scala3-compiler-bootstrapped/dotty.tools.dotc.transform.init/Semantic

Semantic

class Semantic

Companion: object

class Object

trait Matchable

class Any

Type members

Classlikes

An object with unknown initialization status

Interpreter configuration

The (abstract) interpreter can be seen as a push-down automaton that transits between the configurations where the stack is the implicit call stack of the meta-language.

It's important that the configuration is finite for the analysis to terminate.

For soundness, we need to compute fixed point of the cache, which maps configuration to evaluation result.

Thanks to heap monotonicity, heap is not part of the configuration. Which also avoid computing fix-point on the cache, as the cache is immutable.

A function value

Abstract heap stores abstract objects

As in the OOPSLA paper, the abstract heap is monotonistic.

A transitively initialized object

The abstract object which stores value about its fields and immediate outers.

Semantically it suffices to store the outer for klass. We cache other outers for performance reasons.

Note: Object is NOT a value.

A value which represents a set of addresses

It comes from if expressions.

Result of abstract interpretation

A reference to the object under initialization pointed by this

Abstract values

           Cold
  ┌──────►  ▲   ◄──┐  ◄────┐
  │         │      │       │
  │         │      │       │

ThisRef(C) │ │ │ ▲ │ │ │ │ Warm(D) Fun RefSet │ ▲ ▲ ▲ │ │ │ │ Warm(C) │ │ │ ▲ │ │ │ │ │ │ │ └─────────┴──────┴───────┘ Hot

The most important ordering is the following:

 Hot ⊑ Warm(C) ⊑ ThisRef(C) ⊑ Cold

The diagram above does not reflect relationship between RefSet and other values. RefSet represents a set of values which could be ThisRef, Warm or Fun. The following ordering applies for RefSet:

   R_a ⊑ R_b if R_a ⊆ R_b

   V ⊑ R if V ∈ R

An object with all fields initialized but reaches objects under initialization

We need to restrict nesting levels of outer to finitize the domain.

Types

Cache used to terminate the analysis

A finitary configuration is not enough for the analysis to terminate. We need to use cache to let the interpreter "know" that it can terminate.

For performance reasons we use curried key.

Note: It's tempting to use location of trees as key. That should be avoided as a template may have the same location as its single statement body. Macros may also create incorrect locations.

The state that threads through the interpreter

Value members

Concrete methods

Handles the evaluation of different expressions

Note: Recursive call should go to eval instead of cases.

Handle semantics of leaf nodes

Check that path in path-dependent types are initialized

This is intended to avoid type soundness issues in Dotty.

Evaluate an expression with the given value for this in a given class klass

Note that klass might be a super class of the object referred by thisV. The parameter klass is needed for this resolution. Consider the following code:

class A { A.this class B extends A { A.this } }

As can be seen above, the meaning of the expression A.this depends on where it is located.

This method only handles cache logic and delegates the work to cases.

Evaluate a list of expressions

Evaluate arguments of methods

Initialize part of an abstract object in klass of the inheritance chain

Compute the outer value that correspond to tref.prefix

Resolve C.this that appear in klass

Concrete fields

Extensions

extension (a: Value)

extension (value: Addr)

Can the method call on value be ignored?

Note: assume overriding resolution has been performed.

extension (value: Value)

Can we promote the value by checking the extrinsic values?

The extrinsic values are environment values, e.g. outers for Warm and thisV captured in functions.

This is a fast track for early promotion of values.

Promotion of values to hot

extension (value: Value)

Handle a new expression new p.C where p is abstracted by value

extension (values: Seq[Value])

extension (warm: Warm)

Try early promotion of warm objects

Promotion is expensive and should only be performed for small classes.

for each concrete method m of the warm object: call the method and promote the result
for each concrete field f of the warm object: promote the field value

If the object contains nested classes as members, the checker simply reports a warning to avoid expensive checks.

TODO: we need to revisit whether this is needed once we make the system more flexible in other dimentions: e.g. leak to methods or constructors, or use ownership for creating cold data structures.