private def compile()

in src/org/jetbrains/jps/ProjectBuilder.groovy [320:428]
99 lines of code
16 McCabe index (conditional complexity)

  private def compile(ModuleChunk chunk, boolean tests, Collection<StringCache.S> files, Backend callback, ProjectWrapper pw) {
    List<String> chunkSources = filterNonExistingFiles(tests ? chunk.testRoots : chunk.sourceRoots, true)
    if (chunkSources.isEmpty()) return

    List<String> sourceFiles = []

    if (files != null) {
      files.each {
        sourceFiles << pw.getAbsolutePath(it.value)
      }
    }

    if (!dryRun) {
      List<String> chunkClasspath = ProjectPaths.getPathsList(getProjectPaths().getClasspathFiles(chunk, ClasspathKind.compile(tests), files == null))

      List sourceRootsWithDependencies = getProjectPaths().getSourcePathsForModuleWithDependents(chunk, tests)
      Map<ModuleBuildState, ModuleChunk> states = new HashMap<ModuleBuildState, ModuleChunk>()
      def chunkState = new ModuleBuildState(
              iterated: false,
              loader: null,
              formInstrumenter: null,
              tests: tests,
              projectWrapper: pw,
              incremental: files != null,
              callback: callback,
              sourceFiles: sourceFiles,
              sourceRoots: chunkSources,
              excludes: computeExcludes(chunk.elements, chunkSources),
              classpath: chunkClasspath,
              sourceRootsFromModuleWithDependencies: sourceRootsWithDependencies,
      )
      if (arrangeModuleCyclesOutputs) {
        chunk.modules.each {
          List<String> sourceRoots = filterNonExistingFiles(tests ? it.testRoots : it.sourceRoots, false)
          if (!sourceRoots.isEmpty()) {
            def state = new ModuleBuildState(
                    iterated: false,
                    loader: null,
                    formInstrumenter: null,
                    tests: tests,
                    projectWrapper: pw,
                    incremental: chunkState.incremental,
                    callback: callback,
                    sourceFiles: sourceFiles,
                    sourceRoots: sourceRoots,
                    excludes: computeExcludes([it], sourceRoots),
                    classpath: chunkClasspath,
                    targetFolder: createOutputFolder(it.name, it, tests),
                    sourceRootsFromModuleWithDependencies: sourceRootsWithDependencies
            )
            states[state] = new ModuleChunk(it)
          }
        }
        if (chunk.modules.size() > 1) {
          chunkState.targetFolder = getTempDirectoryPath(chunk.name + (tests ? "_tests" : ""))
          binding.ant.mkdir(dir: chunkState.targetFolder)
          chunkClasspath.add(0, chunkState.targetFolder)
          chunkState.tempRootsToDelete << chunkState.targetFolder
        }
      }
      else {
        chunkState.targetFolder = createOutputFolder(chunk.name, chunk.representativeModule(), tests)
        states[chunkState] = chunk
      }

      listeners*.onCompilationStarted(chunk)

      try {
        builders().each {ModuleBuilder builder ->
          listeners*.onModuleBuilderStarted(builder, chunk)
          if (arrangeModuleCyclesOutputs && chunk.modules.size() > 1 && builder instanceof ModuleCycleBuilder) {
            ((ModuleCycleBuilder) builder).preprocessModuleCycle(chunkState, chunk, this)
          }
          states.keySet().each {
            builder.processModule(it, states[it], this)
          }
          listeners*.onModuleBuilderFinished(builder, chunk)
        }
      }
      catch (Exception e) {
        final String reason = e.toString();

        if (pw != null) {
          chunk.modules.each {
            Reporter.reportBuildFailure(it, tests, reason)
          }
        }

        throw e;
      }

      states.keySet().each {
        it.tempRootsToDelete.each {
          BuildUtil.deleteDir(this, it)
        }
      }
      chunkState.tempRootsToDelete.each {
        BuildUtil.deleteDir(this, it)
      }
      listeners*.onCompilationFinished(chunk)
    }

    chunk.modules.each {
      if (pw != null) {
        Reporter.reportBuildSuccess(it, tests)
      }
      exportProperty("module.${it.name}.output.${tests ? "test" : "main"}", getModuleOutputFolder(it, tests))
    }
  }