Applications

Type Members

class ApplicableToTrees extends (Applications.this)#TestApplication[ast.tpd.Tree]

Subclass of Application for applicability tests with type arguments and value argument trees.
class ApplicableToTreesDirectly extends (Applications.this)#ApplicableToTrees

Subclass of Application for applicability tests with type arguments and value argument trees.
class ApplicableToTypes extends (Applications.this)#TestApplication[Type]

Subclass of Application for applicability tests with value argument types.
abstract class Application[Arg] extends AnyRef

Arg
the type of arguments, could be tpd.Tree, untpd.Tree, or Type
class ApplyToTyped extends (Applications.this)#TypedApply[Type]

Subclass of Application for type checking an Apply node with typed arguments.
class ApplyToUntyped extends (Applications.this)#TypedApply[Untyped]

Subclass of Application for type checking an Apply node with untyped arguments.
abstract class TestApplication[Arg] extends (Applications.this)#Application[Arg]

Subclass of Application for the cases where we are interested only in a "can/cannot apply" answer, without needing to construct trees or issue error messages.
abstract class TypedApply[T >: Untyped] extends (Applications.this)#Application[Tree[T]]

Subclass of Application for type checking an Apply node, where types of arguments are either known or unknown.

Abstract Value Members

abstract def viewExists(tp: Type, pt: Type)(implicit ctx: Context): Boolean

Is there an implicit conversion from tp to pt?
Is there an implicit conversion from tp to pt?

Definition Classes
Compatibility

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def argCtx(app: ast.untpd.Tree)(implicit ctx: Context): Context

If app is a this(...) constructor call, the this-call argument context, otherwise the current context.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def constrainResult(mt: Type, pt: Type)(implicit ctx: Context): Boolean

Check that the result type of the current method fits the given expected result type.
Check that the result type of the current method fits the given expected result type.

Definition Classes
Compatibility
def convertNewGenericArray(tree: ast.tpd.Tree)(implicit ctx: Context): ast.tpd.Tree

Rewrite new Array[T](....) if T is an unbounded generic to calls to newGenericArray.
Rewrite new Array[T](....) if T is an unbounded generic to calls to newGenericArray. It is performed during typer as creation of generic arrays needs a classTag. we rely on implicit search to find one.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def handleUnexpectedFunType(tree: ast.untpd.Apply, fun: ast.tpd.Tree)(implicit ctx: Context): ast.tpd.Tree

Overridden in ReTyper to handle primitive operations that can be generated after erasure
Overridden in ReTyper to handle primitive operations that can be generated after erasure

Attributes
protected
def harmonize(trees: List[ast.tpd.Tree])(implicit ctx: Context): List[ast.tpd.Tree]

If trees all have numeric value types, and they do not have all the same type, pick a common numeric supertype and convert all trees to this type.
def harmonizeTypes(tpes: List[Type])(implicit ctx: Context): List[Type]

If all types are numeric value types, and they are not all the same type, pick a common numeric supertype and return it instead of every original type.
def hashCode(): Int

Definition Classes
AnyRef → Any
def isApplicable(tp: Type, args: List[Type], resultType: Type)(implicit ctx: Context): Boolean

Is given type applicable to argument types args, possibly after inserting an apply?
Is given type applicable to argument types args, possibly after inserting an apply?
resultType
The expected result type of the application
def isApplicable(tp: Type, targs: List[Type], args: List[ast.tpd.Tree], resultType: Type)(implicit ctx: Context): Boolean

Is given type applicable to type arguments targs and argument trees args, possibly after inserting an apply?
Is given type applicable to type arguments targs and argument trees args, possibly after inserting an apply?
resultType
The expected result type of the application
def isApplicable(methRef: TermRef, args: List[Type], resultType: Type)(implicit ctx: Context): Boolean

Is given method reference applicable to argument types args?
Is given method reference applicable to argument types args?
resultType
The expected result type of the application
def isApplicable(methRef: TermRef, targs: List[Type], args: List[ast.tpd.Tree], resultType: Type)(implicit ctx: Context): Boolean

