Adapt a tree that has an annotated type to the given type tp, taking into account the given mode (see method adapt in trait Typers).

An implementation cannot rely on canAdaptAnnotations being called before. If the implementing class cannot do the adapting, it should return the tree unchanged.

Selectively activate this analyzer plugin, e.g. according to the compiler phase.

Note that the current phase can differ from the global compiler phase (look for enteringPhase invocations in the compiler). For instance, lazy types created by the UnPickler are completed at the phase in which their symbol is created. Observations show that this can even be the parser phase. Since symbol completion can trigger subtyping, typing etc, your plugin might need to be active also in phases other than namer and typer.

Typically, this method can be implemented as

global.phase.id < global.currentRun.picklerPhase.id

Construct a custom error message for implicit parameters that could not be resolved.

Access the search instance that will be used for the implicit search.

The motivation of this method is to allow analyzer plugins to control when/where implicit search are triggered, and access their environment for data capturing purposes.

Access the implicit search result from Scalac's typechecker.

The motivation of this method is to allow analyzer plugins to control when/where implicit search results are returned, and inspect them for data capturing purposes.

Let analyzer plugins change the types assigned to definitions. For definitions that have an annotated type, the assigned type is obtained by typing that type tree. Otherwise, the type is inferred by typing the definition's righthand side, or from the overridden member under -Xsource-features.

In order to know if the type was inferred, you can query the wasEmpty field in the tpt TypeTree of the definition (for DefDef and ValDef).

(*) If the type of a method or value is inferred, the type-checked tree is stored in the analyzer.transformed hash map, indexed by the definition's rhs tree.

NOTE: Invoking the type checker can lead to cyclic reference errors. For instance, if this method is called from the type completer of a recursive method, type checking the method rhs will invoke the same completer again. It might be possible to avoid this situation by assigning tpe to defTree.symbol (untested) - the final type computed by this method will then be assigned to the definition's symbol by monoTypeCompleter (in Namers).

The hooks into typeSig allow analyzer plugins to add annotations to (or change the types of) definition symbols. This cannot not be achieved by using pluginsTyped: this method is only called during type checking, so changing the type of a symbol at this point is too late: references to the symbol might already be typed and therefore obtain the original type assigned during naming.

Modify the types of field accessors. The namer phase creates method types for getters and setters based on the type of the corresponding field.

Note: in order to compute the method type of an accessor, the namer calls typeSig on the ValDef tree of the corresponding field. This implies that the pluginsTypeSig method is potentially called multiple times for the same ValDef tree.

Let analyzer plugins modify the type that has been computed for a tree.

Modify the type of a return expression. By default, return expressions have type NothingTpe.