trait APIChange extends AnyRef

trait AnalysisContents extends AnyRef

Defines an analysis file that contains information about every incremental compile.

This information can be persisted using an AnalysisStore.

trait AnalysisStore extends AnyRef

Defines a store interface that provides analysis read and write capabilities to users.

The store is a backend-independent interface that allows implementors to decide how the analysis stores are read and written before or after every incremental compile.

The implementations of AnalysisStore live in interfaces extending this one.

trait AuxiliaryClassFiles extends AnyRef

Interface that associates a class file with other corresponding produced files, for instance .tasty files or .sjsir files.

This class is meant to be used inside the ClassFileManager to manage auxiliary files.

ClassFileManagers are forgiving on auxiliary files that do not exist.

trait CachedCompiler extends AnyRef

Define the interface of a cached Scala compiler that can be run.

This cached compiler hides the implementation of a compiler by just defining two operations: #commandArguments(File[]) and DependencyChanges, AnalysisCallback, Logger, Reporter, CompileProgress).

trait CachedCompilerProvider extends AnyRef

Represent a provider that creates cached Scala compilers from a Scala instance.

trait Changes[T] extends AnyRef

Defines an interface to query for changes of certain items that have an effect on incremental compilation.

The common use case for this interface is to detect added, removed, unmodified and changed source files.

trait ClassFileManager extends AnyRef

Represent the interface to manage the generated class files by the Scala or Java compilers.

Represent the interface to manage the generated class files by the Scala or Java compilers. The class file manager is responsible for providing operations to users to allow them to have a fine-grained control over the generated class files and how they are generated/deleted.

This class is meant to be used once per compilation run.

abstract class ClassFileManagerType extends Serializable

This code is generated using sbt-contraband.

final class ClasspathOptions extends Serializable

Define modifications to classpaths based on the ScalaInstance used for compilation.

Define modifications to classpaths based on the ScalaInstance used for compilation. This class tells how to instrument the classpaths given certain Scala compiler-related parameters. Usually, values are all false for Java compilation.

trait CompileAnalysis extends Serializable

Represents the analysis interface of an incremental compilation.

The analysis interface conforms the public API of the Analysis files that contain information about the incremental compilation of a project.

final class CompileOptions extends Serializable

Compilation options

sealed abstract final class CompileOrder extends Enum[CompileOrder]

Define the order in which Scala and Java compilation should happen.

This compilation order matters when the sources to be compiled are both Scala and Java sources, in which case the Zinc compiler needs a strategy to deal with the compilation order. Therefore, this setting has no effect if only Java or Scala sources are being compiled.

trait CompileProgress extends AnyRef

An API for reporting when files are being compiled.

This design is tied to the Scala compiler but it is used by the Java compiler too, check the docs of the methods.

final class CompileResult extends AnalysisContents with Serializable

The result of running the incremental compilation.

trait CompilerBridgeProvider extends AnyRef

Defines an interface for users to get the compiler bridge for a given Scala version.

The implementors of this interface will retrieve the compiler bridge following different mechanisms. For example, sbt implements this to use LM to resolve the sources for a given Scala version, which Zinc then compiles and defines an sbt component, which is reused across different sbt projects.

trait CompilerInterface2 extends AnyRef

Interface for running compilation.

Interface for running compilation. An implementation is loaded using java.util.ServiceLoader.

final class Compilers extends Serializable

The instances of Scalac/Javac used to compile the current project.

trait ConsoleInterface1 extends AnyRef

Console Interface as of Zinc 1.2.0.

Console Interface as of Zinc 1.2.0. An implementation is loaded using java.util.ServiceLoader.

class DefaultExternalHooks extends ExternalHooks

trait DefinesClass extends AnyRef

Determine whether a classpath entry contains a class.

The corresponding classpath entry is not exposed by this interface.

final class DeleteImmediatelyManagerType extends ClassFileManagerType with Serializable

Constructs a minimal ClassfileManager that immediately deletes class files when requested.

Constructs a minimal ClassfileManager that immediately deletes class files when requested. This is the default classfile manager if no type is provided in incremental options.

trait DependencyChanges extends AnyRef

Define the changes that can occur to the dependencies of a given compilation run.

trait ExternalHooks extends AnyRef

Defines hooks that can be user-defined to modify the behaviour of internal components of the incremental compiler.

final class FileHash extends Serializable

This code is generated using sbt-contraband.

trait GlobalsCache extends AnyRef

Define operations that let us retrieve cached compiler instances for the current Java Virtual Machine.

final class IncOptions extends Serializable

Represents all configuration options for the incremental compiler itself and not the underlying Java/Scala compiler.

final class IncToolOptions extends Serializable

