Packages

object erasure extends Erasure

Definition Classes
Global → Transforms
Source
Global.scala
Content Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. erasure
  2. Erasure
  3. TypeAdaptingTransformer
  4. TypingTransformers
  5. Analyzer
  6. AnalyzerPlugins
  7. MacroAnnotationAttachments
  8. StdAttachments
  9. ContextErrors
  10. SplainErrors
  11. TypeDiagnostics
  12. SplainDiagnostics
  13. SplainFormatting
  14. SplainFormatters
  15. NamesDefaults
  16. Macros
  17. Helpers
  18. Traces
  19. MacroRuntimes
  20. JavaReflectionRuntimes
  21. Unapplies
  22. SyntheticMethods
  23. TreeDSL
  24. EtaExpansion
  25. Implicits
  26. SplainData
  27. Infer
  28. Checkable
  29. Typers
  30. PatternTypers
  31. TypersTracking
  32. Tags
  33. Adaptations
  34. Namers
  35. MethodSynthesis
  36. Contexts
  37. Erasure
  38. InfoTransform
  39. Transform
  40. SubComponent
  41. AnyRef
  42. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. trait JavaReflectionResolvers extends AnyRef
    Definition Classes
    JavaReflectionRuntimes
  2. class MacroRuntimeResolver extends tools.nsc.typechecker.Analyzer.JavaReflectionResolvers
    Definition Classes
    MacroRuntimes
  3. trait BoxingErasure extends ErasureMap
    Definition Classes
    Erasure
  4. type Checkability = Int
    Definition Classes
    Checkable
  5. abstract class ErasureMap extends reflect.internal.SymbolTable.TypeMap
    Definition Classes
    Erasure
  6. type ImportType = Global.ImportType
    Definition Classes
    Contexts
  7. final type InfoPhase = Phase
    Definition Classes
    InfoTransform
    Annotations
    @nowarn()
  8. class JavaErasureMap extends ErasureMap with Scala2JavaArrayErasure
    Definition Classes
    Erasure
  9. type MacroContext = UnaffiliatedMacroContext { val universe: scala.tools.nsc.Global.erasure.global.type }
    Definition Classes
    StdAttachments
  10. type MacroRuntime = (MacroArgs) => Any

    Abstracts away resolution of macro runtimes.

    Abstracts away resolution of macro runtimes.

    Definition Classes
    MacroRuntimes
  11. trait Scala2JavaArrayErasure extends AnyRef
    Definition Classes
    Erasure
  12. class Scala3ErasureMap extends ErasureMap
    Definition Classes
    Erasure
  13. abstract class ScalaErasureMap extends ErasureMap with Scala2JavaArrayErasure
    Definition Classes
    Erasure
  14. trait SpecialScalaErasure extends ErasureMap
    Definition Classes
    Erasure
  15. type UnaffiliatedMacroContext = reflect.macros.contexts.Context

    Carries information necessary to expand the host tree.

    Carries information necessary to expand the host tree. At times we need to store this info, because macro expansion can be delayed until its targs are inferred. After a macro application has been successfully expanded, this attachment is destroyed.

    Definition Classes
    StdAttachments
  16. abstract class StdPhase extends GlobalPhase

    A standard phase template

    A standard phase template

    Definition Classes
    SubComponent
  17. class EnterBridges extends AnyRef
    Definition Classes
    Erasure
  18. class Eraser extends Typer

    The modifier typer which retypes with erased types.

    The modifier typer which retypes with erased types.

    Definition Classes
    Erasure
  19. class ErasureTransformer extends Global.AstTransformer

    The erasure transformer

    The erasure transformer

    Definition Classes
    Erasure
  20. class GenerateBridges extends EnterBridges
    Definition Classes
    Erasure
  21. class UnknownSig extends Exception
    Definition Classes
    Erasure
  22. abstract class TypeAdapter extends AnyRef
    Definition Classes
    TypeAdaptingTransformer
  23. abstract class ThicketTransformer extends TypingTransformer

    A base class for typing transformers that need to perform "thicket expansion".

    A base class for typing transformers that need to perform "thicket expansion". A thicket is the output of a transformation that is flattened into the enclosing block.

    Definition Classes
    TypingTransformers
  24. abstract class TypingTransformer extends Global.AstTransformer
    Definition Classes
    TypingTransformers
  25. trait Adaptation extends AnyRef
    Definition Classes
    Adaptations
  26. trait AnalyzerPlugin extends AnyRef
    Definition Classes
    AnalyzerPlugins
  27. trait MacroPlugin extends AnyRef

    Definition Classes
    AnalyzerPlugins
  28. trait InferCheckable extends AnyRef
    Definition Classes
    Checkable
  29. abstract class AbsAmbiguousTypeError extends Analyzer.AbsTypeError
    Definition Classes
    ContextErrors
  30. sealed abstract class AbsTypeError extends AnyRef
    Definition Classes
    ContextErrors
  31. case class AccessTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.TreeTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  32. case class AmbiguousImplicitTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  33. case class AmbiguousTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  34. final case class ContextWarning(pos: Global.Position, msg: String, cat: WarningCategory, sym: Global.Symbol, actions: List[CodeAction]) extends Product with Serializable
    Definition Classes
    ContextErrors
  35. case class DivergentImplicitTypeError(underlyingTree: Global.Tree, pt0: Global.Type, sym: Global.Symbol) extends Analyzer.TreeTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  36. trait ImplicitsContextErrors extends AnyRef
    Definition Classes
    ContextErrors
  37. trait InferencerContextErrors extends AnyRef
    Definition Classes
    ContextErrors
  38. trait NamerContextErrors extends AnyRef
    Definition Classes
    ContextErrors
  39. case class NormalTypeError(underlyingTree: Global.Tree, errMsg: String, actions: List[CodeAction] = Nil) extends Analyzer.TreeTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  40. case class PosAndMsgTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  41. case class SymbolTypeError(underlyingSym: Global.Symbol, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  42. sealed abstract class TreeTypeError extends Analyzer.AbsTypeError
    Definition Classes
    ContextErrors
  43. case class TypeErrorWithUnderlyingTree(tree: Global.Tree, ex: Global.TypeError) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  44. case class TypeErrorWrapper(ex: Global.TypeError, actions: List[CodeAction] = Nil) extends Analyzer.AbsTypeError with Product with Serializable
    Definition Classes
    ContextErrors
  45. trait TyperContextErrors extends AnyRef
    Definition Classes
    ContextErrors
  46. class Context extends AnyRef

    A motley collection of the state and loosely associated behaviour of the type checker.

    A motley collection of the state and loosely associated behaviour of the type checker. Each Typer has an associated context, and as it descends into the tree new (Typer, Context) pairs are spawned.

    Meet the crew; first the state:

    • A tree, symbol, and scope representing the focus of the typechecker
    • An enclosing context, outer.
    • The current compilation unit.
    • A variety of bits that track the current error reporting policy (more on this later); whether or not implicits/macros are enabled, whether we are in a self or super call or in a constructor suffix. These are represented as bits in the mask contextMode.
    • Some odds and ends: undetermined type parameters of the current line of type inference; contextual augmentation for error messages, tracking of the nesting depth.

    And behaviour:

    • The central point for issuing errors and warnings from the typechecker, with a means to buffer these for use in 'silent' type checking, when some recovery might be possible.
    • Context is something of a Zipper for the tree were are typechecking: it enclosingContextChain is the path back to the root. This is exactly what we need to resolve names (lookupSymbol) and to collect in-scope implicit definitions (implicitss) Supporting these are imports, which represents all Import trees in in the enclosing context chain.
    • In a similar vein, we can assess accessibility (isAccessible.)

    More on error buffering: When are type errors recoverable? In quite a few places, it turns out. Some examples: trying to type an application with/without the expected type, or with/without implicit views enabled. This is usually mediated by Typer.silent, Inferencer#tryTwice.

    Initially, starting from the typer phase, the contexts either buffer or report errors; afterwards errors are thrown. This is configured in rootContext. Additionally, more fine grained control is needed based on the kind of error; ambiguity errors are often suppressed during exploratory typing, such as determining whether a == b in an argument position is an assignment or a named argument, when Inferencer#isApplicableSafe type checks applications with and without an expected type, or when Typer#tryTypedApply tries to fit arguments to a function type with/without implicit views.

    When the error policies entail error/warning buffering, the mutable ContextReporter records everything that is issued. It is important to note, that child Contexts created with make "inherit" the very same ContextReporter instance, whereas children spawned through makeSilent receive a separate, fresh buffer.

    Definition Classes
    Contexts
  47. abstract class ContextReporter extends AnyRef

    A reporter for use during type checking.

    A reporter for use during type checking. It has multiple modes for handling errors.

    The default (immediate mode) is to send the error to the global reporter. When switched into buffering mode via makeBuffering, errors and warnings are buffered and not be reported (there's a special case for ambiguity errors for some reason: those are force to the reporter when context.ambiguousErrors, or else they are buffered -- TODO: can we simplify this?)

    When using the type checker after typers, an error results in a TypeError being thrown. TODO: get rid of this mode.

    To handle nested contexts, reporters share buffers. TODO: only buffer in BufferingReporter, emit immediately in ImmediateReporter

    Definition Classes
    Contexts
  48. final class ImportContext extends Analyzer.Context

    A Context focussed on an Import tree

    A Context focussed on an Import tree

    Definition Classes
    Contexts
  49. class ImportInfo extends AnyRef
    Definition Classes
    Contexts
  50. class ImplicitAnnotationMsg extends AnyRef
    Definition Classes
    Implicits
  51. class ImplicitInfo extends AnyRef

    A class that records an available implicit

    A class that records an available implicit

    Definition Classes
    Implicits
  52. class ImplicitSearch extends Analyzer.Typer with Analyzer.ImplicitsContextErrors

    A class that sets up an implicit search.

    A class that sets up an implicit search. For more info, see comments for inferImplicit.

    Definition Classes
    Implicits
  53. class Message extends AnyRef
    Definition Classes
    Implicits
  54. case class OpenImplicit(info: Analyzer.ImplicitInfo, pt: Global.Type, tree: Global.Tree) extends Product with Serializable

    A class which is used to track pending implicits to prevent infinite implicit searches.

    A class which is used to track pending implicits to prevent infinite implicit searches.

    Definition Classes
    Implicits
  55. class SearchResult extends AnyRef

    The result of an implicit search

    The result of an implicit search

    Definition Classes
    Implicits
  56. final case class AdjustedTypeArgs(okParams: List[Global.Symbol], okArgs: List[Global.Type], undetParams: List[Global.Symbol], allArgs: List[Global.Type]) extends Product with Serializable
    Definition Classes
    Infer
  57. abstract class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable

    The context-dependent inferencer part

    The context-dependent inferencer part

    Definition Classes
    Infer
  58. class NoInstance extends ControlThrowable
    Definition Classes
    Infer
  59. case class CacheAttachment(cache: Map[String, Any]) extends Product with Serializable
    Definition Classes
    MacroAnnotationAttachments
  60. implicit class RichTree extends AnyRef
    Definition Classes
    MacroAnnotationAttachments
  61. case class SymbolCompleterAttachment(info: Global.Type) extends Product with Serializable
    Definition Classes
    MacroAnnotationAttachments
  62. case class SymbolExpansionAttachment(expansion: List[Global.Tree]) extends Product with Serializable
    Definition Classes
    MacroAnnotationAttachments
  63. case class SymbolSourceAttachment(source: Global.Tree) extends Product with Serializable
    Definition Classes
    MacroAnnotationAttachments
  64. class DefMacroExpander extends Analyzer.MacroExpander

    Expands a term macro used in apply role as M(2)(3) in val x = M(2)(3).

    Expands a term macro used in apply role as M(2)(3) in val x = M(2)(3).

    Definition Classes
    Macros
  65. case class Delayed(delayed: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
    Macros
  66. case class Failure(failure: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
    Macros
  67. case class Fallback(fallback: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
    Macros
  68. case class MacroArgs(c: Analyzer.MacroContext, others: List[Any]) extends Product with Serializable

    Calculate the arguments to pass to a macro implementation when expanding the provided tree.

    Calculate the arguments to pass to a macro implementation when expanding the provided tree.

    Definition Classes
    Macros
  69. abstract class MacroExpander extends AnyRef

    Performs macro expansion:

    Performs macro expansion:

    Expandable trees

    A term of one of the following shapes:

    Ident(<term macro>) Select(<any qualifier>, <term macro>) TypeApply(<any of the above>, <targs>) Apply(...Apply(<any of the above>, <args1>)...<argsN>)

    Macro expansion

    First of all macroExpandXXX: 1) If necessary desugars the expandee to fit into the default expansion scheme that is understood by macroExpandWithRuntime / macroExpandWithoutRuntime

    Then macroExpandWithRuntime: 2) Checks whether the expansion needs to be delayed 3) Loads macro implementation using macroMirror 4) Synthesizes invocation arguments for the macro implementation 5) Checks that the result is a tree or an expr bound to this universe

    Finally macroExpandXXX: 6) Validates the expansion against the white list of supported tree shapes 7) Typechecks the result as required by the circumstances of the macro application

    If -Ymacro-debug-lite is enabled, you will get basic notifications about macro expansion along with macro expansions logged in the form that can be copy/pasted verbatim into REPL.

    If -Ymacro-debug-verbose is enabled, you will get detailed log of how exactly this function performs class loading and method resolution in order to load the macro implementation. The log will also include other non-trivial steps of macro expansion.

    returns

    the expansion result if the expansion has been successful, the fallback tree if the expansion has been unsuccessful, but there is a fallback, the expandee unchanged if the expansion has been delayed, the expandee fully expanded if the expansion has been delayed before and has been expanded now, the expandee with an error marker set if the expansion has been cancelled due malformed arguments or implementation the expandee with an error marker set if there has been an error

    Definition Classes
    Macros
  70. case class MacroImplBinding(isBundle: Boolean, isBlackbox: Boolean, className: String, methName: String, signature: List[List[Fingerprint]], targs: List[Global.Tree]) extends Product with Serializable

    Represents all the information that a macro definition needs to know about its implementation.

    Represents all the information that a macro definition needs to know about its implementation. Includes a path to load the implementation via Java reflection, and various accounting information necessary when composing an argument list for the reflective invocation.

    Definition Classes
    Macros
  71. sealed abstract class MacroStatus extends AnyRef
    Definition Classes
    Macros
  72. case class Skipped(skipped: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
    Macros
  73. case class Success(expanded: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
    Definition Classes
    Macros
  74. class ClassMethodSynthesis extends AnyRef
    Definition Classes
    MethodSynthesis
  75. trait MethodSynth extends AnyRef

    There are two key methods in here.

    There are two key methods in here.

    1) Enter methods such as enterGetterSetter are called from Namer with a tree which may generate further trees such as accessors or implicit wrappers. Some setup is performed. In general this creates symbols and enters them into the scope of the owner.

    2) addDerivedTrees is called from Typer when a Template is typed. It completes the job, returning a list of trees with their symbols set to those created in the enter methods. Those trees then become part of the typed template.

    Definition Classes
    MethodSynthesis
  76. class CompleterWrapper extends Analyzer.TypeCompleter

    Wrap an existing completer to do some post/pre-processing of the completed type.

    Wrap an existing completer to do some post/pre-processing of the completed type.

    Definition Classes
    Namers
  77. trait LockingTypeCompleter extends Analyzer.TypeCompleter
    Definition Classes
    Namers
  78. abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors
    Definition Classes
    Namers
  79. class PolyTypeCompleter extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter

    A class representing a lazy type with known type parameters.

    A class representing a lazy type with known type parameters. ctx is the namer context in which the owner is defined.

    Constructing a PolyTypeCompleter for a DefDef creates type skolems for the type parameters and assigns them to the tparams trees.

    Definition Classes
    Namers
  80. abstract class TypeCompleter extends Global.LazyType
    Definition Classes
    Namers
  81. abstract class TypeCompleterBase[T <: Global.Tree] extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter
    Definition Classes
    Namers
  82. class CaseApplyDefaultGetters extends AnyRef
    Definition Classes
    NamesDefaults
  83. class ConstructorDefaultsAttachment extends AnyRef
    Definition Classes
    NamesDefaults
  84. class DefaultsOfLocalMethodAttachment extends AnyRef
    Definition Classes
    NamesDefaults
  85. case class NamedApplyInfo(qual: Option[Global.Tree], targs: List[Global.Tree], vargss: List[List[Global.Tree]], blockTyper: Analyzer.Typer) extends Product with Serializable
    Definition Classes
    NamesDefaults
  86. trait PatternTyper extends AnyRef
    Definition Classes
    PatternTypers
  87. case class MacroExpanderAttachment(original: Global.Tree, desugared: Global.Tree) extends Product with Serializable

    Scratchpad for the macro expander, which is used to store all intermediate data except the details about the runtime.

    Scratchpad for the macro expander, which is used to store all intermediate data except the details about the runtime.

    Definition Classes
    StdAttachments
  88. case class MacroExpansionAttachment(expandee: Global.Tree, expanded: Any) extends Product with Serializable

    Is added by the macro engine to originals and results of macro expansions.

    Is added by the macro engine to originals and results of macro expansions. Stores the original expandee as it entered the macroExpand function.

    Definition Classes
    StdAttachments
  89. case class MacroRuntimeAttachment(delayed: Boolean, typerContext: Analyzer.Context, macroContext: Option[Analyzer.MacroContext]) extends Product with Serializable
    Definition Classes
    StdAttachments
  90. case class OriginalTreeAttachment(original: Global.Tree) extends Product with Serializable

    Marks a tree that has been adapted by typer and sets the original tree that was in place before.

    Marks a tree that has been adapted by typer and sets the original tree that was in place before.

    Keeping track of the original trees were is an important feature for some compiler plugins (like Scalameta) and the incremental compiler (Zinc). In both cases, adapting trees loses information in some sense and do not allow external tools to capture some information stored in user-defined trees that are optimized away by early phases (mostly, typer).

    See how the absence of this attachment blocks Zinc: https://github.com/sbt/zinc/issues/227. Related: https://github.com/scala/scala-dev/issues/340.

    This attachment is, at the moment, only used to keep track of constant-folded constants. It has a generic wording in the hope that in the future can be reused in the same context to keep track of other adapted trees.

    Definition Classes
    StdAttachments
  91. case class SuperArgsAttachment(argss: List[List[Global.Tree]]) extends Product with Serializable

    After being synthesized by the parser, primary constructors aren't fully baked yet.

    After being synthesized by the parser, primary constructors aren't fully baked yet. A call to super in such constructors is just a fill-me-in-later dummy resolved later by parentTypes. This attachment coordinates parentTypes and typedTemplate and allows them to complete the synthesis.

    Definition Classes
    StdAttachments
  92. trait Tag extends AnyRef
    Definition Classes
    Tags
  93. case class TypeDiag(tp: Global.Type, sym: Global.Symbol) extends Ordered[(TypeDiagnostics.this)#TypeDiag] with Product with Serializable
    Definition Classes
    TypeDiagnostics
  94. trait TyperDiagnostics extends AnyRef
    Definition Classes
    TypeDiagnostics
  95. class UnusedPrivates extends Global.Traverser
    Definition Classes
    TypeDiagnostics
  96. class checkUnused extends AnyRef
    Definition Classes
    TypeDiagnostics
  97. sealed abstract class SilentResult[+T] extends AnyRef
    Definition Classes
    Typers
  98. case class SilentResultValue[+T](value: T) extends Analyzer.SilentResult[T] with Product with Serializable
    Definition Classes
    Typers
  99. class SilentTypeError extends Analyzer.SilentResult[Nothing]
    Definition Classes
    Typers
  100. abstract class Typer extends Analyzer.TyperDiagnostics with Analyzer.Adaptation with Analyzer.Tag with Analyzer.PatternTyper with Analyzer.TyperContextErrors
    Definition Classes
    Typers
  101. class ClassForCaseCompanionAttachment extends AnyRef
    Definition Classes
    Unapplies
  102. case class ImplicitError(tpe: Global.Type, candidate: Global.Tree, nesting: Int, specifics: Analyzer.ImplicitErrorSpecifics) extends Product with Serializable
    Definition Classes
    SplainData
  103. sealed trait ImplicitErrorSpecifics extends AnyRef
    Definition Classes
    SplainData
  104. trait SpecialFormatter extends AnyRef
    Definition Classes
    SplainFormatters
  105. case class ImplicitErrorLink(fromTree: Analyzer.ImplicitError, fromHistory: Analyzer.DivergentImplicitTypeError) extends Product with Serializable
    Definition Classes
    SplainFormatting
  106. case class ImplicitErrorTree(error: Analyzer.ImplicitError, children: collection.immutable.Seq[Analyzer.ImplicitErrorTree] = Nil) extends Product with Serializable
    Definition Classes
    SplainFormatting
  107. case class TypeParts(sym: Global.Symbol, tt: Global.Type) extends Product with Serializable
    Definition Classes
    SplainFormatting

Deprecated Type Members

  1. class Phase extends InfoTransform.Phase
    Definition Classes
    InfoTransform
    Annotations
    @nowarn() @deprecated
    Deprecated

    (Since version 2.13.4) use InfoPhase instead

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. lazy val AmbiguousSearchFailure: SearchResult
    Definition Classes
    Implicits
  5. def Delay(expanded: Global.Tree): Delayed
    Definition Classes
    Macros
  6. lazy val DivergentSearchFailure: SearchResult
    Definition Classes
    Implicits
  7. val ImportType: Global.ImportType.type
    Definition Classes
    Contexts
  8. def MacroCantExpand210xMacrosError(internalMessage: String): Nothing
    Definition Classes
    ContextErrors
  9. def MacroCantExpandIncompatibleMacrosError(internalMessage: String): Nothing
    Definition Classes
    ContextErrors
  10. def NoImplicitFoundAnnotation(tree: Global.Tree, param: Global.Symbol): (Boolean, String)

    The implicit not found message from the annotation, and whether it's a supplement message or not.

    The implicit not found message from the annotation, and whether it's a supplement message or not.

    Definition Classes
    ContextErrors
  11. def NoImplicitFoundError(tree: Global.Tree, param: Global.Symbol)(implicit context: Context): Unit
    Definition Classes
    ContextErrors
  12. val NoImplicitInfo: ImplicitInfo

    A sentinel indicating no implicit was found

    A sentinel indicating no implicit was found

    Definition Classes
    Implicits
  13. lazy val SearchFailure: SearchResult
    Definition Classes
    Implicits
  14. def SearchedPrefixImplicitInfo(pre: Global.Type): ImplicitInfo
    Definition Classes
    Implicits
  15. def Skip(expanded: Global.Tree): Skipped
    Definition Classes
    Macros
  16. val _openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.erasure.global.type }]

    Keeps track of macros in-flight.

    Keeps track of macros in-flight. See more informations in comments to openMacros in scala.reflect.macros.whitebox.Context.

    Definition Classes
    Macros
  17. def abstractVarMessage(sym: Global.Symbol): String

    An explanatory note to be added to error messages when there's a problem with abstract var defs

    An explanatory note to be added to error messages when there's a problem with abstract var defs

    Definition Classes
    TypeDiagnostics
  18. final def accessibleOwnerOrParentDefiningMember(member: Global.Symbol, parents: Iterator[Global.Symbol], context: Context): Option[Global.Symbol]

    The goal of this method is to find a class that is accessible (in bytecode) and can be used to select member.

    The goal of this method is to find a class that is accessible (in bytecode) and can be used to select member. - For constructors, it returns the member.owner. We can assume the class is accessible: if it wasn't, the typer would have rejected the program, as the class is referenced in source. - For Scala-defined members it also returns member.owner, all Scala-defined classes are public in bytecode. - For Java-defined members we prefer a direct parent over of the owner, even if the owner is accessible. This way the owner doesn't need to be added as a direct parent, see scala-dev#143.

    Definition Classes
    Erasure
  19. def adaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Global.Tree

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.adaptAnnotations

  20. def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit

    Registers a new analyzer plugin

    Registers a new analyzer plugin

    Definition Classes
    AnalyzerPlugins
  21. def addDefaults(givenArgs: List[Global.Tree], qual: Option[Global.Tree], targs: List[Global.Tree], previousArgss: List[List[Global.Tree]], params: List[Global.Symbol], pos: reflect.internal.util.Position, context: Context): (List[Global.Tree], List[Global.Symbol])

    Extend the argument list givenArgs with default arguments.

    Extend the argument list givenArgs with default arguments. Defaults are added as named arguments calling the corresponding default getter.

    Returns the extended arg list and missing parameters if any.

    Example: given def foo(x: Int = 2, y: String = "def") foo(y = "lt") the argument list (y = "lt") is transformed to (y = "lt", x = foo$default$1())

    Definition Classes
    NamesDefaults
  22. def addMacroPlugin(plugin: MacroPlugin): Unit

    Registers a new macro plugin

    Registers a new macro plugin

    Definition Classes
    AnalyzerPlugins
  23. def addSyntheticMethods(templ: Global.Template, clazz0: Global.Symbol, context: Context): Global.Template

    Add the synthetic methods to case classes.

    Add the synthetic methods to case classes.

    Definition Classes
    SyntheticMethods
  24. final def afterOwnPhase[T](op: => T): T
    Definition Classes
    SubComponent
    Annotations
    @inline()
  25. def allArgsArePositional(a: Array[Int]): Boolean

    returns true if every element is equal to its index

    returns true if every element is equal to its index

    Definition Classes
    NamesDefaults
  26. def allViewsFrom(tp: Global.Type, context: Context, tpars: List[Global.Symbol]): List[(SearchResult, List[Global.TypeConstraint])]

    Find all views from type tp (in which tpars are free)

    Find all views from type tp (in which tpars are free)

    Note that the trees in the search results in the returned list share the same type variables. Ignore their constr field! The list of type constraints returned along with each tree specifies the constraints that must be met by the corresponding type parameter in tpars (for the returned implicit view to be valid).

    tp

    from-type for the implicit conversion

    context

    search implicits here

    tpars

    symbols that should be considered free type variables (implicit search should not try to solve them, just track their constraints)

    Definition Classes
    Implicits
  27. def alternatives(tree: Global.Tree): List[Global.Type]
    Definition Classes
    TypeDiagnostics
  28. def alternativesString(tree: Global.Tree): String
    Definition Classes
    TypeDiagnostics
  29. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  30. implicit def asSimpleName(s: String): SimpleName
    Definition Classes
    SplainFormatters
  31. def attachExpansion(sym: Global.Symbol, trees: List[Global.Tree]): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  32. def attachSource(sym: Global.Symbol, tree: Global.Tree): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  33. def attachedExpansion(sym: Global.Symbol): Option[List[Global.Tree]]
    Definition Classes
    MacroAnnotationAttachments
  34. def attachedSource(sym: Global.Symbol): Global.Tree
    Definition Classes
    MacroAnnotationAttachments
  35. def backupCompleter(sym: Global.Symbol): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  36. final def beforeOwnPhase[T](op: => T): T
    Definition Classes
    SubComponent
    Annotations
    @inline()
  37. def bindMacroImpl(macroDef: Global.Symbol, macroImplRef: Global.Tree): Unit
    Definition Classes
    Macros
  38. def bracket[A](params: collection.immutable.List[A]): String
    Definition Classes
    SplainFormatting
  39. def breakInfix(types: collection.immutable.List[Formatted]): TypeRepr

    Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal.

    Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal. If the expression's length is smaller than the threshold specified via plugin parameter, return a single line.

    Definition Classes
    SplainFormatting
  40. val breakInfixLength: Int
    Definition Classes
    SplainFormatting
  41. def builtinFoundReqMsg(found: Global.Type, req: Global.Type): String
    Definition Classes
    TypeDiagnostics
  42. def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Boolean

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.canAdaptAnnotations

  43. final def caseAccessorName(caseclazz: Global.Symbol, paramName: Global.TermName): Global.TermName

    Does not force the info of caseclazz

    Does not force the info of caseclazz

    Definition Classes
    SyntheticMethods
  44. def caseClassCopyMeth(cdef: Global.ClassDef): Option[Global.DefDef]

    Generates copy methods for case classes.

    Generates copy methods for case classes. Copy only has defaults on the first parameter list, as of scala/bug#5009.

    The parameter types of the copy method need to be exactly the same as the parameter types of the primary constructor. Just copying the TypeTree is not enough: a type C might refer to something else *inside* the class (i.e. as parameter type of copy) than *outside* the class (i.e. in the class parameter list).

    One such example is t0054.scala: class A { case class B(x: C) extends A { def copy(x: C = x) = ... } class C {} } (1) (2)

    The reference (1) to C is A.this.C. The reference (2) is B.this.C - not the same.

    This is fixed with a hack currently. Unapplies.caseClassCopyMeth, which creates the copy method, uses empty TypeTree() nodes for parameter types.

    In Namers.enterDefDef, the copy method gets a special type completer (enterCopyMethod). Before computing the body type of copy, the class parameter types are assigned the copy method parameters.

    This attachment class stores the copy method parameter ValDefs as an attachment in the ClassDef of the case class.

    Definition Classes
    Unapplies
  45. def caseModuleApplyMeth(cdef: Global.ClassDef): Global.DefDef

    The apply method corresponding to a case class

    The apply method corresponding to a case class

    Definition Classes
    Unapplies
  46. def caseModuleDef(cdef: Global.ClassDef): Global.ModuleDef

    The module corresponding to a case class; overrides toString to show the module's name

    The module corresponding to a case class; overrides toString to show the module's name

    Definition Classes
    Unapplies
  47. def caseModuleUnapplyMeth(cdef: Global.ClassDef): Global.DefDef

    The unapply method corresponding to a case class

    The unapply method corresponding to a case class

    Definition Classes
    Unapplies
  48. def changesBaseClasses: Boolean
    Attributes
    protected
    Definition Classes
    InfoTransform
  49. def clearDelayed(): Unit
    Definition Classes
    Macros
  50. final def clearRenamedCaseAccessors(caseclazz: Global.Symbol): Unit
    Definition Classes
    SyntheticMethods
  51. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  52. def companionModuleDef(cdef: Global.ClassDef, parents: List[Global.Tree] = Nil, body: List[Global.Tree] = Nil): Global.ModuleDef
    Definition Classes
    Unapplies
  53. def companionSymbolOf(original: Global.Symbol, ctx: Context): Global.Symbol

    The companion class or companion module of original.

    The companion class or companion module of original. Calling .companionModule does not work for classes defined inside methods.

    !!! Then why don't we fix companionModule? Does the presence of these methods imply all the places in the compiler calling sym.companionModule are bugs waiting to be reported? If not, why not? When exactly do we need to call this method?

    Definition Classes
    Namers
  54. final def compilesToPureInterface(tpSym: Global.Symbol): Boolean

    Does this symbol compile to the underlying platform's notion of an interface, without requiring compiler magic before it can be instantiated?

    Does this symbol compile to the underlying platform's notion of an interface, without requiring compiler magic before it can be instantiated?

    More specifically, we're interested in whether LambdaMetaFactory can instantiate this type, assuming it has a single abstract method. In other words, if we were to mix this trait into a class, it should not result in any compiler-generated members having to be implemented in ("mixed in to") this class (except for the SAM).

    Thus, the type must erase to a java interface, either by virtue of being defined as one, or by being a trait that:

    • is static (explicitouter or lambdalift may add disqualifying members)
    • extends only other traits that compile to pure interfaces (except for Any)
    • has no val/var members

    TODO: can we speed this up using the INTERFACE flag, or set it correctly by construction?

    Definition Classes
    Erasure
  55. def ctorNames(tpe: Global.Type): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  56. def dealias(tpe: Global.Type): Global.Type
    Definition Classes
    SplainFormatting
  57. def decideBreak(flat: FlatType, broken: => BrokenType): TypeRepr
    Definition Classes
    SplainFormatting
  58. def decodeWithKind(name: Global.Name, owner: Global.Symbol): String
    Definition Classes
    TypeDiagnostics
  59. val deconstMap: Global.TypeMap
    Definition Classes
    Erasure
  60. def decreaseMetalevel(tp: Global.Type): Global.Type

    Decreases metalevel of the type, i.e.

    Decreases metalevel of the type, i.e. transforms: * c.Expr[T] to T * Nothing to Nothing * Anything else to NoType

    Definition Classes
    Helpers
    See also

    Metalevels.scala for more information and examples about metalevels

  61. def deepestLevel(chain: collection.immutable.List[ImplicitError]): Int
    Definition Classes
    SplainFormatting
  62. def defaultGetter(param: Global.Symbol, context: Context): Global.Symbol

    For a parameter with default argument, find the method symbol of the default getter.

    For a parameter with default argument, find the method symbol of the default getter.

    Definition Classes
    NamesDefaults
  63. def defaultMacroClassloader: ClassLoader
    Definition Classes
    MacroRuntimes
  64. final def definesMemberAfterErasure(cls: Global.Symbol, member: Global.Symbol): Boolean

    Check if a class defines a member after erasure.

    Check if a class defines a member after erasure. The phase travel is important for trait T extends AClass: after erasure (and in bytecode), T has supertype Object, not AClass.

    Definition Classes
    Erasure
  65. def directUnapplyMember(tp: Global.Type): Global.Symbol

    Returns unapply or unapplySeq if available, without further checks.

    Returns unapply or unapplySeq if available, without further checks.

    Definition Classes
    Unapplies
  66. def disambiguate(ss: List[String]): collection.immutable.List[String]
    Definition Classes
    TypeDiagnostics
  67. def enabled: Boolean

    Is this component enabled? Default is true.

    Is this component enabled? Default is true.

    Definition Classes
    SubComponent
  68. def enclosingMacroPosition: reflect.internal.util.Position
    Definition Classes
    Macros
  69. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  70. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  71. def erasedValueClassArg(tref: Global.TypeRef): Global.Type
    Definition Classes
    Erasure
  72. def erasure(sym: Global.Symbol): ErasureMap
    Definition Classes
    Erasure
  73. def etaExpand(tree: Global.Tree, owner: Global.Symbol)(implicit creator: FreshNameCreator): Global.Tree

    Expand partial method application p.f(es_1)...(es_n).

    Expand partial method application p.f(es_1)...(es_n).

    We expand this to the following block, which evaluates the target of the application and its supplied arguments if needed (they are not stable), and then wraps a Function that abstracts over the missing arguments.

    {
      private synthetic val eta$f   = p.f   // if p is not stable
      ...
      private synthetic val eta$e_i = e_i   // if e_i is not stable
      ...
      (ps_1 => ... => ps_m => eta$f([es_1])...([es_m])(ps_1)...(ps_m))
    }

    This is called from typedEtaExpansion, which itself is called from

    • instantiateToMethodType (for a naked method reference), or
    • typedEta (when type checking a method value, m _).
    Definition Classes
    EtaExpansion
  74. final def exampleTuplePattern(names: List[Global.Name]): String

    [a, b, c] => "(a, b, c)" [a, B] => "(param1, param2)" [a, B, c] => "(param1, ..., param2)"

    [a, b, c] => "(a, b, c)" [a, B] => "(param1, param2)" [a, B, c] => "(param1, ..., param2)"

    Definition Classes
    TypeDiagnostics
  75. val excludedRootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]
    Definition Classes
    Contexts
  76. def existentialContext(tp: Global.Type): String
    Definition Classes
    TypeDiagnostics
  77. def explainAlias(tp: Global.Type): String
    Definition Classes
    TypeDiagnostics
  78. def explainAnyVsAnyRef(found: Global.Type, req: Global.Type): String
    Definition Classes
    TypeDiagnostics
  79. def explainVariance(found: Global.Type, req: Global.Type): String

    Look through the base types of the found type for any which might have been valid subtypes if given conformant type arguments.

    Look through the base types of the found type for any which might have been valid subtypes if given conformant type arguments. Examine those for situations where the type error would have been eliminated if the variance were different. In such cases, append an additional explanatory message.

    TODO: handle type aliases better.

    Definition Classes
    TypeDiagnostics
    Annotations
    @nowarn()
  80. def extractArgs(tpe: Global.Type): collection.immutable.List[Global.Type]
    Definition Classes
    SplainFormatting
  81. def factoryMeth(mods: Global.Modifiers, name: Global.TermName, cdef: Global.ClassDef): Global.DefDef

    The apply method corresponding to a case class

    The apply method corresponding to a case class

    Definition Classes
    Unapplies
  82. final def falseIfNoInstance(body: => Boolean): Boolean
    Definition Classes
    Infer
    Annotations
    @inline()
  83. lazy val fastTrack: FastTrack[Global.erasure.this.type]
    Definition Classes
    Macros
  84. def finalOwners(tpe: Global.Type): Boolean
    Definition Classes
    TypeDiagnostics
  85. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  86. final def finishComputeParamAlias(): Unit

    Finish computation of param aliases after typechecking is completed

    Finish computation of param aliases after typechecking is completed

    Definition Classes
    Typers
  87. def flattenInfix(tpe: Infix): collection.immutable.List[Formatted]

    Turn a nested infix type structure into a flat list

    Turn a nested infix type structure into a flat list

    ::[A, ::[B, C]]] => List(A, ::, B, ::, C)
    Definition Classes
    SplainFormatting
  88. final def forArgMode(fun: Global.Tree, mode: Mode): reflect.internal.Mode
    Definition Classes
    Typers
  89. def formalTypes(formals: List[Global.Type], numArgs: Int, removeByName: Boolean = true, removeRepeated: Boolean = true): List[Global.Type]

    The formal parameter types corresponding to formals.

    The formal parameter types corresponding to formals. If formals has a repeated last parameter, a list of (numArgs - numFormals + 1) copies of its type is appended to the other formals. By-name types are replaced with their underlying type.

    removeByName

    allows keeping ByName parameters. Used in NamesDefaults.

    removeRepeated

    allows keeping repeated parameter (if there's one argument). Used in NamesDefaults.

    Definition Classes
    Infer
  90. def formatAuxSimple(tpe: Global.Type): (collection.immutable.List[String], String)
    Definition Classes
    SplainFormatting
  91. def formatDiff(left: Global.Type, right: Global.Type, top: Boolean): Formatted
    Definition Classes
    SplainFormatting
  92. val formatDiffCache: FormatCache[(Global.Type, Global.Type, Boolean), Formatted]
    Definition Classes
    SplainFormatting
  93. def formatDiffImpl(found: Global.Type, req: Global.Type, top: Boolean): Formatted
    Definition Classes
    SplainFormatting
  94. def formatDiffInfix(left: Global.Type, right: Global.Type, top: Boolean): Formatted
    Definition Classes
    SplainFormatting
  95. def formatDiffSimple(left: Global.Type, right: Global.Type): Formatted
    Definition Classes
    SplainFormatting
  96. def formatDiffSpecial(left: Global.Type, right: Global.Type, top: Boolean): Option[Formatted]
    Definition Classes
    SplainFormatting
  97. def formatFunction(args: collection.immutable.List[String]): String
    Definition Classes
    SplainFormatting
  98. def formatImplicitChainFlat(chain: collection.immutable.List[ImplicitError]): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  99. def formatImplicitChainTreeFull(chain: collection.immutable.List[ImplicitError]): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  100. def formatImplicitError(param: Global.Symbol, errors: collection.immutable.List[ImplicitError], annotationMsg: String): String
    Definition Classes
    SplainFormatting
  101. def formatIndentTree(chain: collection.immutable.List[ImplicitError], baseIndent: Int): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  102. def formatInfix[A](path: collection.immutable.List[String], simple: String, left: A, right: A, top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
    Definition Classes
    SplainFormatting
  103. def formatNestedImplicit(err: ImplicitError): (String, collection.immutable.List[String], Int)
    Definition Classes
    SplainFormatting
  104. def formatNonConfBounds(err: NonconformantBounds): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  105. def formatNormalSimple(tpe: Global.Type): (collection.immutable.List[String], String)
    Definition Classes
    SplainFormatting
  106. def formatRefinement(sym: Global.Symbol): String
    Definition Classes
    SplainFormatting
  107. def formatSimpleType(tpe: Global.Type): (collection.immutable.List[String], String)
    Definition Classes
    SplainFormatting
  108. def formatSpecial[A](tpe: Global.Type, simple: String, args: collection.immutable.List[A], formattedArgs: => collection.immutable.List[Formatted], top: Boolean)(rec: (A, Boolean) => Formatted): Option[Formatted]
    Definition Classes
    SplainFormatting
  109. def formatType(tpe: Global.Type, top: Boolean): Formatted
    Definition Classes
    SplainFormattingSplainFormatters
  110. val formatTypeCache: FormatCache[(Global.Type, Boolean), Formatted]
    Definition Classes
    SplainFormatting
  111. def formatTypeImpl(tpe: Global.Type, top: Boolean): Formatted
    Definition Classes
    SplainFormatting
  112. def formatWithInfix[A](tpe: Global.Type, args: collection.immutable.List[A], top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
    Definition Classes
    SplainFormatting
  113. def formattedDiff(left: Formatted, right: Formatted): String
    Definition Classes
    SplainFormatting
  114. def foundReqMsg(found: Global.Type, req: Global.Type): String
    Definition Classes
    TypeDiagnostics
  115. def freshNameCreatorFor(context: Context): FreshNameCreator
    Definition Classes
    Typers
  116. def freshVar(tparam: Global.Symbol): Global.TypeVar

    A fresh type variable with given type parameter as origin.

    A fresh type variable with given type parameter as origin.

    Definition Classes
    Infer
  117. def fullSiteString(context: Context): String
    Definition Classes
    TypersTracking
  118. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  119. val global: Global.this.type

    The global environment; overridden by instantiation in Global.

    The global environment; overridden by instantiation in Global.

    Definition Classes
    erasureTypingTransformersAnalyzerTreeDSL → Erasure → SubComponent
  120. def globalSettings: Settings
    Definition Classes
    MacrosTraces
  121. def hasAttachedExpansion(sym: Global.Symbol): Boolean
    Definition Classes
    MacroAnnotationAttachments
  122. def hasMacroExpansionAttachment(any: Any): Boolean

    Determines whether the target is either an original or a result of a macro expansion.

    Determines whether the target is either an original or a result of a macro expansion. The parameter is of type Any, because macros can expand both into trees and into annotations.

    Definition Classes
    StdAttachments
  123. val hasPendingMacroExpansions: Boolean

    Without any restrictions on macro expansion, macro applications will expand at will, and when type inference is involved, expansions will end up using yet uninferred type params.

    Without any restrictions on macro expansion, macro applications will expand at will, and when type inference is involved, expansions will end up using yet uninferred type params.

    For some macros this might be ok (thanks to TreeTypeSubstituter that replaces the occurrences of undetparams with their inferred values), but in general case this won't work. E.g. for reification simple substitution is not enough - we actually need to re-reify inferred types.

    Luckily, there exists a very simple way to fix the problem: delay macro expansion until everything is inferred. Here are the exact rules. Macro application gets delayed if any of its subtrees contain: 1) type vars (tpe.isInstanceOf[TypeVar]) // [Eugene] this check is disabled right now, because TypeVars seem to be created from undetparams anyways 2) undetparams (sym.isTypeParameter && !sym.isSkolem)

    Definition Classes
    Macros
  124. def hasSuperArgs(tree: Global.Tree): Boolean

    Determines whether the given tree has an associated SuperArgsAttachment.

    Determines whether the given tree has an associated SuperArgsAttachment.

    Definition Classes
    StdAttachments
  125. def hashCode(): Int

    SubComponents are added to a HashSet and two phases are the same if they have the same name.

    SubComponents are added to a HashSet and two phases are the same if they have the same name.

    Definition Classes
    SubComponent → AnyRef → Any
  126. def hideImpError(error: ImplicitError): Boolean
    Definition Classes
    SplainFormatting
  127. def implicitMessage(param: Global.Symbol, annotationMsg: String): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  128. def increaseMetalevel(pre: Global.Type, tp: Global.Type): Global.Type

    Increases metalevel of the type, i.e.

    Increases metalevel of the type, i.e. transforms: * T to c.Expr[T]

    Definition Classes
    Helpers
    See also

    Metalevels.scala for more information and examples about metalevels

  129. def indent(lines: collection.immutable.List[String], n: Int = 1, prefix: String = " "): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  130. def indentLine(line: String, n: Int = 1, prefix: String = " "): String
    Definition Classes
    SplainFormatting
  131. def indentTree(tree: collection.immutable.List[(String, collection.immutable.List[String], Int)], baseIndent: Int): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  132. def inferImplicit(tree: Global.Tree, pt: Global.Type, isView: Boolean, context: Context, silent: Boolean, withMacrosDisabled: Boolean, pos: Global.Position, onError: (Global.Position, String) => Unit): Global.Tree

    A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.

    A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.

    Definition Classes
    Implicits
  133. def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean, pos: Global.Position): SearchResult

    Search for an implicit value.

    Search for an implicit value. Consider using one of the convenience methods above. This one has many boolean levers.

    See the comment on result at the end of class ImplicitSearch for more info how the search is conducted.

    tree

    The tree for which the implicit needs to be inserted. (the inference might instantiate some of the undetermined type parameters of that tree.

    pt

    The expected type of the implicit.

    reportAmbiguous

    Should ambiguous implicit errors be reported? False iff we search for a view to find out whether one type is coercible to another.

    isView

    We are looking for a view

    context

    The current context

    saveAmbiguousDivergent

    False if any divergent/ambiguous errors should be ignored after implicits search, true if they should be reported (used in further typechecking).

    pos

    Position that should be used for tracing and error reporting (useful when we infer synthetic stuff and pass EmptyTree in the tree argument) If it's set to NoPosition, then position-based services will use tree.pos

    returns

    A search result

    Definition Classes
    Implicits
  134. def inferImplicitByType(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult
    Definition Classes
    Implicits
  135. def inferImplicitByTypeSilent(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult
    Definition Classes
    Implicits
  136. def inferImplicitFor(pt: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean = true): SearchResult
    Definition Classes
    Implicits
  137. def inferImplicitView(from: Global.Type, to: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean, saveAmbiguousDivergent: Boolean): SearchResult
    Definition Classes
    Implicits
  138. val initial: Boolean

    True if this phase runs before all other phases.

    True if this phase runs before all other phases. Usually, parser.

    Definition Classes
    SubComponent
  139. def instantiateSamFromFunction(funTp: Global.Type, samTp: Global.Type, sam: Global.Symbol): Global.Type
    Definition Classes
    Infer
  140. val internal: Boolean

    True if this phase is not provided by a plug-in.

    True if this phase is not provided by a plug-in.

    Definition Classes
    SubComponent
  141. def intersectionDominator(parents: List[Global.Type]): Global.Type
    Definition Classes
    Erasure
  142. def isAux(tpe: Global.Type): Boolean
    Definition Classes
    SplainFormatting
  143. def isBlackbox(macroDef: Global.Symbol): Boolean
    Definition Classes
    Macros
  144. def isBlackbox(expandee: Global.Tree): Boolean
    Definition Classes
    Macros
  145. def isDynamicRewrite(tree: Global.Tree): Boolean
    Definition Classes
    StdAttachments
  146. def isExpanded(sym: Global.Symbol): Boolean
    Definition Classes
    MacroAnnotationAttachments
  147. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  148. final def isJvmAccessible(cls: Global.Symbol, context: Context): Boolean
    Definition Classes
    Erasure
  149. def isMacroExpansionSuppressed(tree: Global.Tree): Boolean

    Determines whether a tree should not be expanded, because someone has put SuppressMacroExpansionAttachment on it or one of its children.

    Determines whether a tree should not be expanded, because someone has put SuppressMacroExpansionAttachment on it or one of its children.

    Definition Classes
    StdAttachments
  150. def isMacroImplRef(tree: Global.Tree): Boolean

    Determines whether a tree should or should not be adapted, because someone has put MacroImplRefAttachment on it.

    Determines whether a tree should or should not be adapted, because someone has put MacroImplRefAttachment on it.

    Definition Classes
    StdAttachments
  151. def isMaybeExpandee(sym: Global.Symbol): Boolean
    Definition Classes
    MacroAnnotationAttachments
  152. def isNamedArg(arg: Global.Tree): Boolean
    Definition Classes
    NamesDefaults
  153. def isNotExpandable(sym: Global.Symbol): Boolean
    Definition Classes
    MacroAnnotationAttachments
  154. def isRefined(tpe: Global.Type): Boolean
    Definition Classes
    SplainFormatting
  155. def isSymbolic(tpe: Global.Type): Boolean
    Definition Classes
    SplainFormatting
  156. def isWeak(sym: Global.Symbol): Boolean
    Definition Classes
    MacroAnnotationAttachments
  157. final def javaSig(sym0: Global.Symbol, info: Global.Type, markClassUsed: (Global.Symbol) => Unit): Option[String]

    The Java signature of type 'info', for symbol sym.

    The Java signature of type 'info', for symbol sym. The symbol is used to give the right return type for constructors.

    Definition Classes
    Erasure
  158. def keepsTypeParams: Boolean
    Definition Classes
    ErasureInfoTransform
  159. val lastAccessCheckDetails: String
    Definition Classes
    Contexts
  160. val lastTreeToTyper: Global.Tree
    Definition Classes
    TypersTracking
  161. def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean
    Definition Classes
    TypeDiagnostics
  162. def linkExpandeeAndDesugared(expandee: Global.Tree, desugared: Global.Tree): Unit

    After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment.

    After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment.

    Definition Classes
    StdAttachments
  163. def linkExpandeeAndExpanded(expandee: Global.Tree, expanded: Any): Unit

    After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment.

    After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment. The expanded parameter is of type Any, because macros can expand both into trees and into annotations.

    Definition Classes
    StdAttachments
  164. final def linkedClassOfClassOf(original: Global.Symbol, ctx: Context): Global.Symbol

    A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.

    A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.

    Definition Classes
    Namers
  165. def loadMacroImplBinding(macroDef: Global.Symbol): Option[MacroImplBinding]
    Definition Classes
    Macros
  166. def macroArgs(typer: Typer, expandee: Global.Tree): MacroArgs
    Definition Classes
    Macros
  167. def macroContext(typer: Typer, prefixTree: Global.Tree, expandeeTree: Global.Tree): MacroContext
    Definition Classes
    Macros
  168. val macroDebugLite: Boolean
    Definition Classes
    Traces
  169. val macroDebugVerbose: Boolean
    Definition Classes
    Traces
  170. def macroEngine: String

    Macro def -> macro impl bindings are serialized into a macroImpl annotation with synthetic content that carries the payload described in MacroImplBinding.

    Macro def -> macro impl bindings are serialized into a macroImpl annotation with synthetic content that carries the payload described in MacroImplBinding.

    For example, for a pair of macro definition and macro implementation: def impl(c: scala.reflect.macros.blackbox.Context): c.Expr[Unit] = ??? def foo: Unit = macro impl

    We will have the following annotation added on the macro definition foo:

    @scala.reflect.macros.internal.macroImpl(
      `macro`(
        "macroEngine" = <current macro engine>,
        "isBundle" = false,
        "isBlackbox" = true,
        "signature" = List(Other),
        "methodName" = "impl",
        "className" = "Macros$"))
    Definition Classes
    Macros
  171. def macroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

    Expands a term macro used in apply role as M(2)(3) in val x = M(2)(3).

    Expands a term macro used in apply role as M(2)(3) in val x = M(2)(3).

    Definition Classes
    Macros
    See also

    DefMacroExpander

  172. def macroExpandAll(typer: Typer, expandee: Global.Tree): Global.Tree

    Performs macro expansion on all subtrees of a given tree.

    Performs macro expansion on all subtrees of a given tree. Innermost macros are expanded first, outermost macros are expanded last. See the documentation for macroExpand for more information.

    Definition Classes
    Macros
  173. def macroExpandWithRuntime(typer: Typer, expandee: Global.Tree, runtime: MacroRuntime): MacroStatus

    Expands a macro when a runtime (i.e.

    Expands a macro when a runtime (i.e. the macro implementation) can be successfully loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

    Definition Classes
    Macros
  174. def macroExpandWithoutRuntime(typer: Typer, expandee: Global.Tree): MacroStatus

    Expands a macro when a runtime (i.e.

    Expands a macro when a runtime (i.e. the macro implementation) cannot be loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

    Definition Classes
    Macros
  175. def macroExpandee(tree: Global.Tree): Global.Tree

    Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.

    Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.

    Definition Classes
    StdAttachments
  176. def macroExpanderAttachment(tree: Global.Tree): MacroExpanderAttachment

    Loads underlying MacroExpanderAttachment from a macro expandee or returns a default value for that attachment.

    Loads underlying MacroExpanderAttachment from a macro expandee or returns a default value for that attachment.

    Definition Classes
    StdAttachments
  177. final def macroLogLite(msg: => Any): Unit
    Definition Classes
    Traces
    Annotations
    @inline()
  178. final def macroLogVerbose(msg: => Any): Unit
    Definition Classes
    Traces
    Annotations
    @inline()
  179. def macroRuntime(expandee: Global.Tree): MacroRuntime

    Produces a function that can be used to invoke macro implementation for a given macro definition: 1) Looks up macro implementation symbol in this universe.

    Produces a function that can be used to invoke macro implementation for a given macro definition: 1) Looks up macro implementation symbol in this universe. 2) Loads its enclosing class from the macro classloader. 3) Loads the companion of that enclosing class from the macro classloader. 4) Resolves macro implementation within the loaded companion.

    returns

    Requested runtime if macro implementation can be loaded successfully from either of the mirrors, null otherwise.

    Definition Classes
    MacroRuntimes
  180. def makeNamedTypes(syms: List[Global.Symbol]): collection.immutable.List[Global.NamedType]
    Definition Classes
    NamesDefaults
  181. def markDynamicRewrite(tree: Global.Tree): Global.Tree
    Definition Classes
    StdAttachments
  182. def markExpanded(sym: Global.Symbol): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  183. def markMacroImplRef(tree: Global.Tree): Global.Tree

    Marks the tree as a macro impl reference, which is a naked reference to a method.

    Marks the tree as a macro impl reference, which is a naked reference to a method.

    This is necessary for typechecking macro impl references (see DefaultMacroCompiler.defaultResolveMacroImpl), because otherwise typing a naked reference will result in the "follow this method with _ if you want to treat it as a partially applied function" errors.

    This mark suppresses adapt except for when the annottee is a macro application.

    Definition Classes
    StdAttachments
  184. def markMaybeExpandee(sym: Global.Symbol): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  185. def markNotExpandable(sym: Global.Symbol): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  186. def markWeak(sym: Global.Symbol): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  187. def memberWildcardType(name: Global.Name, tp: Global.Type): Global.Type

    A constructor for types ?{ def/type name: tp }, used in infer view to member searches.

    A constructor for types ?{ def/type name: tp }, used in infer view to member searches.

    Definition Classes
    Implicits
  188. def minimizeParents(cls: Global.Symbol, parents: List[Global.Type]): List[Global.Type]
    Definition Classes
    Erasure
  189. def missingParams[T](args: List[T], params: List[Global.Symbol], argName: (T) => Option[Global.Name]): (List[Global.Symbol], Boolean)

    Returns the parameter symbols of an invocation expression that are not defined by the list of arguments.

    Returns the parameter symbols of an invocation expression that are not defined by the list of arguments.

    args

    The list of arguments

    params

    The list of parameter symbols of the invoked method

    argName

    A function that extracts the name of an argument expression, if it is a named argument.

    Definition Classes
    NamesDefaults
  190. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  191. def newNamer(context: Context): Namer
    Definition Classes
    Namers
  192. def newPhase(prev: nsc.Phase): StdPhase

    Create a new phase which applies transformer

    Create a new phase which applies transformer

    Definition Classes
    InfoTransformTransformSubComponent
  193. def newRootLocalTyper(unit: Global.CompilationUnit): (analyzer)#Typer
    Attributes
    protected
    Definition Classes
    TypingTransformers
  194. def newTransformer(unit: Global.CompilationUnit): Global.AstTransformer

    The transformer factory

    The transformer factory

    Definition Classes
    ErasureTransform
  195. def newTyper(context: Context): Eraser
    Definition Classes
    ErasureTypers
  196. def noPrintAdapt(tree1: Global.Tree, tree2: Global.Tree): Boolean
    Definition Classes
    TypersTracking
  197. def noPrintTyping(t: Global.Tree): Boolean
    Definition Classes
    TypersTracking
  198. def notAnyRefMessage(found: Global.Type): String
    Definition Classes
    ContextErrors
  199. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  200. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  201. def notifyUndetparamsAdded(newUndets: List[Global.Symbol]): Unit
    Definition Classes
    Macros
  202. def notifyUndetparamsInferred(undetNoMore: List[Global.Symbol], inferreds: List[Global.Type]): Unit
    Definition Classes
    Macros
  203. def numericConversion(tree: Global.Tree, numericSym: Global.Symbol): Global.Tree
    Definition Classes
    Erasure
  204. def onTreeCheckerError(pos: Global.Position, msg: String): Unit
    Attributes
    protected
    Definition Classes
    Contexts
  205. def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: scala.tools.nsc.Global.erasure.global.type }]
    Definition Classes
    Macros
  206. def ownPhase: nsc.Phase

    The phase corresponding to this subcomponent in the current compiler run.

    The phase corresponding to this subcomponent in the current compiler run.

    Definition Classes
    SubComponent
  207. def pathPrefix: (collection.immutable.List[String]) => String
    Definition Classes
    SplainFormatting
  208. val phaseName: String

    The name of the phase

    The name of the phase

    Definition Classes
    ErasureSubComponent
  209. def phaseNewFlags: Long

    New flags defined by the phase which are not valid before

    New flags defined by the phase which are not valid before

    Definition Classes
    SubComponent
  210. def phaseNextFlags: Long

    New flags defined by the phase which are not valid until immediately after it

    New flags defined by the phase which are not valid until immediately after it

    Definition Classes
    SubComponent
  211. def pluginsEnsureCompanionObject(namer: Namer, cdef: Global.ClassDef, creator: (Global.ClassDef) => Global.Tree = companionModuleDef(_)): Global.Symbol

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsEnsureCompanionObject

  212. def pluginsEnterStats(typer: Typer, stats: List[Global.Tree]): List[Global.Tree]

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsEnterStats

  213. def pluginsEnterSym(namer: Namer, tree: Global.Tree): Context

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsEnterSym

  214. def pluginsIsBlackbox(macroDef: Global.Symbol): Boolean

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsIsBlackbox

  215. def pluginsMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsMacroArgs

  216. def pluginsMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsMacroExpand

  217. def pluginsMacroRuntime(expandee: Global.Tree): MacroRuntime

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsMacroRuntime

  218. def pluginsNoImplicitFoundError(param: Global.Symbol, errors: List[ImplicitError], initial: String): String

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.noImplicitFoundError

  219. def pluginsNotifyImplicitSearch(search: ImplicitSearch): Unit

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsImplicitSearch

  220. def pluginsNotifyImplicitSearchResult(result: SearchResult): Unit

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsImplicitSearchResult

  221. def pluginsPt(pt: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode): Global.Type

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsPt

  222. def pluginsTypeSig(tpe: Global.Type, typer: Typer, defTree: Global.Tree, pt: Global.Type): Global.Type

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypeSig

  223. def pluginsTypeSigAccessor(tpe: Global.Type, typer: Typer, tree: Global.ValDef, sym: Global.Symbol): Global.Type

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypeSigAccessor

  224. def pluginsTyped(tpe: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Type

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTyped

  225. def pluginsTypedMacroBody(typer: Typer, ddef: Global.DefDef): Global.Tree

    Definition Classes
    AnalyzerPlugins
    See also

    MacroPlugin.pluginsTypedMacroBody

  226. def pluginsTypedReturn(tpe: Global.Type, typer: Typer, tree: Global.Return, pt: Global.Type): Global.Type

    Definition Classes
    AnalyzerPlugins
    See also

    AnalyzerPlugin.pluginsTypedReturn

  227. def popMacroContext(): Unit
    Definition Classes
    Macros
  228. def posPrecedes(p1: Global.Position, p2: Global.Position): Boolean

    Does the positioned line assigned to t1 precede that of t2?

    Does the positioned line assigned to t1 precede that of t2?

    Definition Classes
    TypeDiagnostics
  229. val prepareSigMap: Global.TypeMap { def squashBoxed(tp: scala.tools.nsc.Global.erasure.global.Type): scala.tools.nsc.Global.erasure.global.Type }

    This object is only used for confidence checking when -check:genjvm is set.

    This object is only used for confidence checking when -check:genjvm is set. In that case we make sure that the erasure of the normalized type is the same as the erased type that's generated. Normalization means unboxing some primitive types and further simplifications as they are done in jsig.

    Definition Classes
    Erasure
  230. def printingOk(t: Global.Tree): Boolean
    Definition Classes
    TypersTracking
  231. def propagateKnownTypes(from: Global.Type, to: Global.Symbol): Global.Type

    The applied type of class 'to' after inferring anything possible from the knowledge that 'to' must also be of the type given in 'from'.

    The applied type of class 'to' after inferring anything possible from the knowledge that 'to' must also be of the type given in 'from'.

    Definition Classes
    Checkable
  232. def pushMacroContext(c: MacroContext): Unit
    Definition Classes
    Macros
  233. def qualifiedName(path: collection.immutable.List[String], name: FormattedName): String
    Definition Classes
    SplainFormatting
  234. def rebindInnerClass(pre: Global.Type, cls: Global.Symbol): Global.Type
    Attributes
    protected
    Definition Classes
    Erasure
  235. final def recursivelyFinal(tpe: Global.Type): Boolean
    Definition Classes
    TypeDiagnostics
    Annotations
    @tailrec()
  236. def registerImport(ctx: Context, imp: Global.Import): Unit
    Definition Classes
    Contexts
  237. def removeNames(typer: Typer)(args: List[Global.Tree], params: List[Global.Symbol]): (List[Global.Tree], Array[Int])

    Removes name assignments from args.

    Removes name assignments from args. Additionally, returns an array mapping argument indices from call-site-order to definition-site-order.

    Verifies that names are not specified twice, and positional args don't appear after named ones.

    Definition Classes
    NamesDefaults
  238. def reorderArgs[T](args: List[T], pos: (Int) => Int)(implicit arg0: ClassTag[T]): List[T]

    pos

    maps indices from old to new

    Definition Classes
    NamesDefaults
  239. val requiredDirectInterfaces: AnyRefMap[Global.Symbol, Set[Global.Symbol]]
    Definition Classes
    Erasure
  240. val requires: List[String]

    Names of phases required by this component.

    Names of phases required by this component. Default is Nil.

    Definition Classes
    SubComponent
  241. def resetContexts(): Unit
    Definition Classes
    Contexts
  242. def resetDocComments(): Unit
    Definition Classes
    Typers
  243. def resetImplicits(): Unit
    Definition Classes
    Implicits
  244. def resetTyper(): Unit
    Definition Classes
    Typers
  245. final def resolveAnonymousBridgeClash(sym: Global.Symbol, bridge: Global.Symbol): Unit
    Definition Classes
    Erasure
  246. def restoreCompleter(sym: Global.Symbol): Unit
    Definition Classes
    MacroAnnotationAttachments
  247. def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit
    Definition Classes
    TypeDiagnostics
  248. def restrictionWarning(pos: Global.Position, unit: Global.CompilationUnit, msg: String, category: WarningCategory, site: Global.Symbol): Unit

    For errors which are artifacts of the implementation: such messages indicate that the restriction may be lifted in the future.

    For errors which are artifacts of the implementation: such messages indicate that the restriction may be lifted in the future.

    Definition Classes
    TypeDiagnostics
  249. def rootContext(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context
    Definition Classes
    Contexts
  250. def rootContextPostTyper(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree): Context
    Definition Classes
    Contexts
  251. def rootImports(unit: Global.CompilationUnit): List[Global.Symbol]

    List of symbols to import from in a root context.

    List of symbols to import from in a root context. By default, that is java.lang, scala, and scala.Predef, in that order.

    • if option -Yimports is supplied, then that specifies the preamble imports
    • if the unit body has an import of Predef among its leading imports, or if the tree is scala.Predef, Predef is not imported. Similarly for any module among the preamble imports.
    • if the unit is java defined, only java.lang is imported

    The root imports for a unit are cached.

    Attributes
    protected
    Definition Classes
    Contexts
  252. val rootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]
    Definition Classes
    Contexts
  253. val runsAfter: collection.immutable.List[String]

    Names of phases that must run before this phase.

    Names of phases that must run before this phase.

    Definition Classes
    erasureSubComponent
  254. val runsBefore: List[String]

    Names of phases that must run after this phase.

    Names of phases that must run after this phase. Default is Nil.

    Definition Classes
    SubComponent
  255. val runsRightAfter: Some[String]

    Name of the phase that this phase must follow immediately.

    Name of the phase that this phase must follow immediately.

    Definition Classes
    erasureSubComponent
  256. def sanitizePath(path: collection.immutable.List[String]): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  257. def setAddendum(pos: Global.Position, msg: () => String): Unit
    Definition Classes
    TypeDiagnostics
  258. final val shortenImports: Boolean(false)
    Definition Classes
    Typers
  259. def showFormatted(tpe: Formatted): String
    Definition Classes
    SplainFormatting
  260. def showFormattedL(tpe: Formatted, break: Boolean): TypeRepr
    Definition Classes
    SplainFormatting
  261. val showFormattedLCache: FormatCache[(Formatted, Boolean), TypeRepr]
    Definition Classes
    SplainFormatting
  262. def showFormattedLImpl(tpe: Formatted, break: Boolean): TypeRepr
    Definition Classes
    SplainFormatting
  263. def showFormattedQualified(path: collection.immutable.List[String], name: FormattedName): TypeRepr
    Definition Classes
    SplainFormatting
  264. def showFuncParams(args: collection.immutable.List[String]): String
    Definition Classes
    SplainFormatting
  265. def showRefined(parents: collection.immutable.List[String], decls: collection.immutable.List[String]): String
    Definition Classes
    SplainFormatting
  266. def showTuple(args: collection.immutable.List[String]): String
    Definition Classes
    SplainFormatting
  267. def showType(tpe: Global.Type): String
    Definition Classes
    SplainFormatting
  268. def showTypeApply(cons: String, args: collection.immutable.List[TypeRepr], break: Boolean): TypeRepr

    If the args of an applied type constructor are multiline, create separate lines for the constructor name and the closing bracket; else return a single line.

    If the args of an applied type constructor are multiline, create separate lines for the constructor name and the closing bracket; else return a single line.

    Definition Classes
    SplainFormatting
  269. def showTypeBreakL(tpe: Global.Type): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  270. def skipImplicit(tp: Global.Type): Global.Type
    Definition Classes
    Infer
  271. def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], getVariance: Extractor[Global.Symbol], upper: Boolean, depth: Depth): List[Global.Type]

    Solve constraint collected in types tvars.

    Solve constraint collected in types tvars.

    tvars

    All type variables to be instantiated.

    tparams

    The type parameters corresponding to tvars

    getVariance

    Function to extract variances of type parameters; we need to reverse solution direction for all contravariant variables.

    upper

    When true search for max solution else min.

    Definition Classes
    Infer
    Exceptions thrown
  272. def specialConstructorErasure(clazz: Global.Symbol, tpe: Global.Type): Global.Type
    Definition Classes
    Erasure
  273. def specialErasure(sym: Global.Symbol)(tp: Global.Type): Global.Type
    Definition Classes
    Erasure
  274. val specialFormatters: collection.immutable.List[SpecialFormatter]
    Definition Classes
    SplainFormatting
  275. def specialScalaErasureFor(sym: Global.Symbol): ErasureMap
    Definition Classes
    Erasure
  276. def splainFoundReqMsg(found: Global.Type, req: Global.Type): String
    Definition Classes
    SplainDiagnostics
  277. def splainPushImplicitSearchFailure(implicitTree: Global.Tree, expectedType: Global.Type, originalError: AbsTypeError): Unit
    Definition Classes
    SplainErrors
  278. def splainPushNonconformantBonds(tpe: Global.Type, candidate: Global.Tree, targs: List[Global.Type], tparams: List[Global.Symbol], originalError: Option[AbsTypeError]): Unit
    Definition Classes
    SplainErrors
  279. def splainPushNotFound(tree: Global.Tree, param: Global.Symbol): Unit
    Definition Classes
    SplainErrors
  280. def splainPushOrReportNotFound(tree: Global.Tree, param: Global.Symbol, annotationMsg: String): String
    Definition Classes
    SplainErrors
  281. def splitChains(errors: collection.immutable.List[ImplicitError]): collection.immutable.List[collection.immutable.List[ImplicitError]]
    Definition Classes
    SplainFormatting
  282. def standardIsBlackbox(macroDef: Global.Symbol): Boolean

    Default implementation of isBlackbox.

    Default implementation of isBlackbox. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsIsBlackbox for more details)

    Definition Classes
    Macros
  283. def standardMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs

    Default implementation of macroArgs.

    Default implementation of macroArgs. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroArgs for more details)

    Definition Classes
    Macros
  284. def standardMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree

    Default implementation of macroExpand.

    Default implementation of macroExpand. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroExpand for more details)

    Definition Classes
    Macros
  285. def standardMacroRuntime(expandee: Global.Tree): MacroRuntime
    Definition Classes
    MacroRuntimes
  286. def standardTypedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

    Default implementation of typedMacroBody.

    Default implementation of typedMacroBody. Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsTypedMacroBody for more details)

    Definition Classes
    Macros
  287. def stripModules(path: collection.immutable.List[String], name: FormattedName): String
    Definition Classes
    SplainFormatting
  288. def stripType(tpe: Global.Type): (collection.immutable.List[String], String)
    Definition Classes
    SplainFormatting
  289. def superArgs(tree: Global.Tree): Option[List[List[Global.Tree]]]

    Convenience method for SuperArgsAttachment.

    Convenience method for SuperArgsAttachment. Compared with MacroRuntimeAttachment this attachment has different a usage pattern, so it really benefits from a dedicated extractor.

    Definition Classes
    StdAttachments
  290. def suppressMacroExpansion(tree: Global.Tree): tree.type

    Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.

    Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.

    Definition Classes
    StdAttachments
  291. def symbolPath(sym: Global.Symbol): collection.immutable.List[String]
    Definition Classes
    SplainFormatting
  292. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  293. val terminal: Boolean

    True if this phase runs after all other phases.

    True if this phase runs after all other phases. Usually, terminal.

    Definition Classes
    SubComponent
  294. def toString(): String
    Definition Classes
    AnyRef → Any
  295. def tpe_s(tp: Global.Type, colorize: (String) => String): String
    Definition Classes
    TypersTracking
  296. def transformInfo(sym: Global.Symbol, tp: Global.Type): Global.Type
    Definition Classes
    Erasure
  297. def transformNamedApplication(typer: Typer, mode: Mode, pt: Global.Type)(tree: Global.Tree, argPos: (Int) => Int): Global.Tree

    Transform a function application into a Block, and assigns typer.context .namedApplyBlockInfo to the new block as side-effect.

    Transform a function application into a Block, and assigns typer.context .namedApplyBlockInfo to the new block as side-effect. If tree has the form Apply(fun, args) first the function "fun" (which might be an application itself!) is transformed into a block of the form { val qual$1 = qualifier_of_fun val x$1 = arg_1_of_fun ... val x$n = arg_n_of_fun qual$1.fun[targs](x$1, ...)...(..., x$n) } then for each argument in args, a value is created and entered into the block. finally the application expression of the block is updated. { val qual$1 = .. ... val x$n = ... > val qual$n+1 = arg(1) > ... > val qual$n+m = arg(m) > qual$1.fun[targs](x$1, ...)...(..., x$n)(x$n+1, ..., x$n+m) }

    typer

    the typer calling this method; this method calls typer.doTypedApply

    mode

    the mode to use for calling typer.doTypedApply

    pt

    the expected type for calling typer.doTypedApply

    tree

    the function application tree

    argPos

    a function mapping arguments from their current position to the position specified by the method type. example: def foo(a: Int, b: String) foo(b = "1", a = 2) calls transformNamedApplication(Apply(foo, List("1", 2), { 0 => 1, 1 => 0 })

    returns

    the transformed application (a Block) together with the NamedApplyInfo. if isNamedApplyBlock(tree), returns the existing context.namedApplyBlockInfo

    Definition Classes
    NamesDefaults
  298. def transformTypeTagEvidenceParams(macroImplRef: Global.Tree, transform: (Global.Symbol, Global.Symbol) => Global.Symbol): List[List[Global.Symbol]]

    Transforms parameters lists of a macro impl.

    Transforms parameters lists of a macro impl. The transform function is invoked only for WeakTypeTag evidence parameters.

    The transformer takes two arguments: a value parameter from the parameter list and a type parameter that is witnesses by the value parameter.

    If the transformer returns a NoSymbol, the value parameter is not included from the result. If the transformer returns something else, this something else is included in the result instead of the value parameter.

    Despite of being highly esoteric, this function significantly simplifies signature analysis. For example, it can be used to strip macroImpl.paramss from the evidences (necessary when checking def <-> impl correspondence) or to streamline creation of the list of macro arguments.

    Definition Classes
    Helpers
  299. def transparentDealias(sym: Global.Symbol, pre: Global.Type, owner: Global.Symbol): Global.Type
    Definition Classes
    Erasure
  300. def treeSymTypeMsg(tree: Global.Tree): String
    Definition Classes
    TypeDiagnostics
  301. def truncateDecls(decls: collection.immutable.List[Formatted]): Boolean
    Definition Classes
    SplainFormatting
  302. def typePatternAdvice(sym: Global.Symbol, ptSym: Global.Symbol): String
    Definition Classes
    TypeDiagnostics
  303. def typedMacroBody(typer: Typer, macroDdef: Global.DefDef): Global.Tree

    Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method or a top-level macro bundle, and that that method is signature-wise compatible with the given macro definition.

    Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method or a top-level macro bundle, and that that method is signature-wise compatible with the given macro definition.

    returns

    Macro impl reference for the given macro definition if everything is okay. EmptyTree if an error occurs.

    Definition Classes
    Macros
  304. def typerShouldExpandDeferredMacros: Boolean
    Definition Classes
    Macros
  305. def typingInPattern[T](body: => T): T

    Devising new ways of communicating error info out of desperation to work on error messages.

    Devising new ways of communicating error info out of desperation to work on error messages. This is used by typedPattern to wrap its business so we can generate a sensible error message when things go south.

    Definition Classes
    TypeDiagnostics
  306. def unapplyMember(tp: Global.Type): Global.Symbol

    Filters out unapplies with invalid shapes: extractor methods must have either one unary param list or one unary param list and an implicit param list.

    Filters out unapplies with invalid shapes: extractor methods must have either one unary param list or one unary param list and an implicit param list.

    Definition Classes
    Unapplies
  307. def unboundedGenericArrayLevel(tp: Global.Type): Int
    Definition Classes
    Erasure
  308. def underlyingSymbol(member: Global.Symbol): Global.Symbol

    The symbol which the given accessor represents (possibly in part).

    The symbol which the given accessor represents (possibly in part). This is used for error messages, where we want to speak in terms of the actual declaration or definition, not in terms of the generated setters and getters.

    TODO: is it wise to create new symbols simply to generate error message? is this safe in interactive/resident mode?

    Definition Classes
    TypeDiagnostics
  309. def unmarkDynamicRewrite(tree: Global.Tree): Global.Tree
    Definition Classes
    StdAttachments
  310. def unmarkExpanded(sym: Global.Symbol): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  311. def unmarkMacroImplRef(tree: Global.Tree): Global.Tree

    Unmarks the tree as a macro impl reference (see markMacroImplRef for more information).

    Unmarks the tree as a macro impl reference (see markMacroImplRef for more information).

    This is necessary when a tree that was previously deemed to be a macro impl reference, typechecks to be a macro application. Then we need to unmark it, expand it and try to treat its expansion as a macro impl reference.

    Definition Classes
    StdAttachments
  312. def unmarkWeak(sym: Global.Symbol): Global.Symbol
    Definition Classes
    MacroAnnotationAttachments
  313. def unsuppressMacroExpansion(tree: Global.Tree): tree.type

    Unsuppresses macro expansion of the tree by removing SuppressMacroExpansionAttachment from it and its children.

    Unsuppresses macro expansion of the tree by removing SuppressMacroExpansionAttachment from it and its children.

    Definition Classes
    StdAttachments
  314. def untypeMetalevel(tp: Global.Type): Global.Type

    Transforms c.Expr[T] types into c.Tree and leaves the rest unchanged.

    Transforms c.Expr[T] types into c.Tree and leaves the rest unchanged.

    Definition Classes
    Helpers
  315. final def validateUnapplyMember(tp: Global.Type): typechecker.Unapplies.UnapplyMemberResult.Value
    Definition Classes
    Unapplies
    Annotations
    @tailrec()
  316. def valueClassIsParametric(clazz: Global.Symbol): Boolean
    Definition Classes
    Erasure
  317. def verifyJavaErasure: Boolean
    Attributes
    protected
    Definition Classes
    Erasure → Erasure
  318. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  319. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  320. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  321. def warnUnusedImports(unit: Global.CompilationUnit): Unit
    Definition Classes
    Contexts
  322. def withAddendum(pos: Global.Position): (String) => String
    Definition Classes
    TypeDiagnostics
  323. def withDisambiguation[T](locals: List[Global.Symbol], types: Global.Type*)(op: => T): T

    Given any number of types, alters the name information in the symbols until they can be distinguished from one another: then executes the given code.

    Given any number of types, alters the name information in the symbols until they can be distinguished from one another: then executes the given code. The names are restored and the result is returned.

    Definition Classes
    TypeDiagnostics
  324. def wrapParens(expr: String, top: Boolean): String
    Definition Classes
    SplainFormatting
  325. def wrapParensRepr(tpe: TypeRepr, top: Boolean): TypeRepr
    Definition Classes
    SplainFormatting
  326. object GenericArray
    Definition Classes
    Erasure
  327. object javaErasure extends JavaErasureMap
    Definition Classes
    Erasure
  328. object specialScalaErasure extends ScalaErasureMap with SpecialScalaErasure
    Definition Classes
    Erasure
  329. object CODE
    Definition Classes
    TreeDSL
  330. object namerFactory extends SubComponent
    Definition Classes
    Analyzer
  331. object packageObjects extends SubComponent
    Definition Classes
    Analyzer
  332. object typerFactory extends SubComponent
    Definition Classes
    Analyzer
  333. object Checkability
    Definition Classes
    Checkable
  334. object ErrorUtils
    Definition Classes
    ContextErrors
  335. object NamesDefaultsErrorsGen
    Definition Classes
    ContextErrors
  336. object NoContext extends Analyzer.Context
    Definition Classes
    Contexts
  337. object Function1

    An extractor for unary function types arg => res

    An extractor for unary function types arg => res

    Definition Classes
    Implicits
  338. object HasMember

    An extractor for types of the form ? { name: ? }

    An extractor for types of the form ? { name: ? }

    Definition Classes
    Implicits
  339. object HasMethodMatching

    An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }

    An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }

    Definition Classes
    Implicits
  340. object ImplicitAmbiguousMsg extends Analyzer.ImplicitAnnotationMsg
    Definition Classes
    Implicits
  341. object ImplicitNotFoundMsg extends Analyzer.ImplicitAnnotationMsg
    Definition Classes
    Implicits
  342. object OpenImplicit extends java.io.Serializable
    Definition Classes
    Implicits
  343. object Shadower
    Definition Classes
    Implicits
  344. object approximateAbstracts extends Global.TypeMap
    Definition Classes
    Infer
  345. object instantiate extends Global.TypeMap

    Map every TypeVar to its constraint.inst field.

    Map every TypeVar to its constraint.inst field. throw a NoInstance exception if a NoType or WildcardType is encountered.

    Definition Classes
    Infer
  346. object toOrigin extends Global.TypeMap
    Definition Classes
    Infer
  347. case object WeakSymbolAttachment extends Product with Serializable
    Definition Classes
    MacroAnnotationAttachments
  348. object MacroImplBinding extends java.io.Serializable
    Definition Classes
    Macros
  349. object NamedApplyBlock
    Definition Classes
    NamesDefaults
  350. case object DynamicRewriteAttachment extends Product with Serializable

    Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected from typedNamedApply, the applyDynamicNamed argument rewriter, the latter doesn’t know whether it needs to apply the rewriting because the application has just been desugared or it needs to hold on because it’s already performed a desugaring on this tree.

    Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected from typedNamedApply, the applyDynamicNamed argument rewriter, the latter doesn’t know whether it needs to apply the rewriting because the application has just been desugared or it needs to hold on because it’s already performed a desugaring on this tree. This has led to scala/bug#8006.

    This attachment solves the problem by providing a means of communication between the two Dynamic desugarers, which solves the aforementioned issue.

    Definition Classes
    StdAttachments
  351. case object MacroImplRefAttachment extends Product with Serializable

    Definition Classes
    StdAttachments
    See also

    markMacroImplRef

  352. case object SuppressMacroExpansionAttachment extends Product with Serializable

    When present, suppresses macro expansion for the host.

    When present, suppresses macro expansion for the host. This is occasionally necessary, e.g. to prohibit eta-expansion of macros.

    Does not affect expandability of child nodes, there's context.withMacrosDisabled for that (but think thrice before using that API - see the discussion at https://github.com/scala/scala/pull/1639).

    Definition Classes
    StdAttachments
  353. object UnusedPrivates
    Definition Classes
    TypeDiagnostics
  354. object checkDead
    Definition Classes
    TypeDiagnostics
  355. object SilentTypeError
    Definition Classes
    Typers
  356. object checkNoEscaping extends Global.TypeMap

    Check that type of given tree does not contain local or private components.

    Check that type of given tree does not contain local or private components.

    Definition Classes
    Typers
  357. object typingStack
    Definition Classes
    TypersTracking
  358. object HasUnapply
    Definition Classes
    Unapplies
  359. object UnapplyMemberResult extends Enumeration
    Definition Classes
    Unapplies
  360. object ImplicitError extends java.io.Serializable
    Definition Classes
    SplainData
  361. object ImplicitErrorSpecifics
    Definition Classes
    SplainData
  362. object ImplicitErrors
    Definition Classes
    SplainData
  363. object ByNameFormatter extends Analyzer.SpecialFormatter
    Definition Classes
    SplainFormatters
  364. object FunctionFormatter extends Analyzer.SpecialFormatter
    Definition Classes
    SplainFormatters
  365. object Refined
    Definition Classes
    SplainFormatters
  366. object RefinedFormatter extends Analyzer.SpecialFormatter
    Definition Classes
    SplainFormatters
  367. object TupleFormatter extends Analyzer.SpecialFormatter
    Definition Classes
    SplainFormatters
  368. object ImplicitErrorLink extends java.io.Serializable
    Definition Classes
    SplainFormatting
  369. object ImplicitErrorTree extends java.io.Serializable
    Definition Classes
    SplainFormatting

