Produces an inlined version of
call via its
A typer for inlined code. Its purpose is: 1. Implement constant folding over inlined code 2. Selectively expand ifs with constant conditions 3. Inline arguments that are by-name closures 4. Make sure inlined code is type-correct. 5. Make sure that the tree's typing is idempotent (so that future -Ycheck passes succeed)
An extractor for references to inlineable arguments. These are :
- by-value arguments marked with
- all by-name arguments
A buffer for bindings that define proxies for actual arguments
A map from parameter names of the inline method to references of the actual arguments.
For a type argument this is the full argument type.
For a value argument, it is a reference to either the argument value
(if the argument is a pure expression of singleton type), or to
as a proxy (if the argument is something else).
A map from references to (type and value) parameters of the inline method
to their corresponding argument or proxy references, as given by
A map from the classes of (direct and outer) this references in
to references of their proxies.
Note that we can't index by the ThisType itself since there are several
possible forms to express what is logicaly the same ThisType. E.g.
These are different (wrt ==) types but represent logically the same key
bindingsBuf by matching parameters with
bindingbuf will be further extended later by
proxies to this-references.
Drop any side-effect-free bindings that are unused in expansion or other reachable bindings. Inline def bindings that are used only once.
A binding for the parameter of an inlined method. This is a
val def for
by-value parameters and a
def def for by-name parameters.
val defs inherit
inline annotations from their parameters. The generated
def is appended
Register type of leaf node
paramProxy as follows:
1a. If given type refers to a static this, thisProxy binds it to corresponding global reference,
1b. If given type refers to an instance this to a class that is not contained in the
inlined method, create a proxy symbol and bind the thistype to refer to the proxy.
The proxy is not yet entered in
bindingsBuf; that will come later.
2. If given type refers to a parameter, make
paramProxy refer to the entry stored
paramNames under the parameter's name. This roundabout way to bind parameter
references to proxies is done because we don't know a priori what the parameter
references of a method are (we only know the method's type, but that contains TypeParamRefs
and MethodParams, not TypeRefs or TermRefs.