Application

abstract def addArg(arg: TypedArg, formal: Type): Unit

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

abstract def appPos: Position

abstract def fail(msg: ⇒ Message): Unit

Signal failure with given message at position of the application itself

abstract def fail(msg: ⇒ Message, arg: Arg): Unit

Signal failure with given message at position of given argument

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

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

abstract def isVarArg(arg: Arg): Boolean

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

abstract def makeVarArg(n: Int, elemFormal: Type): Unit

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

abstract def normalizedFun: ast.tpd.Tree

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

abstract def treeToArg(arg: ast.tpd.Tree): Arg

Turn a typed tree into an argument

abstract def typedArg(arg: Arg, formal: Type): TypedArg

Given an original argument and the type of the corresponding formal parameter, produce a typed argument.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findDefaultGetter(n: Int)(implicit ctx: Context): ast.tpd.Tree

Find reference to default parameter getter for parameter #n in current parameter list, or NoType if none was found

final def getClass(): Class[_]

def hashCode(): Int

def init(): Unit

final def isInstanceOf[T0]: Boolean

def liftFun(): Unit

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

def matchArgs(args: List[Arg], formals: List[Type], n: Int): Unit

Match re-ordered arguments against formal parameters

val methType: Type

The function's type after widening and instantiating polytypes with polyparams in constraint set

def methodType: MethodType

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def ok: Boolean

def ok_=(x: Boolean): Unit

lazy val orderedArgs: List[Arg]

The arguments re-ordered so that each named argument matches the same-named formal parameter.

def reorder[T >: Untyped](args: List[Tree[T]]): List[Tree[T]]

Re-order arguments to correctly align named arguments

def spliceMeth(meth: ast.tpd.Tree, app: ast.tpd.Tree): ast.tpd.Tree

Splice new method reference into existing application

def success: Boolean

The application was successful

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit