treeChecker
Related Doc:
package Global
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:
outer.contextMode.And behaviour:
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.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 ReportBuffer records
everything that is issued. It is important to note, that child Contexts created with make
"inherit" the very same ReportBuffer instance, whereas children spawned through makeSilent
receive a separate, fresh buffer.
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
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).
A class that records an available implicit
A class that records an available implicit
A class that sets up an implicit search.
A class that sets up an implicit search. For more info, see comments for inferImplicit.
A Context focussed on an Import tree
A Context focussed on an Import tree
The context-dependent inferencer part
The context-dependent inferencer part
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.
Performs macro expansion:
Performs macro expansion:
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>)
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.
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
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.
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.
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.
Abstracts away resolution of macro runtimes.
Abstracts away resolution of macro runtimes.
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.
Marks a TypeError that was constructed from a CyclicReference (under silent).
Marks a TypeError that was constructed from a CyclicReference (under silent). This is used for named arguments, where we need to know if an assignment expression failed with a cyclic reference or some other type error.
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.
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.
The result of an implicit search
The result of an implicit search
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.
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.
Test two objects for inequality.
Test two objects for inequality.
true if !(this == that), false otherwise.
Equivalent to x.hashCode except for boxed numeric types and null.
Equivalent to x.hashCode except for boxed numeric types and null.
For numerics, it returns a hash value which is consistent
with value equality: if two value type instances compare
as true, then ## will produce the same hash value for each
of them.
For null returns a hashcode where null.hashCode throws a
NullPointerException.
a hash value consistent with ==
The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).
The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).
true if the receiver object is equivalent to the argument; false otherwise.
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 SI-8006.
This attachment solves the problem by providing a means of communication between the two Dynamic desugarers, which solves the aforementioned issue.
An extractor for unary function types arg => res
An extractor for unary function types arg => res
An extractor for types of the form ? { name: ? }
An extractor for types of the form ? { name: ? }
An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }
An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }
markMacroImplRef
A sentinel indicating no implicit was found
A sentinel indicating no implicit was found
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).
This is a work in progress, don't take it too seriously.
This is a work in progress, don't take it too seriously.
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.
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
AnalyzerPlugin.adaptAnnotations
Registers a new analyzer plugin
Registers a new analyzer plugin
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())
Registers a new macro plugin
Registers a new macro plugin
Add the synthetic methods to case classes.
Add the synthetic methods to case classes.
returns true if every element is equal to its index
returns true if every element is equal to its index
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).
from-type for the implicit conversion
search implicits here
symbols that should be considered free type variables (implicit search should not try to solve them, just track their constraints)
Cast the receiver object to be of type T0.
Cast the receiver object to be of type T0.
Note that the success of a cast at runtime is modulo Scala's erasure semantics.
Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at
runtime, while the expression List(1).asInstanceOf[List[String]] will not.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the requested type.
the receiver object.
ClassCastException if the receiver object is not an instance of the erasure of type T0.
AnalyzerPlugin.canAdaptAnnotations
Does not force the info of caseclazz
Does not force the info of caseclazz
Generates copy methods for case classes.
Generates copy methods for case classes. Copy only has defaults on the first parameter list, as of SI-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.
The apply method corresponding to a case class
The apply method corresponding to a case class
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
The unapply method corresponding to a case class
The unapply method corresponding to a case class
Create a copy of the receiver object.
Create a copy of the receiver object.
The default implementation of the clone method is platform dependent.
a copy of the receiver object.
not specified by SLS as a member of AnyRef
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?
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
Metalevels.scala for more information and examples about metalevels
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.
Macro classloader that is used to resolve and run macro implementations.
Macro classloader that is used to resolve and run macro implementations. Loads classes from from -cp (aka the library classpath). Is also capable of detecting REPL and reusing its classloader.
When -Xmacro-jit is enabled, we sometimes fallback to on-the-fly compilation of macro implementations, which compiles implementations into a virtual directory (very much like REPL does) and then conjures a classloader mapped to that virtual directory.
The annotations amongst those found on the original symbol which should be propagated to this kind of accessor.
The annotations amongst those found on the original symbol which should be propagated to this kind of accessor.
Returns unapply or unapplySeq if available, without further checks.
Returns unapply or unapplySeq if available, without further checks.
Tests whether the argument (that) is a reference to the receiver object (this).
Tests whether the argument (that) is a reference to the receiver object (this).
The eq method implements an equivalence relation on
non-null instances of AnyRef, and has three additional properties:
x and y of type AnyRef, multiple invocations of
x.eq(y) consistently returns true or consistently returns false.x of type AnyRef, x.eq(null) and null.eq(x) returns false.null.eq(null) returns true. When overriding the equals or hashCode methods, it is important to ensure that their behavior is
consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they
should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).
true if the argument is a reference to the receiver object; false otherwise.
The equality method for reference types.
Expand partial function applications of type type.
Expand partial function applications of type type.
p.f(es_1)...(es_n)
==> {
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))
}
tree is already attributed
[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)"
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.
The apply method corresponding to a case class
The apply method corresponding to a case class
Called by the garbage collector on the receiver object when there are no more references to the object.
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the finalize method is invoked, as
well as the interaction between finalize and non-local returns
and exceptions, are all platform dependent.
not specified by SLS as a member of AnyRef
Obtains a ClassLoader instance used for macro expansion.
Obtains a ClassLoader instance used for macro expansion.
By default a new ScalaClassLoader is created using the classpath
from global and the classloader of self as parent.
Mirrors with runtime definitions (e.g. Repl) need to adjust this method.
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.
allows keeping ByName parameters. Used in NamesDefaults.
allows keeping repeated parameter (if there's one argument). Used in NamesDefaults.
A fresh type variable with given type parameter as origin.
A fresh type variable with given type parameter as origin.
A representation that corresponds to the dynamic class of the receiver object.
A representation that corresponds to the dynamic class of the receiver object.
The nature of the representation is platform dependent.
a representation that corresponds to the dynamic class of the receiver object.
not specified by SLS as a member of AnyRef
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.
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)
Determines whether the given tree has an associated SuperArgsAttachment.
Determines whether the given tree has an associated SuperArgsAttachment.
The hashCode method for reference types.
Increases metalevel of the type, i.e.
Increases metalevel of the type, i.e. transforms: * T to c.Expr[T]
Metalevels.scala for more information and examples about metalevels
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.
Search for an implicit value.
Search for an implicit value. See the comment on result at the end of class ImplicitSearch
for more info how the search is conducted.
The tree for which the implicit needs to be inserted. (the inference might instantiate some of the undetermined type parameters of that tree.
The expected type of the implicit.
Should ambiguous implicit errors be reported? False iff we search for a view to find out whether one type is coercible to another.
We are looking for a view
The current context
False if any divergent/ambiguous errors should be ignored after implicits search, true if they should be reported (used in further typechecking).
Position that is 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 NoPosition, then position-based services will use tree.pos
A search result
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.
Test whether the dynamic type of the receiver object is T0.
Test whether the dynamic type of the receiver object is T0.
Note that the result of the test is modulo Scala's erasure semantics.
Therefore the expression 1.isInstanceOf[String] will return false, while the
expression List(1).isInstanceOf[List[String]] will return true.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the specified type.
true if the receiver object is an instance of erasure of type T0; false otherwise.
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.
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.
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.
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.
A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.
A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.
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:
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).
DefMacroExpander
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.
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.
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.
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.
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.
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.
Requested runtime if macro implementation can be loaded successfully from either of the mirrors,
null otherwise.
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.
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.
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.
The list of arguments
The list of parameter symbols of the invoked method
A function that extracts the name of an argument expression, if it is a named argument.
Equivalent to !(this eq that).
Equivalent to !(this eq that).
true if the argument is not a reference to the receiver object; false otherwise.
Automatically perform the following conversions on expression types: A method type becomes the corresponding function type.
Automatically perform the following conversions on expression types: A method type becomes the corresponding function type. A nullary method type becomes its result type. Implicit parameters are skipped. This method seems to be performance critical.
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up a single thread that is waiting on the receiver object's monitor.
not specified by SLS as a member of AnyRef
Wakes up all threads that are waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
not specified by SLS as a member of AnyRef
MacroPlugin.pluginsEnsureCompanionObject
MacroPlugin.pluginsEnterStats
MacroPlugin.pluginsEnterSym
MacroPlugin.pluginsIsBlackbox
MacroPlugin.pluginsMacroArgs
MacroPlugin.pluginsMacroExpand
MacroPlugin.pluginsMacroRuntime
AnalyzerPlugin.pluginsPt
AnalyzerPlugin.pluginsTypeSig
AnalyzerPlugin.pluginsTypeSigAccessor
AnalyzerPlugin.pluginsTyped
MacroPlugin.pluginsTypedMacroBody
AnalyzerPlugin.pluginsTypedReturn
Does the positioned line assigned to t1 precede that of t2?
Does the positioned line assigned to t1 precede that of t2?
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'.
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, positional args don't appear after named ones.
maps indices from old to new
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.
List of symbols to import from in a root context.
List of symbols to import from in a root context. Typically that
is java.lang, scala, and scala.Predef, in that order. Exceptions:
-Yno-imports is given, nothing is importedjava.lang is imported-Yno-predef is given, if the unit body has an import of Predef
among its leading imports, or if the tree is scala.Predef, Predef is not imported.
Solve constraint collected in types tvars.
Solve constraint collected in types tvars.
All type variables to be instantiated.
The type parameters corresponding to tvars
The variances of type parameters; need to reverse solution direction for all contravariant variables.
When true search for max solution else min.
Default implementation of isBlackbox.
Default implementation of isBlackbox.
Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsIsBlackbox for more details)
Default implementation of macroArgs.
Default implementation of macroArgs.
Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroArgs for more details)
Default implementation of macroExpand.
Default implementation of macroExpand.
Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsMacroExpand for more details)
Default implementation of typedMacroBody.
Default implementation of typedMacroBody.
Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsTypedMacroBody for more details)
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.
Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.
Suppresses macro expansion of the tree by putting SuppressMacroExpansionAttachment on it.
Creates a String representation of this object.
Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.
a String representation of the object.
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) }
the typer calling this method; this method calls typer.doTypedApply
the mode to use for calling typer.doTypedApply
the expected type for calling typer.doTypedApply
the transformed application (a Block) together with the NamedApplyInfo. if isNamedApplyBlock(tree), returns the existing context.namedApplyBlockInfo
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.
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.
Macro impl reference for the given macro definition if everything is okay. EmptyTree if an error occurs.
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.
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
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.
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.
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.
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.
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.
Tree checker