public Iterable getNodes()

in sources/java-incremental-compilation/jvm-inc-builder/src/com/intellij/tools/build/bazel/jvmIncBuilder/impl/OutputSinkImpl.java [101:178]
69 lines of code
14 McCabe index (conditional complexity)

  public Iterable<NodeWithSources> getNodes() {
    Map<NodeSource, Set<Usage>> fileLocalUsages = new HashMap<>();
    Set<NodeSource> registeredSources = new HashSet<>();

    for (BuilderWithSources bs : myBuilders) {
      JvmClassNodeBuilder builder = bs.builder();
      Iterable<NodeSource> sources = bs.sources();
      Iterators.collect(sources, registeredSources);

      JvmNodeReferenceID nodeID = builder.getReferenceID();
      String nodeName = nodeID.getNodeName();
      addConstantUsages(builder, nodeName, myConstantRefs.remove(nodeName));
      Collection<String> classImports = myClassImportRefs.remove(nodeName);
      Collection<String> staticImports = myStaticImportRefs.remove(nodeName);
      if (classImports != null || staticImports != null) {
        addImportUsages(builder, classImports != null? classImports : Set.of(), staticImports != null? staticImports : Set.of());
      }
      Set<Usage> additionalUsages = myAdditionalUsages.remove(nodeName);
      if (additionalUsages != null) {
        for (Usage usage : additionalUsages) {
          builder.addUsage(usage);
        }
      }

      var node = builder.getResult();

      Iterable<LookupNameUsage> lookups = Iterators.flat(Iterators.map(node.getMetadata(KotlinMeta.class), meta -> {
        KmDeclarationContainer container = meta.getDeclarationContainer();
        final JvmNodeReferenceID owner;
        LookupNameUsage clsUsage = null;
        if (container instanceof KmPackage) {
          owner = new JvmNodeReferenceID(JvmClass.getPackageName(node.getName()));
        }
        else if (container instanceof KmClass) {
          owner = new JvmNodeReferenceID(((KmClass)container).getName());
          String ownerName = owner.getNodeName();
          String scopeName = JvmClass.getPackageName(ownerName);
          String symbolName = scopeName.isEmpty()? ownerName : ownerName.substring(scopeName.length() + 1);
          clsUsage = new LookupNameUsage(scopeName, symbolName);
        }
        else {
          owner = null;
        }
        if (owner == null) {
          return Collections.emptyList();
        }
        Iterable<LookupNameUsage> memberLookups =
          Iterators.map(Iterators.unique(Iterators.flat(Iterators.map(container.getFunctions(), KmFunction::getName), Iterators.map(container.getProperties(), KmProperty::getName))), name -> new LookupNameUsage(owner, name));
        return clsUsage == null? memberLookups : Iterators.flat(Iterators.asIterable(clsUsage), memberLookups);
      }));

      for (LookupNameUsage lookup : lookups) {
        for (NodeSource src : sources) {
          fileLocalUsages.computeIfAbsent(src, s -> new HashSet<>()).add(lookup);
        }
      }

      myNodes.add(new NodeWithSources(node, sources));
    }
    myBuilders.clear();

    for (Map.Entry<NodeSource, Set<Usage>> entry : myPerSourceAdditionalUsages.entrySet()) {
      NodeSource src = entry.getKey();
      if (!registeredSources.contains(src)) {
        // create synthetic FileNode instances for those sources only, that have at least one compiled ClassNode associated
        continue;
      }
      Set<Usage> usages = entry.getValue();
      Set<Usage> selfUsages = fileLocalUsages.get(src);
      if (selfUsages != null) {
        usages.removeAll(selfUsages);
      }
      myNodes.add(new NodeWithSources(new FileNode(src.toString(), usages), List.of(src)));
    }
    myPerSourceAdditionalUsages.clear();

    return myNodes;
  }