Names of phases that must run before this phase.

Name of the phase that this phase must follow immediately.

The implicit not found message from the annotation, and whether it's a supplement message or not.

A sentinel indicating no implicit was found

Keeps track of macros in-flight. See more informations in comments to openMacros in scala.reflect.macros.whitebox.Context.

An explanatory note to be added to error messages when there's a problem with abstract var defs

The goal of this method is to find a class that is accessible (in bytecode) and can be used to select member. - For constructors, it returns the member.owner. We can assume the class is accessible: if it wasn't, the typer would have rejected the program, as the class is referenced in source. - For Scala-defined members it also returns member.owner, all Scala-defined classes are public in bytecode. - For Java-defined members we prefer a direct parent over of the owner, even if the owner is accessible. This way the owner doesn't need to be added as a direct parent, see scala-dev#143.

Registers a new analyzer plugin

Extend the argument list givenArgs with default arguments. Defaults are added as named arguments calling the corresponding default getter.

Returns the extended arg list and missing parameters if any.

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())

Registers a new macro plugin

Add the synthetic methods to case classes.

returns true if every element is equal to its index

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).

Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal. If the expression's length is smaller than the threshold specified via plugin parameter, return a single line.

Does not force the info of caseclazz

Generates copy methods for case classes. Copy only has defaults on the first parameter list, as of scala/bug#5009.

The parameter types of the copy method need to be exactly the same as the parameter types of the primary constructor. Just copying the TypeTree is not enough: a type C might refer to something else *inside* the class (i.e. as parameter type of copy) than *outside* the class (i.e. in the class parameter list).

One such example is t0054.scala: class A { case class B(x: C) extends A { def copy(x: C = x) = ... } class C {} } (1) (2)

The reference (1) to C is A.this.C. The reference (2) is B.this.C - not the same.

This is fixed with a hack currently. Unapplies.caseClassCopyMeth, which creates the copy method, uses empty TypeTree() nodes for parameter types.

In Namers.enterDefDef, the copy method gets a special type completer (enterCopyMethod). Before computing the body type of copy, the class parameter types are assigned the copy method parameters.

This attachment class stores the copy method parameter ValDefs as an attachment in the ClassDef of the 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 unapply method corresponding to a case class

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?

Does this symbol compile to the underlying platform's notion of an interface, without requiring compiler magic before it can be instantiated?

More specifically, we're interested in whether LambdaMetaFactory can instantiate this type, assuming it has a single abstract method. In other words, if we were to mix this trait into a class, it should not result in any compiler-generated members having to be implemented in ("mixed in to") this class (except for the SAM).

Thus, the type must erase to a java interface, either by virtue of being defined as one, or by being a trait that:

• is static (explicitouter or lambdalift may add disqualifying members)
• extends only other traits that compile to pure interfaces (except for Any)
• has no val/var members

TODO: can we speed this up using the INTERFACE flag, or set it correctly by construction?

Decreases metalevel of the type, i.e. transforms: * c.Expr[T] to T * Nothing to Nothing * Anything else to NoType

For a parameter with default argument, find the method symbol of the default getter.

Check if a class defines a member after erasure. The phase travel is important for trait T extends AClass: after erasure (and in bytecode), T has supertype Object, not AClass.

Returns unapply or unapplySeq if available, without further checks.

Is this component enabled? Default is true.

Expand partial method application p.f(es_1)...(es_n).

We expand this to the following block, which evaluates the target of the application and its supplied arguments if needed (they are not stable), and then wraps a Function that abstracts over the missing arguments.

{
  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))
}

This is called from typedEtaExpansion, which itself is called from

• instantiateToMethodType (for a naked method reference), or
• typedEta (when type checking a method value, m _).

[a, b, c] => "(a, b, c)" [a, B] => "(param1, param2)" [a, B, c] => "(param1, ..., param2)"

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

Finish computation of param aliases after typechecking is completed

Turn a nested infix type structure into a flat list

::[A, ::[B, C]]] => List(A, ::, B, ::, C)

The formal parameter types corresponding to formals. If formals has a repeated last parameter, a list of (numArgs - numFormals + 1) copies of its type is appended to the other formals. By-name types are replaced with their underlying type.

A fresh type variable with given type parameter as origin.

Determines whether the target is either an original or a result of a macro expansion. The parameter is of type Any, because macros can expand both into trees and into annotations.

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)

Determines whether the given tree has an associated SuperArgsAttachment.

SubComponents are added to a HashSet and two phases are the same if they have the same name.

Increases metalevel of the type, i.e. transforms: * T to c.Expr[T]

A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.

Search for an implicit value. Consider using one of the convenience methods above. This one has many boolean levers.

See the comment on result at the end of class ImplicitSearch for more info how the search is conducted.

True if this phase runs before all other phases. Usually, parser.

True if this phase is not provided by a plug-in.

Determines whether a tree should not be expanded, because someone has put SuppressMacroExpansionAttachment on it or one of its children.

Determines whether a tree should or should not be adapted, because someone has put MacroImplRefAttachment on it.

The Java signature of type 'info', for symbol sym. The symbol is used to give the right return type for constructors.

After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment.

After macro expansion is completed, links the expandee and the expansion result by annotating them both with a MacroExpansionAttachment. The expanded parameter is of type Any, because macros can expand both into trees and into annotations.

A version of Symbol#linkedClassOfClass that works with local companions, ala companionSymbolOf.

Macro def -> macro impl bindings are serialized into a macroImpl annotation with synthetic content that carries the payload described in MacroImplBinding.

For example, for a pair of macro definition and macro implementation: def impl(c: scala.reflect.macros.blackbox.Context): c.Expr[Unit] = ??? def foo: Unit = macro impl

We will have the following annotation added on the macro definition foo:

@scala.reflect.macros.internal.macroImpl(
  `macro`(
    "macroEngine" = <current macro engine>,
    "isBundle" = false,
    "isBlackbox" = true,
    "signature" = List(Other),
    "methodName" = "impl",
    "className" = "Macros$"))

Expands a term macro used in apply role as M(2)(3) in val x = M(2)(3).

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.

Expands a macro when a runtime (i.e. the macro implementation) can be successfully loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

Expands a macro when a runtime (i.e. the macro implementation) cannot be loaded Meant for internal use within the macro infrastructure, don't use it elsewhere.

Returns the original tree of the macro expansion if the argument is a macro expansion or EmptyTree otherwise.

Loads underlying MacroExpanderAttachment from a macro expandee or returns a default value for that attachment.

Produces a function that can be used to invoke macro implementation for a given macro definition: 1) Looks up macro implementation symbol in this universe. 2) Loads its enclosing class from the macro classloader. 3) Loads the companion of that enclosing class from the macro classloader. 4) Resolves macro implementation within the loaded companion.

Marks the tree as a macro impl reference, which is a naked reference to a method.

This is necessary for typechecking macro impl references (see DefaultMacroCompiler.defaultResolveMacroImpl), because otherwise typing a naked reference will result in the "follow this method with _ if you want to treat it as a partially applied function" errors.

This mark suppresses adapt except for when the annottee is a macro application.

A constructor for types ?{ def/type name: tp }, used in infer view to member searches.

Returns the parameter symbols of an invocation expression that are not defined by the list of arguments.

Create a new phase which applies transformer

The transformer factory