p

xsbt

package xsbt

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. final class API extends Compat with GlobalHelpers
  2. final class Analyzer extends LocateClassFile
  3. class BenchmarkBase extends AnyRef
    Annotations
    @State()
  4. case class BenchmarkProject (repo: String, hash: String, subprojects: Seq[String], useJavaCp: Boolean = true) extends Product with Serializable

    Represent a project on which to run benchmarks.

  5. sealed abstract class CallbackGlobal extends Global

    Defines the interface of the incremental compiler hiding implementation details.

  6. trait ClassName extends Compat

    Utility methods for creating (source|binary) class names for a Symbol.

  7. class ColdScalacBenchmark extends ScalacBenchmark
    Annotations
    @State() @BenchmarkMode() @OutputTimeUnit() @Fork()
  8. abstract class Compat extends AnyRef
  9. final class CompilerInterface extends AnyRef
  10. class ConsoleInterface extends AnyRef
  11. final class Dependency extends LocateClassFile with GlobalHelpers

    Extracts dependency information from each compilation unit.

    Extracts dependency information from each compilation unit.

    This phase detects all the dependencies both at the term and type level.

    When dependency symbol is processed, it is mapped back to either source file where it's defined in (if it's available in current compilation run) or classpath entry where it originates from. The Symbol -> Classfile mapping is implemented by LocateClassFile that we inherit from.

  12. class ExtractAPI [GlobalType <: Global] extends Compat with ClassName with GlobalHelpers

    Extracts full (including private members) API representation out of Symbols and Types.

    Extracts full (including private members) API representation out of Symbols and Types.

    API for each class is extracted separately. Inner classes are represented as an empty (without members) member of the outer class and as a separate class with full API representation. For example:

    class A { class B { def foo: Int = 123 } }

    Is represented as:

    // className = A class A { class B } // className = A.B class A.B { def foo: Int }

    Each compilation unit should be processed by a fresh instance of this class.

    NOTE: This class extract *full* API representation. In most of other places in the incremental compiler, only non-private (accessible from other compilation units) members are relevant. Other parts of the incremental compiler filter out private definitions before processing API structures. Check SameAPI for an example.

  13. class ExtractUsedNames [GlobalType <: CallbackGlobal] extends Compat with ClassName with GlobalHelpers

    Extracts simple names used in given compilation unit.

    Extracts simple names used in given compilation unit.

    Extracts simple (unqualified) names mentioned in given in non-definition position by collecting all symbols associated with non-definition trees and extracting names from all collected symbols. Also extract the names of the types of non-definition trees (see source-dependencies/types-in-used-names-* and source-dependencies/as-seen-from-* for examples where this is required).

    If given symbol is mentioned both in definition and in non-definition position (e.g. in member selection) then that symbol is collected. It means that names of symbols defined and used in the same compilation unit are extracted. We've considered not extracting names of those symbols as an optimization strategy. It turned out that this is not correct. Check https://github.com/gkossakowski/sbt/issues/3 for an example of scenario where it matters.

    All extracted names are returned in _decoded_ form. This way we stay consistent with the rest of incremental compiler which works with names in decoded form.

    Names mentioned in Import nodes are handled properly but require some special logic for two reasons:

    1. The termSymbol of Import nodes point to the symbol of the prefix it imports from (not the actual members that we import, that are represented as names). 2. ImportSelector is not subtype of Tree therefore is not processed by Tree.foreach.

    Another type of tree nodes that requires special handling is TypeTree. TypeTree nodes has a little bit odd representation:

    1. TypeTree.hasSymbol always returns false even when TypeTree.symbol returns a symbol 2. The original tree from which given TypeTree was derived is stored in TypeTree.original but Tree.forech doesn't walk into original tree so we missed it

    The tree walking algorithm walks into TypeTree.original explicitly.

  14. trait GlobalHelpers extends AnyRef
  15. class HotScalacBenchmark extends ScalacBenchmark
    Annotations
    @State() @BenchmarkMode() @OutputTimeUnit() @Warmup() @Measurement() @Fork()
  16. final class IPC extends AnyRef
  17. class InteractiveConsoleFactory extends xsbti.InteractiveConsoleFactory
  18. class InteractiveConsoleInterface extends xsbti.InteractiveConsoleInterface
  19. case class InteractiveConsoleResponse (result: InteractiveConsoleResult, output: String) extends xsbti.InteractiveConsoleResponse with Product with Serializable
  20. class InterfaceCompileCancelled extends CompileCancelled
  21. class InterfaceCompileFailed extends CompileFailed
  22. class LocalToNonLocalClass [G <: CallbackGlobal] extends AnyRef

    A memoized lookup of an enclosing non local class.

    A memoized lookup of an enclosing non local class.

    Let's consider an example of an owner chain:

    pkg1 <- pkg2 <- class A <- object B <- class C <- def foo <- class Foo <- class Bar

    For an object, we work with its moduleClass so we can refer to everything as classes.

    Classes A, B, C are non local so they are mapped to themselves. Classes Foo and Bar are local because they are defined within method foo.

    Let's define non local class more precisely. A non local class is a class that is owned by either a package or another non local class. This gives rise to a recursive definition of a non local class that is used in the implementation of the mapping.

    Thanks to memoization, the amortized cost of a lookup is O(1). We amortize over lookups of all class symbols in the current compilation run.

    Additionally, you can query whether a given class is local. Check isLocal's documentation.

  23. abstract class LocateClassFile extends Compat with ClassName

    Contains utility methods for looking up class files corresponding to Symbols.

  24. case class ProjectSetup (subproject: String, at: File, compilationInfo: CompilationInfo, runGenerator: Generator) extends Product with Serializable

    Represent the setup for a concrete subproject of a BenchmarkProject.

  25. class ScalacBenchmark extends BenchmarkBase
  26. class ScaladocInterface extends AnyRef
  27. class WarmScalacBenchmark extends ScalacBenchmark
    Annotations
    @State() @BenchmarkMode() @OutputTimeUnit() @Warmup() @Measurement() @Fork()
  28. sealed class ZincCompiler extends CallbackGlobal with ZincGlobalCompat

    Defines the implementation of Zinc with all its corresponding phases.

  29. final class ZincCompilerRangePos extends ZincCompiler with RangePositions
  30. trait ZincGlobalCompat extends AnyRef

    Defines compatibility utils for ZincCompiler.

  31. case class ZincSetup (result: Result[List[ProjectSetup]]) extends Product with Serializable

    Consist of the setups for every subproject of a ProjectBenchmark.

Ungrouped