Deprecated Value Members

  1. def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult
    Definition Classes
    Implicits
    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.0-M4) Unused in scalac

  2. def inferImplicit(tree: Global.Tree, pt: Global.Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult
    Definition Classes
    Implicits
    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.0-M4) Unused in scalac

  3. def mkTypeCompleter(t: Global.Tree)(c: (Global.Symbol) => Unit): TypeCompleterBase[Global.Tree]
    Definition Classes
    Namers
    Annotations
    @deprecated
    Deprecated

    (Since version 2.12.2) Instantiate TypeCompleterBase (for monomorphic, non-wrapping completer) or CompleterWrapper directly.

Inherited from Erasure

Inherited from TypingTransformers

Inherited from Analyzer

Inherited from AnalyzerPlugins

Inherited from StdAttachments

Inherited from ContextErrors

Inherited from SplainErrors

Inherited from TypeDiagnostics

Inherited from SplainDiagnostics

Inherited from SplainFormatting

Inherited from SplainFormatters

Inherited from NamesDefaults

Inherited from Macros

Inherited from Helpers

Inherited from Traces

Inherited from MacroRuntimes

Inherited from JavaReflectionRuntimes

Inherited from Unapplies

Inherited from SyntheticMethods

Inherited from TreeDSL

Inherited from EtaExpansion

Inherited from Implicits

Inherited from SplainData

Inherited from Infer

Inherited from Checkable

Inherited from Typers

Inherited from PatternTypers

Inherited from TypersTracking

Inherited from Tags

Inherited from Adaptations

Inherited from Namers

Inherited from MethodSynthesis

Inherited from Contexts

Inherited from Erasure

Inherited from InfoTransform

Inherited from Transform

Inherited from SubComponent

Inherited from AnyRef

Inherited from Any

Ungrouped