A class that records an available implicit
A class that sets up an implicit search.
The context-dependent inferencer part
Interface with user-defined match monad?
if there's a match in scope, we use this as the match strategy, assuming it conforms to MatchStrategy as defined below:
There are two key methods in here.
A class representing a lazy type with known type parameters.
The result of an implicit search
ALTmode is set when we are under a pattern alternative.
ALTmode is set when we are under a pattern alternative.
BYVALmode is set when we are typing an expression that occurs in a by-value position.
BYVALmode is set when we are typing an expression that occurs in a by-value position. An expression e1 is in by-value position within expression e2 iff it will be reduced to a value at that position during the evaluation of e2. Examples are by-value function arguments or the conditional of an if-then-else clause. This mode has been added to support continuations.
FUNmode is orthogonal to above.
FUNmode is orthogonal to above. When set we are looking for a method or constructor.
An extractor for unary function types arg => res
HKmode is set when we are typing a higher-kinded type.
HKmode is set when we are typing a higher-kinded type. adapt should then check kind-arity based on the prototypical type's kind arity. Type arguments should not be inferred.
An extractor for types of the form ? { name: ? }
An extractor for types of the form ? { name: (? >: argtpe <: Any*)restp }
LHSmode is set for the left-hand side of an assignment.
LHSmode is set for the left-hand side of an assignment.
NOmode, EXPRmode and PATTERNmode are mutually exclusive.
NOmode, EXPRmode and PATTERNmode are mutually exclusive.
A sentinel indicating no implicit was found
A sentinel indicating no implicit was found
POLYmode is orthogonal to above.
POLYmode is orthogonal to above. When set expression types can be polymorphic.
QUALmode is orthogonal to above.
QUALmode is orthogonal to above. When set expressions may be packages and Java statics modules.
SCCmode is orthogonal to above.
SCCmode is orthogonal to above. When set we are in the this or super constructor call of a constructor.
SNDTRYmode indicates that an application is typed for the 2nd time.
SNDTRYmode indicates that an application is typed for the 2nd time. In that case functions may no longer be coerced with implicit views.
STARmode is set when star patterns are allowed.
STARmode is set when star patterns are allowed. (This was formerly called REGPATmode.)
SUPERCONSTRmode is set for the super in a superclass constructor call super.
SUPERCONSTRmode is set for the super in a superclass constructor call super.<init>.
This is a work in progress, don't take it too seriously.
TAPPmode is set for the function/type constructor part of a type application.
TAPPmode is set for the function/type constructor part of a type application. When set we do not decompose PolyTypes.
TYPEPATmode is set when we are typing a type in a pattern.
TYPEPATmode is set when we are typing a type in a pattern.
TYPEmode needs a comment.
TYPEmode needs a comment. <-- XXX.
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
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())
Add the synthetic methods to case classes.
Add the synthetic methods to case classes.
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).
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
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?
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.
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
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
The formal parameter types corresponding to formals.
The formal parameter types corresponding to formals.
If formals has a repeated last parameter, a list of
(nargs - params.length + 1) copies of its type is returned.
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.
...
...
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)
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.
returns true if every element is equal to its index
returns true if every element is equal to its index
Should become private again once we're done with migrating typetag generation from implicits
Should become private again once we're done with migrating typetag generation from implicits
Performs macro expansion:
1) Checks whether the expansion needs to be delayed (see mustDelayMacroExpansion)
2) Loads macro implementation using macroMirror
3) Synthesizes invocation arguments for the macro implementation
4) Checks that the result is a tree bound to this universe
5) Typechecks the result against the return type of the macro definition
Performs macro expansion:
1) Checks whether the expansion needs to be delayed (see mustDelayMacroExpansion)
2) Loads macro implementation using macroMirror
3) Synthesizes invocation arguments for the macro implementation
4) Checks that the result is a tree bound to this universe
5) Typechecks the result against the return type of the macro definition
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.
@return the expansion result if the expansion has been successful, the fallback method invocation 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
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.
A constructor for types ?{ name: tp }, used in infer view to member searches.
A constructor for types ?{ name: tp }, used in infer view to member searches.
The common situation of making sure nothing is erroneous could be nicer if Symbols, Types, and Trees all implemented some common interface in which isErroneous and similar would be placed.
The common situation of making sure nothing is erroneous could be nicer if Symbols, Types, and Trees all implemented some common interface in which isErroneous and similar would be placed.
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.
Keeps track of macros in-flight.
Keeps track of macros in-flight.
See more informations in comments to openMacros in scala.reflect.makro.Context.
Does the positioned line assigned to t1 precede that of t2?
Does the positioned line assigned to t1 precede that of t2?
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
maps indices from new to old (!)
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.
Transform a function application into a Block, and assigns typer.
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
As specified above, body of a macro definition must reference its implementation.
As specified above, body of a macro definition must reference its implementation. This function verifies that the body indeed refers to a method, and that the referenced macro implementation is compatible with the given macro definition.
This means that macro implementation (fooBar in example above) must: 1) Refer to a statically accessible, non-overloaded method. 2) Have the right parameter lists as outlined in the SIP / in the doc comment of this class.
typechecked rhs of the given macro definition
returns unapply or unapplySeq if available
returns unapply or unapplySeq if available
returns unapply member's parameter type.
returns unapply member's parameter type.
returns type of the unapply method returning T_0.
returns type of the unapply method returning T_0...T_n for n == 0, boolean for n == 1, Some[T0] else Some[Product[Ti]]
returns type list for return type of the extraction
returns type list for return type of the extraction
(the inverse of unapplyReturnTypeSeq) for type Boolean, returns Nil for type Option[T] or Some[T]:
(the inverse of unapplyReturnTypeSeq) for type Boolean, returns Nil for type Option[T] or Some[T]:
let type be the result type of the (possibly polymorphic) unapply method for type Option[T] or Some[T] -returns T0.
let type be the result type of the (possibly polymorphic) unapply method for type Option[T] or Some[T] -returns T0...Tn-1,Tn* if n>0 and T <: Product[T0...Tn-1,Seq[Tn]]], -returns R* if T = Seq[R]
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.
Compute variance of type parameter tparam in all type arguments
tps which correspond to formal type parameters tparams1.
Compute variance of type parameter tparam in all type arguments
tps which correspond to formal type parameters tparams1.
Compute variance of type parameter tparam in type annotation annot.
Compute variance of type parameter tparam in type annotation annot.
Compute variance of type parameter tparam in all type annotations annots.
Compute variance of type parameter tparam in all type annotations annots.
Compute variance of type parameter tparam in type of symbol sym.
Compute variance of type parameter tparam in type of symbol sym.
Compute variance of type parameter tparam in types of all symbols sym.
Compute variance of type parameter tparam in types of all symbols sym.
Compute variance of type parameter tparam in type tp.
Compute variance of type parameter tparam in type tp.
Compute variance of type parameter tparam in all types tps.
Compute variance of type parameter tparam in all types tps.
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.
(Since version 2.10.0) Use companionSymbolOf instead
(Since version 2.10.0) Use companionSymbolOf instead
(Since version 2.10.0) Use underlyingSymbol instead
Tree checker