suspend fun createProject()

in plugin-bazel/src/main/kotlin/org/jetbrains/bazel/sync/workspace/mapper/normal/AspectBazelProjectMapper.kt [93:235]
137 lines of code
3 McCabe index (conditional complexity)

  suspend fun createProject(
    allTargets: Map<Label, TargetInfo>,
    rootTargets: Set<Label>,
    workspaceContext: WorkspaceContext,
    featureFlags: FeatureFlags,
    repoMapping: RepoMapping,
    hasError: Boolean,
  ): BazelResolvedWorkspace {
    languagePluginsService.all.forEach { it.prepareSync(allTargets.values.asSequence(), workspaceContext) }
    val dependencyGraph =
      measure("Build dependency tree") {
        DependencyGraph(rootTargets, allTargets)
      }
    val (targetsToImport, targetsAsLibraries) =
      measure("Select targets") {
        val targetsAtDepth =
          dependencyGraph
            .allTargetsAtDepth(
              workspaceContext.importDepth,
              isExternalTarget = { !isTargetTreatedAsInternal(it.assumeResolved(), repoMapping) },
              targetSupportsStrictDeps = { id -> allTargets[id]?.let { targetSupportsStrictDeps(it) } == true },
              isWorkspaceTarget = { id ->
                allTargets[id]?.let { target ->
                  target.sourcesCount > 0 && isWorkspaceTarget(target, repoMapping, featureFlags)
                } == true
              },
            )
        val (targetsToImport, nonWorkspaceTargets) =
          targetsAtDepth.targets.partition {
            isWorkspaceTarget(it, repoMapping, featureFlags)
          }
        val (jvmDirectDependencies, nonJvmDirectDependencies) = targetsAtDepth.directDependencies.partition { it.hasJvmTargetInfo() }
        val jvmLibraries = (nonWorkspaceTargets + jvmDirectDependencies).associateBy { it.label() }
        (targetsToImport + nonJvmDirectDependencies).asSequence() to jvmLibraries
      }
    val interfacesAndBinariesFromTargetsToImport =
      measure("Collect interfaces and classes from targets to import") {
        collectInterfacesAndClasses(targetsToImport)
      }
    val outputJarsLibraries =
      measure("Create output jars libraries") {
        calculateOutputJarsLibraries(targetsToImport)
      }
    val annotationProcessorLibraries =
      measure("Create AP libraries") {
        annotationProcessorLibraries(targetsToImport)
      }
    val kotlinStdlibsMapper =
      measure("Create kotlin stdlibs") {
        calculateKotlinStdlibsMapper(targetsToImport, dependencyGraph)
      }
    val kotlincPluginLibrariesMapper =
      measure("Create kotlinc plugin libraries") {
        calculateKotlincPluginLibrariesMapper(targetsToImport)
      }
    val scalaLibrariesMapper =
      measure("Create scala libraries") {
        calculateScalaLibrariesMapper(targetsToImport)
      }
    val librariesFromDeps =
      measure("Merge libraries from deps") {
        concatenateMaps(
          outputJarsLibraries,
          annotationProcessorLibraries,
          kotlinStdlibsMapper,
          kotlincPluginLibrariesMapper,
          scalaLibrariesMapper,
        )
      }
    val librariesFromDepsAndTargets =
      measure("Libraries from targets and deps") {
        createLibraries(targetsAsLibraries) +
          librariesFromDeps.values
            .flatten()
            .distinct()
            .associateBy { it.label }
      }
    val extraLibrariesFromJdeps =
      measure("Libraries from jdeps") {
        jdepsLibraries(
          targetsToImport.associateBy { it.label() },
          librariesFromDeps,
          librariesFromDepsAndTargets,
          interfacesAndBinariesFromTargetsToImport,
        )
      }
    val librariesToImport =
      measure("Merge all libraries") {
        librariesFromDepsAndTargets +
          extraLibrariesFromJdeps.values.flatten().associateBy { it.label }
      }

    val extraLibraries = concatenateMaps(librariesFromDeps, extraLibrariesFromJdeps)

    val targets =
      measure("create intermediate targets") {
        // Use targetsToImport here instead of allTargets here to respect import_depth
        targetsToImport.mapNotNull { it.toIntermediateData(workspaceContext, extraLibraries) }.toList()
      }

    val highPrioritySources =
      if (this.featureFlags.isSharedSourceSupportEnabled) {
        emptySet()
      } else {
        targets
          .filter { !it.tags.hasLowSharedSourcesPriority() }
          .flatMap { it.sources }
          .map { it.path }
          .toSet()
      }

    val rawTargets = measure("create raw targets") { createRawBuildTargets(targets, highPrioritySources, repoMapping, dependencyGraph) }
    val nonModuleRawTargets = measure("create non module raw targets") {
      val nonModuleTargets =
        createNonModuleTargets(
          allTargets,
          dependencyGraph,
          repoMapping,
          workspaceContext,
        )
      nonModuleTargets.map { it.toBuildTarget() }
    }

    val workspaceTargets = rawTargets.associateByTo(mutableMapOf()) { target -> target.id }
    nonModuleRawTargets.forEach { target -> workspaceTargets.putIfAbsent(target.id, target) }
    return BazelResolvedWorkspace(
      targets = workspaceTargets.values.toList(),
      libraries =
        librariesToImport.values.map {
          LibraryItem(
            id = it.label,
            dependencies = it.dependencies,
            ijars = it.interfaceJars.toList(),
            jars = it.outputs.toList(),
            sourceJars = it.sources.toList(),
            mavenCoordinates = it.mavenCoordinates,
            containsInternalJars = it.containsInternalJars,
            isLowPriority = it.isLowPriority,
          )
        },
      hasError = hasError,
    )
  }