scala.tools.nsc.typechecker.Implicits
ImplicitSearch
Related Doc:
package Implicits
The tree for which the implicit needs to be inserted.
The original expected type of the implicit.
We are looking for a view
The context used for the implicit search
Position that is preferable for use in 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
Prune ImplicitInfos down to either all the eligible ones or the best one.
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.
Perform the following adaptations of expression, pattern or type tree wrt to
given mode mode and given prototype pt:
(-1) For expressions with annotated types, let AnnotationCheckers decide what to do
(0) Convert expressions with constant types to literals (unless in interactive/scaladoc mode)
(1) Resolve overloading, unless mode contains FUNmode
(2) Apply parameterless functions
(3) Apply polymorphic types to fresh instances of their type parameters and
store these instances in context.undetparams,
unless followed by explicit type application.
Perform the following adaptations of expression, pattern or type tree wrt to
given mode mode and given prototype pt:
(-1) For expressions with annotated types, let AnnotationCheckers decide what to do
(0) Convert expressions with constant types to literals (unless in interactive/scaladoc mode)
(1) Resolve overloading, unless mode contains FUNmode
(2) Apply parameterless functions
(3) Apply polymorphic types to fresh instances of their type parameters and
store these instances in context.undetparams,
unless followed by explicit type application.
(4) Do the following to unapplied methods used as values:
(4.1) If the method has only implicit parameters pass implicit arguments
(4.2) otherwise, if pt is a function type and method is not a constructor,
convert to function by eta-expansion,
(4.3) otherwise, if the method is nullary with a result type compatible to pt
and it is not a constructor, apply it to ()
otherwise issue an error
(5) Convert constructors in a pattern as follows:
(5.1) If constructor refers to a case class factory, set tree's type to the unique
instance of its primary constructor that is a subtype of the expected type.
(5.2) If constructor refers to an extractor, convert to application of
unapply or unapplySeq method.
(6) Convert all other types to TypeTree nodes. (7) When in TYPEmode but not FUNmode or HKmode, check that types are fully parameterized (7.1) In HKmode, higher-kinded types are allowed, but they must have the expected kind-arity (8) When in both EXPRmode and FUNmode, add apply method calls to values of object type. (9) If there are undetermined type variables and not POLYmode, infer expression instance Then, if tree's type is not a subtype of expected type, try the following adaptations: (10) If the expected type is Byte, Short or Char, and the expression is an integer fitting in the range of that type, convert it to that type. (11) Widen numeric literals to their expected type, if necessary (12) When in mode EXPRmode, convert E to { E; () } if expected type is scala.Unit. (13) When in mode EXPRmode, apply AnnotationChecker conversion if expected type is annotated. (14) When in mode EXPRmode, apply a view If all this fails, error
Try to apply an implicit conversion to qual to that it contains
a method name which can be applied to arguments args with expected type pt.
Try to apply an implicit conversion to qual to that it contains
a method name which can be applied to arguments args with expected type pt.
If pt is defined, there is a fallback to try again with pt = ?.
This helps avoiding propagating result information too far and solves
#1756.
If no conversion is found, return qual unchanged.
Try to apply an implicit conversion to qual so that it contains
a method name.
Try to apply an implicit conversion to qual so that it contains
a method name. If that's ambiguous try taking arguments into
account using adaptToArguments.
Try to apply an implicit conversion to qual to that it contains a
member name of arbitrary type.
Try to apply an implicit conversion to qual to that it contains a
member name of arbitrary type.
If no conversion is found, return qual unchanged.
Computes from a list of lists of implicit infos a map which takes
infos which are applicable for given expected type pt to their attributed trees.
Computes from a list of lists of implicit infos a map which takes
infos which are applicable for given expected type pt to their attributed trees.
The given list of lists of implicit infos
Is implicit definition visible without prefix? If this is the case then symbols in preceding lists shadow symbols of the same name in succeeding lists.
map from infos to search results
Find implicit arguments and pass them to given tree.
Find implicit arguments and pass them to given tree.
The expected type with all undetermined type parameters replaced with wildcards.
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.
The result of the implicit search: First search implicits visible in current context.
The result of the implicit search:
First search implicits visible in current context.
If that fails, search implicits in expected type pt.
todo. the following lines should be deleted after we migrate delegate tag materialization to implicit macros
If that fails, and pt is an instance of a ClassTag, try to construct a class tag.
If that fails, and pt is an instance of a TypeTag, try to construct a type tag.
If that fails, and pt is an instance of a ClassManifest, try to construct a class manifest.
If that fails, and pt is an instance of a Manifest, try to construct a manifest.
If that fails, and pt is an instance of a OptManifest, try to construct a class manifest and return NoManifest if construction fails.
If all fails return SearchFailure
Overridden to false in scaladoc and/or interactive.
Overridden to false in scaladoc and/or interactive.
Check that tpt refers to a non-refinement class type
Check that tpt refers to a non-refinement class type
Check whether feature given by featureTrait is enabled.
Check whether feature given by featureTrait is enabled.
If it is not, issue an error or a warning depending on whether the feature is required.
A string expression that is substituted for "#" in the feature description string
When set, feature check is run immediately, otherwise it is run at the end of the typechecking run for the enclosing unit. This is done to avoid potential cyclic reference errors by implicits that are forced too early.
if feature check is run immediately: true if feature is enabled, false otherwise if feature check is delayed or suppressed because we are past typer: true
Check if a structurally defined method violates implementation restrictions.
Check if a structurally defined method violates implementation restrictions. A method cannot be called if it is a non-private member of a refinement type and if its parameter's types are any of:
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.
Check that type tp is not a subtype of itself.
Check that type tp is not a subtype of itself.
Check that tpt refers to a class type with a stable prefix.
Check that tpt refers to a class type with a stable prefix.
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
Enter all aliases of local parameter accessors.
Enter all aliases of local parameter accessors.
The typer for an expression, depending on where we are.
The typer for an expression, depending on where we are. If we are before a superclass call, this is a typer over a constructor context; otherwise it is the current typer.
Returns Some(msg) if the given tree is untyped apparently due to a cyclic reference, and None otherwise.
Returns Some(msg) if the given tree is untyped apparently due to a cyclic reference, and None otherwise.
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.
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
In order to override this in the TreeCheckers Typer so synthetics aren't re-added all the time, it is exposed here the module/class typing methods go through it.
In order to override this in the TreeCheckers Typer so synthetics aren't re-added all the time, it is exposed here the module/class typing methods go through it. ...but it turns out it's also the ideal spot for namer/typer coordination for the tricky method synthesis scenarios, so we'll make it that.
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
The hashCode method for reference types.
Is implicit info info1 better than implicit info info2?
Infer an implicit conversion (view) between two types.
Infer an implicit conversion (view) between two types.
The tree which needs to be converted.
The source type of the conversion
The target type of the conversion
Should ambiguous implicit errors be reported? False iff we search for a view to find out whether one type is coercible to another.
Should ambiguous and divergent implicit errors that were buffered during the inference of a view be put into the original buffer. False iff we don't care about them.
If the expected type is Unit: try instantiating type arguments with expected type Unit, but if that fails, try again with pt = WildcardType and discard the expression.
If the expected type is Unit: try instantiating type arguments with expected type Unit, but if that fails, try again with pt = WildcardType and discard the expression.
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.
Is tree a block created by a named application?
Is tree a block created by a named application?
A symbol is stale if it is toplevel, to be loaded from a classfile, and the classfile is produced from a sourcefile which is compiled in the current run.
A symbol is stale if it is toplevel, to be loaded from a classfile, and the classfile is produced from a sourcefile which is compiled in the current run.
Should implicit definition symbol sym be considered for applicability testing?
This is the case if one of the following holds:
Should implicit definition symbol sym be considered for applicability testing?
This is the case if one of the following holds:
The typer for a label definition.
The typer for a label definition. If this is part of a template we first have to enter the label definition.
This file will be the death of me.
This file will be the death of me.
The member with given name of given qualifier tree
The member with given name of given qualifier tree
Equivalent to !(this eq that).
Equivalent to !(this eq that).
true if the argument is not a reference to the receiver object; false otherwise.
Does function need to be instantiated, because a missing parameter in an argument closure overlaps with an uninstantiated formal?
Does function need to be instantiated, because a missing parameter in an argument closure overlaps with an uninstantiated formal?
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
Compute an existential type from raw hidden symbols syms and type tp
Compute an existential type from raw hidden symbols syms and type tp
convert local symbols and skolems to existentials
convert local symbols and skolems to existentials
The qualifying class
of a this or super with prefix qual.
The qualifying class
of a this or super with prefix qual.
packageOk is equal false when qualifying class symbol
Is symbol defined and not stale?
Is symbol defined and not stale?
Report a type error.
Report a type error.
The position where to report the error
The exception that caused the error
Finds in scope or materializes a ClassTag.
Finds in scope or materializes a ClassTag. Should be used instead of ClassManifest every time compiler needs to persist an erasure.
Once upon a time, we had an ErasureTag which was to ClassTag the same that WeakTypeTag is for TypeTag.
However we found out that we don't really need this concept, so it got removed.
Position for error reporting. Please, provide meaningful value.
Type we're looking a ClassTag for, e.g. resolveClassTag(pos, IntTpe) will look for ClassTag[Int].
If true (default) then the resolver is allowed to launch materialization macros when there's no class tag in scope. If false then materialization macros are prohibited from running.
Tree that represents an scala.reflect.ClassTag for tp if everything is okay.
EmptyTree if the result contains unresolved (i.e. not spliced) type parameters and abstract type members.
EmptyTree if allowMaterialization is false, and there is no class tag in scope.
Finds in scope or materializes an WeakTypeTag (if concrete is false) or a TypeTag (if concrete is true).
Finds in scope or materializes an WeakTypeTag (if concrete is false) or a TypeTag (if concrete is true).
Position for error reporting. Please, provide meaningful value.
Prefix that represents a universe this type tag will be bound to.
If pre is set to NoType, then any type tag in scope will do, regardless of its affiliation.
If pre is set to NoType, and tag resolution involves materialization, then mkRuntimeUniverseRef will be used.
Type we're looking a TypeTag for, e.g. resolveTypeTag(pos, mkRuntimeUniverseRef, IntTpe, false) will look for scala.reflect.runtime.universe.TypeTag[Int].
If true then the result must not contain unresolved (i.e. not spliced) type parameters and abstract type members. If false then the function will always succeed (abstract types will be reified as free types).
If true (default) then the resolver is allowed to launch materialization macros when there's no type tag in scope. If false then materialization macros are prohibited from running.
Tree that represents a scala.reflect.TypeTag for tp if everything is okay.
EmptyTree if concrete is true and the result contains unresolved (i.e. not spliced) type parameters and abstract type members.
EmptyTree if allowMaterialization is false, and there is no array tag in scope.
For flatMapping a list of trees when you want the DocDefs and Annotated to be transparent.
For flatMapping a list of trees when you want the DocDefs and Annotated to be transparent.
Convert a SAM type to the corresponding FunctionType, extrapolating BoundedWildcardTypes in the process (no type precision is lost by the extrapolation, but this facilitates dealing with the types arising from Java's use-site variance).
Convert a SAM type to the corresponding FunctionType, extrapolating BoundedWildcardTypes in the process (no type precision is lost by the extrapolation, but this facilitates dealing with the types arising from Java's use-site variance).
Search list of implicit info lists for one matching prototype pt.
Search list of implicit info lists for one matching prototype pt.
If found return a search result with a tree from found implicit info
which is typed with expected type pt. Otherwise return SearchFailure.
The given list of lists of implicit infos
Is implicit definition visible without prefix? If this is the case then symbols in preceding lists shadow symbols of the same name in succeeding lists.
Post-process an identifier or selection node, performing the following:
Post-process an identifier or selection node, performing the following:
synthesize and type check a PartialFunction implementation based on the match in tree
synthesize and type check a PartialFunction implementation based on the match in tree
param => sel match { cases } becomes:
new AbstractPartialFunction[$argTp, $matchResTp] { def applyOrElse[A1 <: $argTp, B1 >: $matchResTp]($param: A1, default: A1 => B1): B1 = $selector match { $cases } def isDefinedAt(x: $argTp): Boolean = $selector match { $casesTrue } }
TODO: it would be nicer to generate the tree specified above at once and type it as a whole, there are two gotchas:
this in cases or sel must resolve to the this of the class originally enclosing the match,
not of the anonymous partial function subclassan alternative TODO: add partial function AST node or equivalent and get rid of this synthesis --> do everything in uncurry (or later) however, note that pattern matching codegen is designed to run *before* uncurry
Synthesize and type check the implementation of a type with a Single Abstract Method
Synthesize and type check the implementation of a type with a Single Abstract Method
{ (p1: T1, ..., pN: TN) => body } : S
expands to (where S is the expected type that defines a single abstract method named apply)
{
def apply$body(p1: T1, ..., pN: TN): T = body
new S {
def apply(p1: T1', ..., pN: TN'): T' = apply$body(p1,..., pN)
}
}
If 'T' is not fully defined, it is inferred by type checking
apply$body without a result type before type checking the block.
The method's inferred result type is used instead of T. [See test/files/pos/sammy_poly.scala]
The apply method is identified by the argument sam; S corresponds to the argument samClassTp,
and resPt is derived from samClassTp -- it may be fully defined, or not...
If it is not fully defined, we derive samClassTpFullyDefined by inferring any unknown type parameters.
The types T1' ... TN' and T' are derived from the method signature of the sam method,
as seen from the fully defined samClassTpFullyDefined.
The function's body is put in a method outside of the class definition to enforce scoping.
S's members should not be in scope in body.
The restriction on implicit arguments (neither S's constructor, nor sam may take an implicit argument list),
is largely to keep the implementation of type inference (the computation of samClassTpFullyDefined) simple.
NOTE: it would be nicer to not have to type check apply$body separately when T is not fully defined.
However T must be fully defined before we type the instantiation, as it'll end up as a parent type,
which must be fully defined. Would be nice to have some kind of mechanism to insert type vars in a block of code,
and have the instantiation of the first occurrence propagate to the rest of the block.
TODO: by-name params scala> trait LazySink { def accept(a: => Any): Unit } defined trait LazySink
scala> val f: LazySink = (a) => (a, a) f: LazySink = $anonfun$1@1fb26910
scala> f(println("!")) <console>:10: error: LazySink does not take parameters f(println("!")) ^
scala> f.accept(println("!")) ! !
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.
Types expression tree with given prototype pt.
Types expression tree with given prototype pt.
Types expression or definition tree.
Types expression or definition tree.
Convert an annotation constructor call into an AnnotationInfo.
Convert an annotation constructor call into an AnnotationInfo.
Types a higher-kinded type tree -- pt denotes the expected kind and must be one of Kind.WildCard and Kind.FromParams
Types a higher-kinded type tree -- pt denotes the expected kind and must be one of Kind.WildCard and Kind.FromParams
Remove definition annotations from modifiers (they have been saved
into the symbol's annotations in the type completer / namer)
Remove definition annotations from modifiers (they have been saved
into the symbol's annotations in the type completer / namer)
However reification does need annotation definitions to proceed. Unfortunately, AnnotationInfo doesn't provide enough info to reify it in general case. The biggest problem is with the "atp: Type" field, which cannot be reified in some situations that involve locally defined annotations. See more about that in Reifiers.scala.
That's why the original tree gets saved into original field of AnnotationInfo (happens elsewhere).
The field doesn't get pickled/unpickled and exists only during a single compilation run.
This simultaneously allows us to reify annotations and to preserve backward compatibility.
Types function part of an application
Types function part of an application
Types a pattern with prototype pt
Types a pattern with prototype pt
Types qualifier tree of a select node.
Types qualifier tree of a select node.
E.g. is tree occurs in a context like tree.m.
Types qualifier tree of a select node.
Types qualifier tree of a select node.
E.g. is tree occurs in a context like tree.m.
Check that inner classes do not inherit from Annotation
Check that inner classes do not inherit from Annotation
Types a (fully parameterized) type tree
Types a (fully parameterized) type tree
Types a (fully parameterized) type tree
Types a (fully parameterized) type tree
Types a type constructor tree used in a new or supertype
Types a type constructor tree used in a new or supertype
The type parameters to instantiate
Check that
Check that
- sealed classes are only inherited by classes which are nested within definition of base class, or that occur within same statement sequence,
A class that sets up an implicit search. For more info, see comments for
inferImplicit.