Define the component that manages the generated class files and defines the configuration options for an incremental compiler.

Define the component that manages the generated class files and defines the configuration options for an incremental compiler. This component is used by any Java compiler that implements xsbti.compile.JavaTools and they should return empty values by default because the incremental tool options are not enabled for Java tools, they are only enabled for Scala's incremental compiler.

class IncToolOptionsUtil extends AnyRef

Define a helper for IncToolOptions that provides information on default class file managers used and gives default incremental compilation options to the user.

The default customized classfile manager and incremental options are empty options because these are disabled by default in Java compilers and Java doc. IncToolOptions are only supposed to be used for the Scala incremental compiler.

trait IncrementalCompiler extends AnyRef

trait InitialChanges extends AnyRef

final class Inputs extends Serializable

Configures a single compilation of a single set of sources.

trait InvalidationProfiler extends AnyRef

trait JavaCompiler extends JavaTool

Represent the interface of a Java compiler.

trait JavaTool extends AnyRef

Represent a bare metal interface around one of the java tools, either the Java compiler (javac) or the Javadoc generator.

The main purpose of this interface is to abstract over the local invocation of the Java toolchain and forked invocation via process.

trait JavaTools extends AnyRef

Represent an interface of the toolchain of Java compilation that gives access javadoc generation and Java compilation.

trait Javadoc extends JavaTool

Represent the interface of a Javadoc generator.

final class MiniOptions extends Serializable

Compilation options.

Compilation options. This is used as part of CompileSetup.

final class MiniSetup extends Serializable

This is used as part of CompileResult.

trait MultipleOutput extends Output

Represents a mapping of several outputs depending on the source directory.

This option is used only by the Scala compiler.

trait Output extends Serializable

Define an abstract interface that represents the output of the compilation.

Inheritors are SingleOutput with a global output directory and MultipleOutput that specifies the output directory per source file.

These two subclasses exist to satisfy the Scala compiler which accepts both single and multiple targets. These targets may depend on the sources to be compiled.

Note that Javac does not support multiple output and any attempt to use it will result in a runtime exception.

This class is used both as an input to the compiler and as an output of the xsbti.compile.CompileAnalysis.

trait OutputGroup extends Serializable

Define the interface of a group of outputs.

trait PerClasspathEntryLookup extends AnyRef

Define the interface to look up mapped data structures and query classpath entries This interface gives answers to classpath-related questions like:

- Is this class defined in this classpath entry?

This interface also allows you to get the relation between a given classpath entry and its existing CompileAnalysis instance.

The classpath entry can be either a JAR file or a given directory, as per the Java Language Specification.

final class PreviousResult extends Serializable

The previous source dependency analysis result from compilation.

trait RunProfiler extends AnyRef

trait ScalaCompiler extends AnyRef

Represent the interface of a Scala compiler.

trait ScalaInstance extends AnyRef

A Scala instance encapsulates all the information that is bound to a concrete Scala version, like the ClassLoader or all the JARs required for Scala compilation: library jar, compiler jar and others.

Both a ClassLoader and the jars are required because the compiler's boot classpath requires the location of the library and compiler jar on the classpath to compile any Scala program and macros.

NOTE: A "jar" can actually be any valid classpath entry.

trait ScaladocInterface1 extends AnyRef

Scaladoc Interface as of Zinc 1.2.0.

Scaladoc Interface as of Zinc 1.2.0. An implementation is loaded using java.util.ServiceLoader.

trait ScaladocInterface2 extends AnyRef

Scaladoc Interface as of Zinc 1.4.0.

Scaladoc Interface as of Zinc 1.4.0. An implementation is loaded using java.util.ServiceLoader.

final class Setup extends Serializable

Configures incremental recompilation.

trait SingleOutput extends Output

Represent a single output directory where the Zinc incremental compiler will store all the generated class files by Java and Scala sources.

final class TransactionalManagerType extends ClassFileManagerType with Serializable

Constructs a transactional ClassFileManager implementation that restores class files to the way they were before compilation if there is an error.

Constructs a transactional ClassFileManager implementation that restores class files to the way they were before compilation if there is an error. Otherwise, it keeps the successfully generated class files from the new compilation.

trait UsedName extends AnyRef

class WrappedClassFileManager extends ClassFileManager

Defines a classfile manager that composes the operation of two classfile manager, one being the internal classfile manager (the one used by the compiler) and the other one being the external classfile manager (a customizable, build tool-defined class file manager to control which class files should be notified/removed/generated aside from the ones covered by the internal classfile manager).

Packages

compile

package compile

Type Members

Ungrouped

Packages

compile 

package compile

Type Members

Ungrouped

compile