Is given method reference applicable to type arguments targs and argument trees args?
Is given method reference applicable to type arguments targs and argument trees args?
resultType
The expected result type of the application
def isAsGood(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Boolean

In a set of overloaded applicable alternatives, is alt1 at least as good as alt2? alt1 and alt2 are non-overloaded references.
def isCompatible(tp: Type, pt: Type)(implicit ctx: Context): Boolean

A type tp is compatible with a type pt if one of the following holds:
A type tp is compatible with a type pt if one of the following holds:
1. tp is a subtype of pt 2. pt is by name parameter type, and tp is compatible with its underlying type 3. there is an implicit conversion from tp to pt. 4. tp is a numeric subtype of pt (this case applies even if implicit conversions are disabled)
Definition Classes
Compatibility
def isDirectlyApplicable(methRef: TermRef, targs: List[Type], args: List[ast.tpd.Tree], resultType: Type)(implicit ctx: Context): Boolean

Is given method reference applicable to type arguments targs and argument trees args without inferring views?
Is given method reference applicable to type arguments targs and argument trees args without inferring views?
resultType
The expected result type of the application
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def normalizedCompatible(tp: Type, pt: Type)(implicit ctx: Context): Boolean

Test compatibility after normalization in a fresh typerstate.
Test compatibility after normalization in a fresh typerstate.

Definition Classes
Compatibility
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def resolveOverloaded(alts: List[TermRef], pt: Type)(implicit ctx: Context): List[TermRef]

Resolve overloaded alternative alts, given expected type pt and possibly also type argument targs that need to be applied to each alternative to form the method type.
Resolve overloaded alternative alts, given expected type pt and possibly also type argument targs that need to be applied to each alternative to form the method type. todo: use techniques like for implicits to pick candidates quickly?
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def typedApply(tree: ast.untpd.Apply, pt: Type)(implicit ctx: Context): ast.tpd.Tree
def typedNamedArgs(args: List[ast.untpd.Tree])(implicit ctx: Context): List[NamedArg[Type]]
def typedTypeApply(tree: ast.untpd.TypeApply, pt: Type)(implicit ctx: Context): ast.tpd.Tree
def typedUnApply(tree: ast.untpd.UnApply, selType: Type)(implicit ctx: Context): ast.tpd.UnApply

A typed unapply hook, can be overridden by re any-typers between frontend and pattern matcher.
def typedUnApply(tree: ast.untpd.Apply, selType: Type)(implicit ctx: Context): ast.tpd.Tree
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Applications | package typer

trait Applications extends Compatibility

Type Members

class ApplicableToTrees extends (Applications.this)#TestApplication[ast.tpd.Tree]

class ApplicableToTreesDirectly extends (Applications.this)#ApplicableToTrees

class ApplicableToTypes extends (Applications.this)#TestApplication[Type]

abstract class Application[Arg] extends AnyRef

class ApplyToTyped extends (Applications.this)#TypedApply[Type]

class ApplyToUntyped extends (Applications.this)#TypedApply[Untyped]

abstract class TestApplication[Arg] extends (Applications.this)#Application[Arg]

abstract class TypedApply[T >: Untyped] extends (Applications.this)#Application[Tree[T]]

Abstract Value Members

abstract def viewExists(tp: Type, pt: Type)(implicit ctx: Context): Boolean

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def argCtx(app: ast.untpd.Tree)(implicit ctx: Context): Context

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def constrainResult(mt: Type, pt: Type)(implicit ctx: Context): Boolean

def convertNewGenericArray(tree: ast.tpd.Tree)(implicit ctx: Context): ast.tpd.Tree

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def handleUnexpectedFunType(tree: ast.untpd.Apply, fun: ast.tpd.Tree)(implicit ctx: Context): ast.tpd.Tree

def harmonize(trees: List[ast.tpd.Tree])(implicit ctx: Context): List[ast.tpd.Tree]

def harmonizeTypes(tpes: List[Type])(implicit ctx: Context): List[Type]

def hashCode(): Int

def isApplicable(tp: Type, args: List[Type], resultType: Type)(implicit ctx: Context): Boolean

def isApplicable(tp: Type, targs: List[Type], args: List[ast.tpd.Tree], resultType: Type)(implicit ctx: Context): Boolean

def isApplicable(methRef: TermRef, args: List[Type], resultType: Type)(implicit ctx: Context): Boolean

def isApplicable(methRef: TermRef, targs: List[Type], args: List[ast.tpd.Tree], resultType: Type)(implicit ctx: Context): Boolean

def isAsGood(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Boolean

def isCompatible(tp: Type, pt: Type)(implicit ctx: Context): Boolean

def isDirectlyApplicable(methRef: TermRef, targs: List[Type], args: List[ast.tpd.Tree], resultType: Type)(implicit ctx: Context): Boolean

final def isInstanceOf[T0]: Boolean

def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef]

final def ne(arg0: AnyRef): Boolean

def normalizedCompatible(tp: Type, pt: Type)(implicit ctx: Context): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def resolveOverloaded(alts: List[TermRef], pt: Type)(implicit ctx: Context): List[TermRef]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def typedApply(tree: ast.untpd.Apply, pt: Type)(implicit ctx: Context): ast.tpd.Tree

def typedNamedArgs(args: List[ast.untpd.Tree])(implicit ctx: Context): List[NamedArg[Type]]

def typedTypeApply(tree: ast.untpd.TypeApply, pt: Type)(implicit ctx: Context): ast.tpd.Tree

def typedUnApply(tree: ast.untpd.UnApply, selType: Type)(implicit ctx: Context): ast.tpd.UnApply

def typedUnApply(tree: ast.untpd.Apply, selType: Type)(implicit ctx: Context): ast.tpd.Tree

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Compatibility

Inherited from AnyRef

Inherited from Any

Ungrouped