Type Members

1.  final class BloopClassFileManager extends ClassFileManager
2.  final class BloopClasspathEntryLookup extends PerClasspathEntryLookup
3.  abstract class CompileBackgroundTasks extends AnyRef
4.  case class CompileInputs(scalaInstance: ScalaInstance, compilerCache: CompilerCache, sources: Array[AbsolutePath], classpath: Array[AbsolutePath], uniqueInputs: UniqueCompileInputs, out: CompileOutPaths, baseDirectory: AbsolutePath, scalacOptions: Array[String], javacOptions: Array[String], compileOrder: CompileOrder, classpathOptions: ClasspathOptions, previousResult: PreviousResult, previousCompilerResult: Result, reporter: ZincReporter, logger: ObservedLogger[Logger], mode: CompileMode, dependentResults: Map[File, PreviousResult], cancelPromise: Promise[Unit], tracer: BraveTracer, ioScheduler: Scheduler, ioExecutor: Executor, invalidatedClassFilesInDependentProjects: Set[File], generatedClassFilePathsInDependentProjects: Map[String, File]) extends Product with Serializable
5.  sealed trait CompileMode extends AnyRef

   Defines the mode in which compilation should run.

6.  case class CompileOutPaths(analysisOut: AbsolutePath, genericClassesDir: AbsolutePath, externalClassesDir: AbsolutePath, internalReadOnlyClassesDir: AbsolutePath) extends Product with Serializable
7.  case class CompileProducts(readOnlyClassesDir: Path, newClassesDir: Path, resultForDependentCompilationsInSameRun: PreviousResult, resultForFutureCompilationRuns: PreviousResult, invalidatedCompileProducts: Set[File], generatedRelativeClassFilePaths: Map[String, File], definedMacroSymbols: Array[String]) extends Product with Serializable

   Collects the products generated during the compilation of a project.

   Collects the products generated during the compilation of a project.

   It has two previous results. The first is to be used by the projects that depend on this compilation and are being compiled during this run. This result is used because it contains class file locations referring to both classes directories and because these two classes directories will be in the dependency classpath of dependent compilations.

   The latter previous result is used for future client compilations. Future compilations will not see the readOnlyClassesDir and newClassesDir in this abstraction, but instead see an aggregated read-only classes directory. newClassesDir will become this read-only classes directory by the time of that compilation because all compilation products (class files, semanticdb files, sjsir files, tasty files, nir files, etc) in the current readOnlyClassesDir that are not in newClassesDir will be copied over. Therefore,the result that is used for compilation will have all class file references rebased to newClassesDir.

   We use different previous results because we want to remove the cost of copying class files from readOnlyClassesDir to newClassesDir before starting dependent compilations. This scheme allows us to be fast and perform as much IO work in the background as possible.

8.  final class CompilerCache extends AnyRef
9.  abstract class CompilerOracle extends AnyRef

   A compiler oracle is an entity that provides answers to questions that come up during the compilation of build targets.

   A compiler oracle is an entity that provides answers to questions that come up during the compilation of build targets. The oracle is an entity capable of synchronizing and answering questions critical for deduplicating and running compilations concurrently.

   For example, if a project wants to know something about the compilation of its dependencies, the oracle would be the right place to create a method that provides answers.

   The compiler oracle is created every time a project compilation is scheduled. Depending on the implementation, it can know both global information such as all the ongoing compilations happening in the build server, local data such as how a target is being compiled or both.

10.  sealed trait ComponentLock extends GlobalLock
11.  sealed trait JavaSignal extends AnyRef

    Signals the Zinc internals whether Java compilation should be attempted or not.

    Signals the Zinc internals whether Java compilation should be attempted or not.

    This signal is completed by Bloop when all the Scala compilations of dependent projects have been successful. If they haven't, then the java signal will be FailFastCompilation with the list of the projects that failed.

    The reason why we need a java signal is because pipelining may start the compilation of dependent projects earlier than the compilation of the dependent projects have compiled. This is okay for dependent Scala projects because they can be compiled against the public interfaces extracted from the Scala pickles, but it's not okay for the java compilation because Java code may have dependencies on Scala code, and for Javac to compile successfully it needs to read the Scala code public APIs from class files (which means the dependent projects need to have finished successfully).

12.  case class PartialCompileProducts(readOnlyClassesDir: AbsolutePath, newClassesDir: AbsolutePath, definedMacroSymbols: Array[String]) extends Product with Serializable

    Collects the partial compile products generated after typechecking but before the end of compilation of a project.

13.  final class ScalaInstance extends xsbti.compile.ScalaInstance
14.  case class UniqueCompileInputs(sources: Vector[HashedSource], classpath: Vector[FileHash], options: Vector[String], scalaJars: Vector[String], originProjectPath: String) extends CacheHashCode with Product with Serializable