TreeCheckers

abstract class TreeCheckers extends Analyzer

Source: TreeCheckers.scala

Known Subclasses

treeChecker

Type Hierarchy

Ordering

Alphabetic
By Inheritance

Inherited

TreeCheckers
Analyzer
AnalyzerPlugins
MacroAnnotationAttachments
StdAttachments
ContextErrors
SplainErrors
TypeDiagnostics
SplainDiagnostics
SplainFormatting
SplainFormatters
NamesDefaults
Macros
Helpers
Traces
MacroRuntimes
JavaReflectionRuntimes
Unapplies
SyntheticMethods
TreeDSL
EtaExpansion
Implicits
SplainData
Infer
Checkable
Typers
PatternTypers
TypersTracking
Tags
Adaptations
Namers
MethodSynthesis
Contexts
AnyRef
Any

Implicitly

by any2stringadd
by StringFormat
by Ensuring
by ArrowAssoc

Hide All
Show All

Visibility

Public
Protected

Instance Constructors

new TreeCheckers()

Type Members

trait JavaReflectionResolvers extends AnyRef
Definition Classes
JavaReflectionRuntimes
class MacroRuntimeResolver extends tools.nsc.typechecker.Analyzer.JavaReflectionResolvers
Definition Classes
MacroRuntimes
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: 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
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
final class ImportContext extends Analyzer.Context
A Context focussed on an Import tree
A Context focussed on an Import 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) 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
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 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
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 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
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 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
trait Tag extends AnyRef
Definition Classes
Tags
type Checkability = Int
Definition Classes
Checkable
case class DiffResult[T](lost: List[T], gained: List[T]) extends Product with Serializable
type ImportType = Global.ImportType
Definition Classes
Contexts
type MacroContext = UnaffiliatedMacroContext { val universe: TreeCheckers.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 TreeChecker extends Typer
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
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 UnusedPrivates extends Global.Traverser
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
case class ImplicitError(tpe: Global.Type, candidate: Global.Tree, nesting: Int, specifics: Analyzer.ImplicitErrorSpecifics) extends Product with Serializable
Definition Classes
SplainData
sealed trait ImplicitErrorSpecifics extends AnyRef
Definition Classes
SplainData
trait SpecialFormatter extends AnyRef
Definition Classes
SplainFormatters
case class TypeParts(sym: Global.Symbol, tt: Global.Type) extends Product with Serializable
Definition Classes
SplainFormatting

Abstract Value Members

abstract val global: Global
Definition Classes
Analyzer → TreeDSL

Concrete Value Members

object CODE
Definition Classes
TreeDSL
object namerFactory extends SubComponent
Definition Classes
Analyzer
object packageObjects extends SubComponent
Definition Classes
Analyzer
object typerFactory extends SubComponent
Definition Classes
Analyzer
object Checkability
Definition Classes
Checkable
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
case object WeakSymbolAttachment extends Product with Serializable
Definition Classes
MacroAnnotationAttachments
object MacroImplBinding extends java.io.Serializable
Definition Classes
Macros
object NamedApplyBlock
Definition Classes
NamesDefaults
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
case object MacroImplRefAttachment extends Product with Serializable
Definition Classes
StdAttachments
See also
markMacroImplRef
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
case object TypedExpectingUnitAttachment extends Product with Serializable
Marks a Typed tree with Unit tpt.
Marks a Typed tree with Unit tpt.
Definition Classes
StdAttachments
final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
def +(other: String): String
Implicit
This member is added by an implicit conversion from TreeCheckers toany2stringadd[TreeCheckers] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (TreeCheckers, B)
Implicit
This member is added by an implicit conversion from TreeCheckers toArrowAssoc[TreeCheckers] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
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 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
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: TreeCheckers.this.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
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
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 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
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
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
def alternatives(tree: Global.Tree): List[Global.Type]
Definition Classes
TypeDiagnostics
def alternativesString(tree: Global.Tree): String
Definition Classes
TypeDiagnostics
def ambiguousDefinitions(owner: Global.Symbol, other: Global.Symbol): Global.LookupAmbiguous
Definition Classes
Contexts
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 assertFn(cond: Boolean, msg: => Any): Unit
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
def bindMacroImpl(macroDef: Global.Symbol, macroImplRef: Global.Tree): Unit
Definition Classes
Macros
def bracket[A](params: List[A]): String
Definition Classes
SplainFormatting
def breakInfix(types: 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
val breakInfixLength: Int
Definition Classes
SplainFormatting
def builtinFoundReqMsg(found: Global.Type, req: Global.Type): String
Definition Classes
TypeDiagnostics
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 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
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 check(unit: Global.CompilationUnit): Unit
def checkTrees(): Unit
def clearDelayed(): Unit
Definition Classes
Macros
final def clearRenamedCaseAccessors(caseclazz: Global.Symbol): Unit
Definition Classes
SyntheticMethods
def clone(): AnyRef
Attributes
protected[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
def ctorNames(tpe: Global.Type): List[String]
Definition Classes
SplainFormatting
def dealias(tpe: Global.Type): Global.Type
Definition Classes
SplainFormatting
def decideBreak(flat: FlatType, broken: => BrokenType): TypeRepr
Definition Classes
SplainFormatting
def decodeWithKind(name: Global.Name, owner: Global.Symbol): String
Definition Classes
TypeDiagnostics
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 deepestLevel(chain: List[ImplicitError]): Int
Definition Classes
SplainFormatting
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
def diff(t1: Global.Tree, t2: Global.Tree): String
def diffList[T](xs: List[T], ys: List[T]): DiffResult[T]
def diffTemplates(t1: Global.Template, t2: Global.Template): String
def diffTrees(t1: Global.Tree, t2: Global.Tree): DiffResult[Global.Tree]
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 enclosingMacroPosition: Position
Definition Classes
Macros
def ensuring(cond: (TreeCheckers) => Boolean, msg: => Any): TreeCheckers
Implicit
This member is added by an implicit conversion from TreeCheckers toEnsuring[TreeCheckers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (TreeCheckers) => Boolean): TreeCheckers
Implicit
This member is added by an implicit conversion from TreeCheckers toEnsuring[TreeCheckers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: => Any): TreeCheckers
Implicit
This member is added by an implicit conversion from TreeCheckers toEnsuring[TreeCheckers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): TreeCheckers
Implicit
This member is added by an implicit conversion from TreeCheckers toEnsuring[TreeCheckers] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def errorFn(msg: Any): Unit
def errorFn(pos: Global.Position, msg: Any): Unit
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). 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
Annotations
@nowarn()
def explicitlyUnit(tree: Global.Tree): Boolean
Definition Classes
StdAttachments
def extractArgs(tpe: Global.Type): collection.immutable.List[Global.Type]
Definition Classes
SplainFormatting
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[TreeCheckers.this.type]
Definition Classes
Macros
def finalOwners(tpe: Global.Type): Boolean
Definition Classes
TypeDiagnostics
def finalize(): Unit
Attributes
protected[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
def flattenInfix(tpe: Infix): 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
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. 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
def formatAuxSimple(tpe: Global.Type): (List[String], String)
Definition Classes
SplainFormatting
def formatDiff(left: Global.Type, right: Global.Type, top: Boolean): Formatted
Definition Classes
SplainFormatting
val formatDiffCache: FormatCache[(Global.Type, Global.Type, Boolean), Formatted]
Definition Classes
SplainFormatting
def formatDiffImpl(found: Global.Type, req: Global.Type, top: Boolean): Formatted
Definition Classes
SplainFormatting
def formatDiffInfix(left: Global.Type, right: Global.Type, top: Boolean): Formatted
Definition Classes
SplainFormatting
def formatDiffSimple(left: Global.Type, right: Global.Type): Formatted
Definition Classes
SplainFormatting
def formatDiffSpecial(left: Global.Type, right: Global.Type, top: Boolean): Option[Formatted]
Definition Classes
SplainFormatting
def formatFunction(args: List[String]): String
Definition Classes
SplainFormatting
def formatImplicitChain(chain: List[ImplicitError]): List[String]
Definition Classes
SplainFormatting
def formatImplicitChainFlat(chain: List[ImplicitError]): List[String]
Definition Classes
SplainFormatting
def formatImplicitChainTreeCompact(chain: List[ImplicitError]): Option[List[String]]
Definition Classes
SplainFormatting
def formatImplicitChainTreeFull(chain: List[ImplicitError]): List[String]
Definition Classes
SplainFormatting
def formatImplicitError(param: Global.Symbol, errors: List[ImplicitError], annotationMsg: String): String
Definition Classes
SplainFormatting
def formatIndentTree(chain: List[ImplicitError], baseIndent: Int): List[String]
Definition Classes
SplainFormatting
def formatInfix[A](path: List[String], simple: String, left: A, right: A, top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
Definition Classes
SplainFormatting
def formatNestedImplicit(err: ImplicitError): (String, List[String], Int)
Definition Classes
SplainFormatting
def formatNestedImplicits(errors: List[ImplicitError]): collection.immutable.List[String]
Remove duplicates and special cases that should not be shown.
Remove duplicates and special cases that should not be shown. In some cases, candidates are reported twice, once as Foo.f and once as f. ImplicitError.equals checks the simple names for identity, which is suboptimal, but works for 99% of cases. Special cases are handled in hideImpError
Definition Classes
SplainFormatting
def formatNonConfBounds(err: NonconformantBounds): List[String]
Definition Classes
SplainFormatting
def formatNormalSimple(tpe: Global.Type): (List[String], String)
Definition Classes
SplainFormatting
def formatRefinement(sym: Global.Symbol): String
Definition Classes
SplainFormatting
def formatSimpleType(tpe: Global.Type): (List[String], String)
Definition Classes
SplainFormatting
def formatSpecial[A](tpe: Global.Type, simple: String, args: List[A], formattedArgs: => List[Formatted], top: Boolean)(rec: (A, Boolean) => Formatted): Option[Formatted]
Definition Classes
SplainFormatting
def formatType(tpe: Global.Type, top: Boolean): Formatted
Definition Classes
SplainFormatting → SplainFormatters
val formatTypeCache: FormatCache[(Global.Type, Boolean), Formatted]
Definition Classes
SplainFormatting
def formatTypeImpl(tpe: Global.Type, top: Boolean): Formatted
Definition Classes
SplainFormatting
def formatWithInfix[A](tpe: Global.Type, args: List[A], top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
Definition Classes
SplainFormatting
def formattedDiff(left: Formatted, right: Formatted): String
Definition Classes
SplainFormatting
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[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def globalSettings: Settings
Definition Classes
Macros → Traces
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
Definition Classes
AnyRef → Any
Annotations
@native()
def hideImpError(error: ImplicitError): Boolean
Definition Classes
SplainFormatting
def implicitMessage(param: Global.Symbol, annotationMsg: String): List[String]
Definition Classes
SplainFormatting
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 indent(lines: List[String], n: Int = 1, prefix: String = " "): collection.immutable.List[String]
Definition Classes
SplainFormatting
def indentLine(line: String, n: Int = 1, prefix: String = " "): String
Definition Classes
SplainFormatting
def indentTree(tree: List[(String, List[String], Int)], baseIndent: Int): List[String]
Definition Classes
SplainFormatting
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 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
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
def informFn(msg: Any): Unit
def instantiateSamFromFunction(funTp: Global.Type, samTp: Global.Type, sam: Global.Symbol): Global.Type
Definition Classes
Infer
def isAux(tpe: Global.Type): Boolean
Definition Classes
SplainFormatting
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
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 isRefined(tpe: Global.Type): Boolean
Definition Classes
SplainFormatting
def isSymbolic(tpe: Global.Type): Boolean
Definition Classes
SplainFormatting
def isWeak(sym: Global.Symbol): Boolean
Definition Classes
MacroAnnotationAttachments
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. The expanded parameter is of type Any, 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, ala companionSymbolOf.
A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.
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 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
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
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 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 newTyper(context: Context): Typer
Definition Classes
TreeCheckers → Typers
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 onTreeCheckerError(pos: Global.Position, msg: String): Unit
Attributes
protected
Definition Classes
TreeCheckers → Contexts
def openMacros: collection.immutable.List[reflect.macros.contexts.Context { val universe: TreeCheckers.this.global.type }]
Definition Classes
Macros
def pathPrefix: (List[String]) => String
Definition Classes
SplainFormatting
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 pluginsNoImplicitFoundError(param: Global.Symbol, errors: List[ImplicitError], initial: String): String
Definition Classes
AnalyzerPlugins
See also
AnalyzerPlugin.noImplicitFoundError
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
def posstr(p: Global.Position): String
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 qualifiedName(path: List[String], name: FormattedName): String
Definition Classes
SplainFormatting
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 reorderArgs[T](args: List[T], pos: (Int) => Int)(implicit arg0: ClassTag[T]): List[T]
pos
maps indices from old to new
Definition Classes
NamesDefaults
def resetContexts(): Unit
Definition Classes
Contexts
def resetDocComments(): Unit
Definition Classes
Typers
def resetImplicits(): Unit
Definition Classes
Implicits
def resetTyper(): Unit
Definition Classes
Typers
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, 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
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
val rootImportsCached: HashMap[Global.CompilationUnit, List[Global.Symbol]]
Definition Classes
Contexts
def runWithUnit[T](unit: Global.CompilationUnit)(body: => Unit): Unit
def sanitizePath(path: List[String]): List[String]
Definition Classes
SplainFormatting
def setAddendum(pos: Global.Position, msg: () => String): Unit
Definition Classes
TypeDiagnostics
final val shortenImports: Boolean(false)
Definition Classes
Typers
def showFormatted(tpe: Formatted): String
Definition Classes
SplainFormatting
def showFormattedL(tpe: Formatted, break: Boolean): TypeRepr
Definition Classes
SplainFormatting
val showFormattedLCache: FormatCache[(Formatted, Boolean), TypeRepr]
Definition Classes
SplainFormatting
def showFormattedLImpl(tpe: Formatted, break: Boolean): TypeRepr
Definition Classes
SplainFormatting
def showFormattedQualified(path: List[String], name: FormattedName): TypeRepr
Definition Classes
SplainFormatting
def showFuncParams(args: List[String]): String
Definition Classes
SplainFormatting
def showRefined(parents: List[String], decls: List[String]): String
Definition Classes
SplainFormatting
def showTuple(args: List[String]): String
Definition Classes
SplainFormatting
def showType(tpe: Global.Type): String
Definition Classes
SplainFormatting
def showTypeApply(cons: String, args: 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
def showTypeBreakL(tpe: Global.Type): List[String]
Definition Classes
SplainFormatting
def skipImplicit(tp: Global.Type): Global.Type
Definition Classes
Infer
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
val specialFormatters: List[SpecialFormatter]
Definition Classes
SplainFormatting
def splainFoundReqMsg(found: Global.Type, req: Global.Type): String
Definition Classes
SplainDiagnostics
def splainPushImplicitSearchFailure(implicitTree: Global.Tree, expectedType: Global.Type, originalError: AbsTypeError): Unit
Definition Classes
SplainErrors
def splainPushNonconformantBonds(tpe: Global.Type, candidate: Global.Tree, targs: List[Global.Type], tparams: List[Global.Symbol], originalError: Option[AbsTypeError]): Unit
Definition Classes
SplainErrors
def splainPushNotFound(tree: Global.Tree, param: Global.Symbol): Unit
Definition Classes
SplainErrors
def splainPushOrReportNotFound(tree: Global.Tree, param: Global.Symbol, annotationMsg: String): String
Definition Classes
SplainErrors
def splitChains(errors: List[ImplicitError]): List[List[ImplicitError]]
Definition Classes
SplainFormatting
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 stripModules(path: List[String], name: FormattedName): String
Definition Classes
SplainFormatting
def stripType(tpe: Global.Type): (List[String], String)
Definition Classes
SplainFormatting
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
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
def symbolPath(sym: Global.Symbol): List[String]
Definition Classes
SplainFormatting
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
lazy val tpeOfTree: HashMap[Global.Tree, Global.Type]
def tpe_s(tp: Global.Type, colorize: (String) => String): String
Definition Classes
TypersTracking
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
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 truncateDecls(decls: List[Formatted]): Boolean
Definition Classes
SplainFormatting
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 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
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
final def validateUnapplyMember(tp: Global.Type): Unapplies.UnapplyMemberResult.Value
Definition Classes
Unapplies
Annotations
@tailrec()
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
def wrapParens(expr: String, top: Boolean): String
Definition Classes
SplainFormatting
def wrapParensRepr(tpe: TypeRepr, top: Boolean): TypeRepr
Definition Classes
SplainFormatting
object SymbolTracker extends Global.Traverser
This is a work in progress, don't take it too seriously.
object UnusedPrivates
Definition Classes
TypeDiagnostics
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
object UnapplyMemberResult extends Enumeration
Definition Classes
Unapplies
object ImplicitError extends java.io.Serializable
Definition Classes
SplainData
object ImplicitErrorSpecifics
Definition Classes
SplainData
object ImplicitErrors
Definition Classes
SplainData
object ByNameFormatter extends Analyzer.SpecialFormatter
Definition Classes
SplainFormatters
object FunctionFormatter extends Analyzer.SpecialFormatter
Definition Classes
SplainFormatters
object Refined
Definition Classes
SplainFormatters
object RefinedFormatter extends Analyzer.SpecialFormatter
Definition Classes
SplainFormatters
object TupleFormatter extends Analyzer.SpecialFormatter
Definition Classes
SplainFormatters

Deprecated Value Members

def formatted(fmtstr: String): String
Implicit
This member is added by an implicit conversion from TreeCheckers toStringFormat[TreeCheckers] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@deprecated @inline()
Deprecated
(Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.
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): (TreeCheckers, B)
Implicit
This member is added by an implicit conversion from TreeCheckers toArrowAssoc[TreeCheckers] 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.

Inherited from Analyzer

Inherited from AnalyzerPlugins

Inherited from MacroAnnotationAttachments

Inherited from StdAttachments

Inherited from ContextErrors

Inherited from SplainErrors

Inherited from TypeDiagnostics

Packages

TreeCheckers

abstract class TreeCheckers extends Analyzer

Instance Constructors

Type Members

Expandable trees

Macro expansion

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from Analyzer

Inherited from AnalyzerPlugins

Inherited from MacroAnnotationAttachments

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 AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromTreeCheckers to any2stringadd[TreeCheckers]

Inherited by implicit conversion StringFormat fromTreeCheckers to StringFormat[TreeCheckers]

Inherited by implicit conversion Ensuring fromTreeCheckers to Ensuring[TreeCheckers]

Inherited by implicit conversion ArrowAssoc fromTreeCheckers to ArrowAssoc[TreeCheckers]

Ungrouped

TreeCheckers