abstract class Erasure extends SubComponent with InfoTransform with reflect.internal.transform.Erasure with Analyzer with TypingTransformers with TreeDSL with TypeAdaptingTransformer
- Alphabetic
- By Inheritance
- Erasure
- TypeAdaptingTransformer
- TypingTransformers
- Analyzer
- AnalyzerPlugins
- MacroAnnotationAttachments
- StdAttachments
- ContextErrors
- TypeDiagnostics
- NamesDefaults
- Macros
- Helpers
- Traces
- MacroRuntimes
- JavaReflectionRuntimes
- Unapplies
- SyntheticMethods
- TreeDSL
- EtaExpansion
- Implicits
- Infer
- Checkable
- Typers
- PatternTypers
- TypersTracking
- Tags
- Adaptations
- Namers
- MethodSynthesis
- Contexts
- Erasure
- InfoTransform
- Transform
- SubComponent
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new Erasure()
Type Members
- trait JavaReflectionResolvers extends AnyRef
- Definition Classes
- JavaReflectionRuntimes
- class MacroRuntimeResolver extends tools.nsc.typechecker.Analyzer.JavaReflectionResolvers
- Definition Classes
- MacroRuntimes
- abstract class StdPhase extends GlobalPhase
A standard phase template
A standard phase template
- Definition Classes
- SubComponent
- class EnterBridges extends AnyRef
- class Eraser extends Typer
The modifier typer which retypes with erased types.
- abstract class ErasureMap extends reflect.internal.SymbolTable.TypeMap
- Definition Classes
- Erasure
- class ErasureTransformer extends Global.Transformer
The erasure transformer
- class GenerateBridges extends EnterBridges
- type ImportType = Global.ImportType
- Definition Classes
- Contexts
- class JavaErasureMap extends ErasureMap
- Definition Classes
- Erasure
- type MacroContext = UnaffiliatedMacroContext { val universe: Erasure.this.global.type }
- Definition Classes
- StdAttachments
- type MacroRuntime = (MacroArgs) => Any
Abstracts away resolution of macro runtimes.
Abstracts away resolution of macro runtimes.
- Definition Classes
- MacroRuntimes
- class ScalaErasureMap extends ErasureMap
- Definition Classes
- Erasure
- 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
- class UnknownSig extends Exception
- class Phase extends InfoTransform.Phase
- Definition Classes
- InfoTransform
- abstract class TypeAdapter extends AnyRef
- Definition Classes
- TypeAdaptingTransformer
- abstract class TypingTransformer extends Global.Transformer
- Definition Classes
- TypingTransformers
- trait Adaptation extends AnyRef
- Definition Classes
- Adaptations
- trait AnalyzerPlugin extends AnyRef
- Definition Classes
- AnalyzerPlugins
- trait MacroPlugin extends AnyRef
- Definition Classes
- AnalyzerPlugins
- trait InferCheckable extends AnyRef
- Definition Classes
- Checkable
- abstract class AbsAmbiguousTypeError extends Analyzer.AbsTypeError
- Definition Classes
- ContextErrors
- sealed abstract class AbsTypeError extends AnyRef
- Definition Classes
- ContextErrors
- case class AccessTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.TreeTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- case class AmbiguousImplicitTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- case class AmbiguousTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsAmbiguousTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- case class DivergentImplicitTypeError(underlyingTree: Global.Tree, pt0: Global.Type, sym: Global.Symbol) extends Analyzer.TreeTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- trait ImplicitsContextErrors extends AnyRef
- Definition Classes
- ContextErrors
- trait InferencerContextErrors extends AnyRef
- Definition Classes
- ContextErrors
- trait NamerContextErrors extends AnyRef
- Definition Classes
- ContextErrors
- case class NormalTypeError(underlyingTree: Global.Tree, errMsg: String) extends Analyzer.TreeTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- case class PosAndMsgTypeError(errPos: Global.Position, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- case class SymbolTypeError(underlyingSym: Global.Symbol, errMsg: String) extends Analyzer.AbsTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- sealed abstract class TreeTypeError extends Analyzer.AbsTypeError
- Definition Classes
- ContextErrors
- case class TypeErrorWithUnderlyingTree(tree: Global.Tree, ex: Global.TypeError) extends Analyzer.AbsTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- case class TypeErrorWrapper(ex: Global.TypeError) extends Analyzer.AbsTypeError with Product with Serializable
- Definition Classes
- ContextErrors
- trait TyperContextErrors extends AnyRef
- Definition Classes
- ContextErrors
- 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: itenclosingContextChain
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 areimports
, which represents allImport
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 inrootContext
. Additionally, more fine grained control is needed based on the kind of error; ambiguity errors are often suppressed during exploratory typing, such as determining whethera == b
in an argument position is an assignment or a named argument, whenInferencer#isApplicableSafe
type checks applications with and without an expected type, or whenTyper#tryTypedApply
tries to fit arguments to a function type with/without implicit views.When the error policies entail error/warning buffering, the mutable ReportBuffer records everything that is issued. It is important to note, that child Contexts created with
make
"inherit" the very sameReportBuffer
instance, whereas children spawned throughmakeSilent
receive a separate, fresh buffer.- Definition Classes
- Contexts
- abstract class ContextReporter extends Reporter
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
- trait ImportContext extends Analyzer.Context
A
Context
focussed on anImport
treeA
Context
focussed on anImport
tree- Definition Classes
- Contexts
- class ImportInfo extends AnyRef
- Definition Classes
- Contexts
- class ImplicitAnnotationMsg extends AnyRef
- Definition Classes
- Implicits
- class ImplicitInfo extends AnyRef
A class that records an available implicit
A class that records an available implicit
- Definition Classes
- Implicits
- 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
- class Message extends AnyRef
- Definition Classes
- Implicits
- 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
- class SearchResult extends AnyRef
The result of an implicit search
The result of an implicit search
- Definition Classes
- Implicits
- 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
- abstract class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable
The context-dependent inferencer part
The context-dependent inferencer part
- Definition Classes
- Infer
- class NoInstance extends ControlThrowable
- Definition Classes
- Infer
- case class CacheAttachment(cache: Map[String, Any]) extends Product with Serializable
- Definition Classes
- MacroAnnotationAttachments
- implicit class RichTree extends AnyRef
- Definition Classes
- MacroAnnotationAttachments
- case class SymbolCompleterAttachment(info: Global.Type) extends Product with Serializable
- Definition Classes
- MacroAnnotationAttachments
- case class SymbolExpansionAttachment(expansion: List[Global.Tree]) extends Product with Serializable
- Definition Classes
- MacroAnnotationAttachments
- case class SymbolSourceAttachment(source: Global.Tree) extends Product with Serializable
- Definition Classes
- MacroAnnotationAttachments
- class DefMacroExpander extends Analyzer.MacroExpander
Expands a term macro used in apply role as
M(2)(3)
inval x = M(2)(3)
.Expands a term macro used in apply role as
M(2)(3)
inval x = M(2)(3)
.- Definition Classes
- Macros
- case class Delayed(delayed: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
- Definition Classes
- Macros
- case class Failure(failure: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
- Definition Classes
- Macros
- case class Fallback(fallback: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
- Definition Classes
- Macros
- 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
- 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 theexpandee
to fit into the default expansion scheme that is understood bymacroExpandWithRuntime
/macroExpandWithoutRuntime
Then
macroExpandWithRuntime
: 2) Checks whether the expansion needs to be delayed 3) Loads macro implementation usingmacroMirror
4) Synthesizes invocation arguments for the macro implementation 5) Checks that the result is a tree or an expr bound to this universeFinally
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 applicationIf -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
- 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
- sealed abstract class MacroStatus extends AnyRef
- Definition Classes
- Macros
- case class Skipped(skipped: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
- Definition Classes
- Macros
- case class Success(expanded: Global.Tree) extends Analyzer.MacroStatus with Product with Serializable
- Definition Classes
- Macros
- class ClassMethodSynthesis extends AnyRef
- Definition Classes
- MethodSynthesis
- 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
- 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
- trait LockingTypeCompleter extends Analyzer.TypeCompleter
- Definition Classes
- Namers
- abstract class Namer extends Analyzer.MethodSynth with Analyzer.NamerContextErrors
- Definition Classes
- Namers
- 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 theowner
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
- abstract class TypeCompleter extends Global.LazyType
- Definition Classes
- Namers
- abstract class TypeCompleterBase[T <: Global.Tree] extends Analyzer.TypeCompleter with Analyzer.LockingTypeCompleter with Global.FlagAgnosticCompleter
- Definition Classes
- Namers
- class CaseApplyDefaultGetters extends AnyRef
- Definition Classes
- NamesDefaults
- class ConstructorDefaultsAttachment extends AnyRef
- Definition Classes
- NamesDefaults
- class DefaultsOfLocalMethodAttachment extends AnyRef
- Definition Classes
- NamesDefaults
- 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
- trait PatternTyper extends AnyRef
- Definition Classes
- PatternTypers
- 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
- 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
- case class MacroRuntimeAttachment(delayed: Boolean, typerContext: Analyzer.Context, macroContext: Option[Analyzer.MacroContext]) extends Product with Serializable
- Definition Classes
- StdAttachments
- 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
- case class StabilizingDefinitions(vdefs: List[Global.ValDef]) extends Product with Serializable
- Definition Classes
- StdAttachments
- 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 coordinatesparentTypes
andtypedTemplate
and allows them to complete the synthesis.- Definition Classes
- StdAttachments
- trait Tag extends AnyRef
- Definition Classes
- Tags
- case class TypeDiag(tp: Global.Type, sym: Global.Symbol) extends Ordered[(TypeDiagnostics.this)#TypeDiag] with Product with Serializable
- Definition Classes
- TypeDiagnostics
- trait TyperDiagnostics extends AnyRef
- Definition Classes
- TypeDiagnostics
- class checkUnused extends AnyRef
- Definition Classes
- TypeDiagnostics
- sealed abstract class SilentResult[+T] extends AnyRef
- Definition Classes
- Typers
- case class SilentResultValue[+T](value: T) extends Analyzer.SilentResult[T] with Product with Serializable
- Definition Classes
- Typers
- class SilentTypeError extends Analyzer.SilentResult[Nothing]
- Definition Classes
- Typers
- abstract class Typer extends Analyzer.TyperDiagnostics with Analyzer.Adaptation with Analyzer.Tag with Analyzer.PatternTyper with Analyzer.TyperContextErrors
- Definition Classes
- Typers
- class ClassForCaseCompanionAttachment extends AnyRef
- Definition Classes
- Unapplies
Abstract Value Members
- abstract val global: Global
- Definition Classes
- TypingTransformers
- abstract val runsAfter: List[String]
Names of phases that must run before this phase.
Names of phases that must run before this phase.
- Definition Classes
- SubComponent
- abstract val runsRightAfter: Option[String]
Name of the phase that this phase must follow immediately.
Name of the phase that this phase must follow immediately.
- Definition Classes
- SubComponent
Concrete Value Members
- object CODE
- Definition Classes
- TreeDSL
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (Erasure, B)
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- lazy val AmbiguousSearchFailure: SearchResult
- Definition Classes
- Implicits
- def Delay(expanded: Global.Tree): Delayed
- Definition Classes
- Macros
- lazy val DivergentSearchFailure: SearchResult
- Definition Classes
- Implicits
- val ImportType: Global.ImportType.type
- Definition Classes
- Contexts
- def MacroCantExpand210xMacrosError(internalMessage: String): Nothing
- Definition Classes
- ContextErrors
- def MacroCantExpandIncompatibleMacrosError(internalMessage: String): Nothing
- Definition Classes
- ContextErrors
- def NoImplicitFoundError(tree: Global.Tree, param: Global.Symbol)(implicit context: Context): Unit
- Definition Classes
- ContextErrors
- val NoImplicitInfo: ImplicitInfo
A sentinel indicating no implicit was found
A sentinel indicating no implicit was found
- Definition Classes
- Implicits
- lazy val SearchFailure: SearchResult
- Definition Classes
- Implicits
- def SearchedPrefixImplicitInfo(pre: Global.Type): ImplicitInfo
- Definition Classes
- Implicits
- def Skip(expanded: Global.Tree): Skipped
- Definition Classes
- Macros
- val _openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: Erasure.this.global.type }]
Keeps track of macros in-flight.
Keeps track of macros in-flight. See more informations in comments to
openMacros
inscala.reflect.macros.whitebox.Context
.- Definition Classes
- Macros
- 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
- 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 themember.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 returnsmember.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. - def adaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Global.Tree
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.adaptAnnotations
- def addAnalyzerPlugin(plugin: AnalyzerPlugin): Unit
Registers a new analyzer plugin
Registers a new analyzer plugin
- Definition Classes
- AnalyzerPlugins
- def addDefaults(givenArgs: List[Global.Tree], qual: Option[Global.Tree], targs: List[Global.Tree], previousArgss: List[List[Global.Tree]], params: List[Global.Symbol], pos: 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.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
- def addMacroPlugin(plugin: MacroPlugin): Unit
Registers a new macro plugin
Registers a new macro plugin
- Definition Classes
- AnalyzerPlugins
- def addStabilizingDefinition(tree: Global.Tree, vdef: Global.ValDef): Global.Tree
- Definition Classes
- StdAttachments
- 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
- final def afterOwnPhase[T](op: => T): T
- Definition Classes
- SubComponent
- Annotations
- @inline()
- def allArgsArePositional(a: Array[Int]): Boolean
returns
true
if every element is equal to its indexreturns
true
if every element is equal to its index- Definition Classes
- NamesDefaults
- def allViewsFrom(tp: Global.Type, context: Context, tpars: List[Global.Symbol]): List[(SearchResult, List[Global.TypeConstraint])]
Find all views from type
tp
(in whichtpars
are free)Find all views from type
tp
(in whichtpars
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
- def alternatives(tree: Global.Tree): List[Global.Type]
- Definition Classes
- TypeDiagnostics
- def alternativesString(tree: Global.Tree): String
- Definition Classes
- TypeDiagnostics
- def ambiguousDefnAndImport(owner: Global.Symbol, imp: ImportInfo): Global.LookupAmbiguous
- Definition Classes
- Contexts
- def ambiguousImports(imp1: ImportInfo, imp2: ImportInfo): Global.LookupAmbiguous
- Definition Classes
- Contexts
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def attachExpansion(sym: Global.Symbol, trees: List[Global.Tree]): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- def attachSource(sym: Global.Symbol, tree: Global.Tree): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- def attachedExpansion(sym: Global.Symbol): Option[List[Global.Tree]]
- Definition Classes
- MacroAnnotationAttachments
- def attachedSource(sym: Global.Symbol): Global.Tree
- Definition Classes
- MacroAnnotationAttachments
- def backupCompleter(sym: Global.Symbol): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- final def beforeOwnPhase[T](op: => T): T
- Definition Classes
- SubComponent
- Annotations
- @inline()
- def bindMacroImpl(macroDef: Global.Symbol, macroImplRef: Global.Tree): Unit
- Definition Classes
- Macros
- def canAdaptAnnotations(tree: Global.Tree, typer: Typer, mode: Mode, pt: Global.Type): Boolean
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.canAdaptAnnotations
- 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
- 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 ofcopy
) 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) isB.this.C
- not the same.This is fixed with a hack currently.
Unapplies.caseClassCopyMeth
, which creates the copy method, uses emptyTypeTree()
nodes for parameter types.In
Namers.enterDefDef
, the copy method gets a special type completer (enterCopyMethod
). Before computing the body type ofcopy
, 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
- 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
- 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
- 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
- def changesBaseClasses: Boolean
- Attributes
- protected
- Definition Classes
- InfoTransform
- def clearDelayed(): Unit
- Definition Classes
- Macros
- final def clearRenamedCaseAccessors(caseclazz: Global.Symbol): Unit
- Definition Classes
- SyntheticMethods
- def clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def companionModuleDef(cdef: Global.ClassDef, parents: List[Global.Tree] = Nil, body: List[Global.Tree] = Nil): Global.ModuleDef
- Definition Classes
- Unapplies
- 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
- 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?
- def decodeWithKind(name: Global.Name, owner: Global.Symbol): String
- Definition Classes
- TypeDiagnostics
- val deconstMap: Global.TypeMap
- 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
- 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
- def defaultMacroClassloader: ClassLoader
- Definition Classes
- MacroRuntimes
- 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 supertypeObject
, notAClass
. - 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
- def disambiguate(ss: List[String]): collection.immutable.List[String]
- Definition Classes
- TypeDiagnostics
- def enabled: Boolean
Is this component enabled? Default is true.
Is this component enabled? Default is true.
- Definition Classes
- SubComponent
- def enclosingMacroPosition: Position
- Definition Classes
- Macros
- def ensuring(cond: (Erasure) => Boolean, msg: => Any): Erasure
- def ensuring(cond: (Erasure) => Boolean): Erasure
- def ensuring(cond: Boolean, msg: => Any): Erasure
- def ensuring(cond: Boolean): Erasure
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def erasedValueClassArg(tref: Global.TypeRef): Global.Type
- Definition Classes
- Erasure
- def erasure(sym: Global.Symbol): ErasureMap
- Definition Classes
- Erasure
- def etaExpand(unit: Global.CompilationUnit, 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)
. Does not support dependent method types (yet).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
- 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
- val excludedRootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]
- Definition Classes
- Contexts
- def existentialContext(tp: Global.Type): String
- Definition Classes
- TypeDiagnostics
- def explainAlias(tp: Global.Type): String
- Definition Classes
- TypeDiagnostics
- def explainAnyVsAnyRef(found: Global.Type, req: Global.Type): String
- Definition Classes
- TypeDiagnostics
- 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
- 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
- final def falseIfNoInstance(body: => Boolean): Boolean
- Definition Classes
- Infer
- Annotations
- @inline()
- lazy val fastTrack: FastTrack[Erasure.this.type]
- Definition Classes
- Macros
- def finalOwners(tpe: Global.Type): Boolean
- Definition Classes
- TypeDiagnostics
- def finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- 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
- final def forArgMode(fun: Global.Tree, mode: Mode): reflect.internal.Mode
- Definition Classes
- Typers
- 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
. Ifformals
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
- def formatted(fmtstr: String): String
- def foundReqMsg(found: Global.Type, req: Global.Type): String
- Definition Classes
- TypeDiagnostics
- def freshNameCreatorFor(context: Context): FreshNameCreator
- Definition Classes
- Typers
- 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
- def fullSiteString(context: Context): String
- Definition Classes
- TypersTracking
- final def getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def globalSettings: Settings
- def hasAttachedExpansion(sym: Global.Symbol): Boolean
- Definition Classes
- MacroAnnotationAttachments
- 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
- 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
- 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
- def hashCode(): Int
SubComponent are added to a HashSet and two phases are the same if they have the same name
SubComponent are added to a HashSet and two phases are the same if they have the same name
- Definition Classes
- SubComponent → AnyRef → Any
- 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
- 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
- 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 classImplicitSearch
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 usetree.pos
- returns
A search result
- Definition Classes
- Implicits
- def inferImplicitByType(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult
- Definition Classes
- Implicits
- def inferImplicitByTypeSilent(pt: Global.Type, context: Context, pos: Global.Position = NoPosition): SearchResult
- Definition Classes
- Implicits
- def inferImplicitFor(pt: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean = true): SearchResult
- Definition Classes
- Implicits
- def inferImplicitView(from: Global.Type, to: Global.Type, tree: Global.Tree, context: Context, reportAmbiguous: Boolean, saveAmbiguousDivergent: Boolean): SearchResult
- Definition Classes
- Implicits
- 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
- def instantiateSamFromFunction(funTp: Global.Type, samTp: Global.Type, sam: Global.Symbol): Global.Type
- Definition Classes
- Infer
- 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
- def intersectionDominator(parents: List[Global.Type]): Global.Type
- Definition Classes
- Erasure
- def isBlackbox(macroDef: Global.Symbol): Boolean
- Definition Classes
- Macros
- def isBlackbox(expandee: Global.Tree): Boolean
- Definition Classes
- Macros
- def isDynamicRewrite(tree: Global.Tree): Boolean
- Definition Classes
- StdAttachments
- def isExpanded(sym: Global.Symbol): Boolean
- Definition Classes
- MacroAnnotationAttachments
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def isJvmAccessible(cls: Global.Symbol, context: Context): Boolean
- 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
- 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
- def isMaybeExpandee(sym: Global.Symbol): Boolean
- Definition Classes
- MacroAnnotationAttachments
- def isNamedArg(arg: Global.Tree): Boolean
- Definition Classes
- NamesDefaults
- def isNotExpandable(sym: Global.Symbol): Boolean
- Definition Classes
- MacroAnnotationAttachments
- def isWeak(sym: Global.Symbol): Boolean
- Definition Classes
- MacroAnnotationAttachments
- 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.
- def keepsTypeParams: Boolean
- Definition Classes
- Erasure → InfoTransform
- val lastAccessCheckDetails: String
- Definition Classes
- Contexts
- val lastTreeToTyper: Global.Tree
- Definition Classes
- TypersTracking
- def linePrecedes(t1: Global.Tree, t2: Global.Tree): Boolean
- Definition Classes
- TypeDiagnostics
- 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
- 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
. Theexpanded
parameter is of typeAny
, because macros can expand both into trees and into annotations.- Definition Classes
- StdAttachments
- final def linkedClassOfClassOf(original: Global.Symbol, ctx: Context): Global.Symbol
A version of
Symbol#linkedClassOfClass
that works with local companions, alacompanionSymbolOf
.A version of
Symbol#linkedClassOfClass
that works with local companions, alacompanionSymbolOf
.- Definition Classes
- Namers
- def loadMacroImplBinding(macroDef: Global.Symbol): Option[MacroImplBinding]
- Definition Classes
- Macros
- def macroArgs(typer: Typer, expandee: Global.Tree): MacroArgs
- Definition Classes
- Macros
- def macroContext(typer: Typer, prefixTree: Global.Tree, expandeeTree: Global.Tree): MacroContext
- Definition Classes
- Macros
- val macroDebugLite: Boolean
- Definition Classes
- Traces
- val macroDebugVerbose: Boolean
- Definition Classes
- Traces
- def macroEngine: String
Macro def -> macro impl bindings are serialized into a
macroImpl
annotation with synthetic content that carries the payload described inMacroImplBinding
.Macro def -> macro impl bindings are serialized into a
macroImpl
annotation with synthetic content that carries the payload described inMacroImplBinding
.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
:- Definition Classes
- Macros
- 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)
inval x = M(2)(3)
.Expands a term macro used in apply role as
M(2)(3)
inval x = M(2)(3)
.- Definition Classes
- Macros
- See also
DefMacroExpander
- 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
- 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
- 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
- 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
- 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
- final def macroLogLite(msg: => Any): Unit
- Definition Classes
- Traces
- Annotations
- @inline()
- final def macroLogVerbose(msg: => Any): Unit
- Definition Classes
- Traces
- Annotations
- @inline()
- 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
- def makeNamedTypes(syms: List[Global.Symbol]): collection.immutable.List[Global.NamedType]
- Definition Classes
- NamesDefaults
- def markDynamicRewrite(tree: Global.Tree): Global.Tree
- Definition Classes
- StdAttachments
- def markExpanded(sym: Global.Symbol): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- 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
- def markMaybeExpandee(sym: Global.Symbol): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- def markNotExpandable(sym: Global.Symbol): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- def markWeak(sym: Global.Symbol): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- 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
- def minimizeParents(cls: Global.Symbol, parents: List[Global.Type]): List[Global.Type]
- 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
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def newNamer(context: Context): Namer
- Definition Classes
- Namers
- def newPhase(prev: nsc.Phase): StdPhase
Create a new phase which applies transformer
Create a new phase which applies transformer
- Definition Classes
- InfoTransform → Transform → SubComponent
- def newTransformer(unit: Global.CompilationUnit): Global.Transformer
The transformer factory
- def newTyper(context: Context): Eraser
- def noPrintAdapt(tree1: Global.Tree, tree2: Global.Tree): Boolean
- Definition Classes
- TypersTracking
- def noPrintTyping(t: Global.Tree): Boolean
- Definition Classes
- TypersTracking
- def notAnyRefMessage(found: Global.Type): String
- Definition Classes
- ContextErrors
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def notifyUndetparamsAdded(newUndets: List[Global.Symbol]): Unit
- Definition Classes
- Macros
- def notifyUndetparamsInferred(undetNoMore: List[Global.Symbol], inferreds: List[Global.Type]): Unit
- Definition Classes
- Macros
- def numericConversion(tree: Global.Tree, numericSym: Global.Symbol): Global.Tree
- def onTreeCheckerError(pos: Global.Position, msg: String): Unit
- Attributes
- protected
- Definition Classes
- Contexts
- def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: Erasure.this.global.type }]
- Definition Classes
- Macros
- 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
- val phaseName: String
The name of the phase
The name of the phase
- Definition Classes
- Erasure → SubComponent
- 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
- 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
- def pluginsEnsureCompanionObject(namer: Namer, cdef: Global.ClassDef, creator: (Global.ClassDef) => Global.Tree = companionModuleDef(_)): Global.Symbol
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsEnsureCompanionObject
- def pluginsEnterStats(typer: Typer, stats: List[Global.Tree]): List[Global.Tree]
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsEnterStats
- def pluginsEnterSym(namer: Namer, tree: Global.Tree): Context
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsEnterSym
- def pluginsIsBlackbox(macroDef: Global.Symbol): Boolean
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsIsBlackbox
- def pluginsMacroArgs(typer: Typer, expandee: Global.Tree): MacroArgs
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsMacroArgs
- def pluginsMacroExpand(typer: Typer, expandee: Global.Tree, mode: Mode, pt: Global.Type): Global.Tree
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsMacroExpand
- def pluginsMacroRuntime(expandee: Global.Tree): MacroRuntime
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsMacroRuntime
- def pluginsNotifyImplicitSearch(search: ImplicitSearch): Unit
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.pluginsImplicitSearch
- def pluginsNotifyImplicitSearchResult(result: SearchResult): Unit
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.pluginsImplicitSearchResult
- def pluginsPt(pt: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode): Global.Type
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.pluginsPt
- def pluginsTypeSig(tpe: Global.Type, typer: Typer, defTree: Global.Tree, pt: Global.Type): Global.Type
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.pluginsTypeSig
- def pluginsTypeSigAccessor(tpe: Global.Type, typer: Typer, tree: Global.ValDef, sym: Global.Symbol): Global.Type
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.pluginsTypeSigAccessor
- def pluginsTyped(tpe: Global.Type, typer: Typer, tree: Global.Tree, mode: Mode, pt: Global.Type): Global.Type
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.pluginsTyped
- def pluginsTypedMacroBody(typer: Typer, ddef: Global.DefDef): Global.Tree
- Definition Classes
- AnalyzerPlugins
- See also
MacroPlugin.pluginsTypedMacroBody
- def pluginsTypedReturn(tpe: Global.Type, typer: Typer, tree: Global.Return, pt: Global.Type): Global.Type
- Definition Classes
- AnalyzerPlugins
- See also
AnalyzerPlugin.pluginsTypedReturn
- def popMacroContext(): Unit
- Definition Classes
- Macros
- 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
- val prepareSigMap: Global.TypeMap { def squashBoxed(tp: Erasure.this.global.Type): Erasure.this.global.Type }
This object is only used for sanity testing when -check:genjvm is set.
This object is only used for sanity testing 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. - def printingOk(t: Global.Tree): Boolean
- Definition Classes
- TypersTracking
- 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
- def pushMacroContext(c: MacroContext): Unit
- Definition Classes
- Macros
- def rebindInnerClass(pre: Global.Type, cls: Global.Symbol): Global.Type
- Attributes
- protected
- Definition Classes
- Erasure
- final def recursivelyFinal(tpe: Global.Type): Boolean
- Definition Classes
- TypeDiagnostics
- Annotations
- @tailrec()
- def registerImport(ctx: Context, imp: Global.Import): Unit
- Definition Classes
- Contexts
- 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
- def removeStabilizingDefinitions(tree: Global.Tree): Global.Tree
- Definition Classes
- StdAttachments
- 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
- val requiredDirectInterfaces: AnyRefMap[Global.Symbol, Set[Global.Symbol]]
- val requires: List[String]
Names of phases required by this component.
Names of phases required by this component. Default is
Nil
.- Definition Classes
- SubComponent
- def resetContexts(): Unit
- Definition Classes
- Contexts
- def resetDocComments(): Unit
- Definition Classes
- Typers
- def resetImplicits(): Unit
- Definition Classes
- Implicits
- def resetTyper(): Unit
- Definition Classes
- Typers
- final def resolveAnonymousBridgeClash(sym: Global.Symbol, bridge: Global.Symbol): Unit
- def restoreCompleter(sym: Global.Symbol): Unit
- Definition Classes
- MacroAnnotationAttachments
- def restrictionError(pos: Global.Position, unit: Global.CompilationUnit, msg: String): Unit
- Definition Classes
- TypeDiagnostics
- def restrictionWarning(pos: Global.Position, unit: Global.CompilationUnit, msg: String): 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
- def rootContext(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context
- Definition Classes
- Contexts
- def rootContextPostTyper(unit: Global.CompilationUnit, tree: Global.Tree = EmptyTree): Context
- Definition Classes
- Contexts
- 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
- if option
- val rootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]
- Definition Classes
- Contexts
- 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
- def setAddendum(pos: Global.Position, msg: () => String): Unit
- Definition Classes
- TypeDiagnostics
- final val shortenImports: Boolean(false)
- Definition Classes
- Typers
- def skipImplicit(tp: Global.Type): Global.Type
- Definition Classes
- Infer
- def solvedTypes(tvars: List[Global.TypeVar], tparams: List[Global.Symbol], variances: List[Variance], 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
- variances
The variances of type parameters; need to reverse solution direction for all contravariant variables.
- upper
When
true
search for max solution else min.
- Definition Classes
- Infer
- Exceptions thrown
- def specialConstructorErasure(clazz: Global.Symbol, tpe: Global.Type): Global.Type
- Definition Classes
- Erasure
- def specialErasure(sym: Global.Symbol)(tp: Global.Type): Global.Type
- Definition Classes
- Erasure
- def stabilizingDefinitions(tree: Global.Tree): List[Global.ValDef]
- Definition Classes
- StdAttachments
- 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
- 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
- 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
- def standardMacroRuntime(expandee: Global.Tree): MacroRuntime
- Definition Classes
- MacroRuntimes
- 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
- def superArgs(tree: Global.Tree): Option[List[List[Global.Tree]]]
Convenience method for
SuperArgsAttachment
.Convenience method for
SuperArgsAttachment
. Compared withMacroRuntimeAttachment
this attachment has different a usage pattern, so it really benefits from a dedicated extractor.- Definition Classes
- StdAttachments
- def suppressMacroExpansion(tree: Global.Tree): Global.Tree
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
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- 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
- def toString(): String
- Definition Classes
- AnyRef → Any
- def tpe_s(tp: Global.Type, colorize: (String) => String): String
- Definition Classes
- TypersTracking
- def transformInfo(sym: Global.Symbol, tp: Global.Type): Global.Type
- Definition Classes
- Erasure
- 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
- returns
the transformed application (a Block) together with the NamedApplyInfo. if isNamedApplyBlock(tree), returns the existing context.namedApplyBlockInfo
- Definition Classes
- NamesDefaults
- 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
- def treeSymTypeMsg(tree: Global.Tree): String
- Definition Classes
- TypeDiagnostics
- def typePatternAdvice(sym: Global.Symbol, ptSym: Global.Symbol): String
- Definition Classes
- TypeDiagnostics
- 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
- def typerShouldExpandDeferredMacros: Boolean
- Definition Classes
- Macros
- 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
- def unapplyMember(tp: Global.Type): Global.Symbol
Filters out unapplies with multiple (non-implicit) parameter lists, as they cannot be used as extractors
Filters out unapplies with multiple (non-implicit) parameter lists, as they cannot be used as extractors
- Definition Classes
- Unapplies
- def unboundedGenericArrayLevel(tp: Global.Type): Int
- Definition Classes
- Erasure
- 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
- def unmarkDynamicRewrite(tree: Global.Tree): Global.Tree
- Definition Classes
- StdAttachments
- def unmarkExpanded(sym: Global.Symbol): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- 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
- def unmarkWeak(sym: Global.Symbol): Global.Symbol
- Definition Classes
- MacroAnnotationAttachments
- def unsuppressMacroExpansion(tree: Global.Tree): Global.Tree
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
- 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
- def valueClassIsParametric(clazz: Global.Symbol): Boolean
- Definition Classes
- Erasure
- def verifyJavaErasure: Boolean
- Attributes
- protected
- Definition Classes
- Erasure → Erasure
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def warnUnusedImports(unit: Global.CompilationUnit): Unit
- Definition Classes
- Contexts
- def withAddendum(pos: Global.Position): (String) => String
- Definition Classes
- TypeDiagnostics
- 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
- object GenericArray
- Definition Classes
- Erasure
- object javaErasure extends JavaErasureMap
- Definition Classes
- Erasure
- object specialScalaErasure extends ScalaErasureMap
- Definition Classes
- Erasure
- object namerFactory extends SubComponent
- Definition Classes
- Analyzer
- object packageObjects extends SubComponent
- Definition Classes
- Analyzer
- object typerFactory extends SubComponent
- Definition Classes
- Analyzer
- object ErrorUtils
- Definition Classes
- ContextErrors
- object NamesDefaultsErrorsGen
- Definition Classes
- ContextErrors
- object NoContext extends Analyzer.Context
- Definition Classes
- Contexts
- object Function1
An extractor for unary function types arg => res
An extractor for unary function types arg => res
- Definition Classes
- Implicits
- object HasMember
An extractor for types of the form ? { name: ? }
An extractor for types of the form ? { name: ? }
- Definition Classes
- Implicits
- 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
- object ImplicitAmbiguousMsg extends Analyzer.ImplicitAnnotationMsg
- Definition Classes
- Implicits
- object ImplicitNotFoundMsg extends Analyzer.ImplicitAnnotationMsg
- Definition Classes
- Implicits
- object OpenImplicit extends java.io.Serializable
- Definition Classes
- Implicits
- object Shadower
- Definition Classes
- Implicits
- object approximateAbstracts extends Global.TypeMap
- Definition Classes
- Infer
- 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
- object toOrigin extends Global.TypeMap
- Definition Classes
- Infer
- object WeakSymbolAttachment extends Product with Serializable
- Definition Classes
- MacroAnnotationAttachments
- object MacroImplBinding extends java.io.Serializable
- Definition Classes
- Macros
- object NamedApplyBlock
- Definition Classes
- NamesDefaults
- 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
- object MacroImplRefAttachment extends Product with Serializable
- Definition Classes
- StdAttachments
- See also
markMacroImplRef
- 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
- object TypedExpectingUnitAttachment extends Product with Serializable
Marks a Typed tree with Unit tpt.
Marks a Typed tree with Unit tpt.
- Definition Classes
- StdAttachments
- object checkDead
- Definition Classes
- TypeDiagnostics
- object SilentTypeError
- Definition Classes
- Typers
- 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
- object typingStack
- Definition Classes
- TypersTracking
- object HasUnapply
- Definition Classes
- Unapplies
Deprecated Value Members
- 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
- 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
- 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.
- def →[B](y: B): (Erasure, B)
- Implicit
- This member is added by an implicit conversion from Erasure toArrowAssoc[Erasure] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.
The Scala compiler and reflection APIs.