abstract class TypedApply [ T ]
extends Application

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

Constructors

TypedApply ( app: Apply , fun: Tree , methRef: TermRef , args: List [ Tree [ T ] ] , resultType: Type )
TypedApply ( implicit ctx: Context )

Members

type TypedArg = Tree

The type of typed arguments: either tpd.Tree or Type

The type of typed arguments: either tpd.Tree or Type

private val app : Apply
private val args : List [ Tree [ T ] ]
private implicit val ctx : Context
private val fun : Tree
private var liftedDefs : ListBuffer [ Tree ]
private val methRef : TermRef
private var myNormalizedFun : Tree
val result : Tree
private val resultType : Type
private var typedArgBuf : ListBuffer [ Tree ]
def addArg ( arg: Tree , formal: Type ) : Unit

Check that argument corresponds to type formal and possibly add it to the list of adapted arguments

Check that argument corresponds to type formal and possibly add it to the list of adapted arguments

override def appPos : Position
def fail ( msg: => Message , arg: Tree [ T ] ) : Unit

Signal failure with given message at position of given argument

Signal failure with given message at position of given argument

def fail ( msg: => Message ) : Unit

Signal failure with given message at position of the application itself

Signal failure with given message at position of the application itself

private def firstDiff ( xs: List [ T ] , ys: List [ T ] , n: Int ) : Int

The index of the first difference between lists of trees xs and ys, where EmptyTrees in the second list are skipped. -1 if there are no differences.

The index of the first difference between lists of trees xs and ys, where EmptyTrees in the second list are skipped. -1 if there are no differences.

def firstDiff$default$3 : Int

The index of the first difference between lists of trees xs and ys, where EmptyTrees in the second list are skipped. -1 if there are no differences.

The index of the first difference between lists of trees xs and ys, where EmptyTrees in the second list are skipped. -1 if there are no differences.

def harmonizeArgs ( args: List [ TypedArg ] ) : List [ TypedArg ]

If all args have primitive numeric types, make sure it's the same one

If all args have primitive numeric types, make sure it's the same one

def isVarArg ( arg: Tree [ T ] ) : Boolean

Is this an argument of the form expr: _* or a RepeatedParamType derived from such an argument?

Is this an argument of the form expr: _* or a RepeatedParamType derived from such an argument?

override def liftFun ( ) : Unit

If constructing trees, pull out all parts of the function which are not idempotent into separate prefix definitions

If constructing trees, pull out all parts of the function which are not idempotent into separate prefix definitions

private def liftedDefs_= ( x$1: ListBuffer [ Tree ] ) : Unit
def makeVarArg ( n: Int , elemFormal: Type ) : Unit

If constructing trees, turn last n processed arguments into a SeqLiteral tree with element type elemFormal.

If constructing trees, turn last n processed arguments into a SeqLiteral tree with element type elemFormal.

private def myNormalizedFun_= ( x$1: Tree ) : Unit
def normalizedFun : Tree

The current function part, which might be affected by lifting.

The current function part, which might be affected by lifting.

private def sameSeq ( xs: List [ T ] , ys: List [ T ] ) : Boolean
private def typedArgBuf_= ( x$1: ListBuffer [ Tree ] ) : Unit