Semantic

Utility definition used for better error-reporting of argument errors

Cache used in fixed point computation

The analysis computes the least fixed point for the cache (see doc for ExprValueCache).

For the fixed point computation to terminate, we need to make sure that the domain of the cache, i.e. the key pair (Ref, Tree) is finite. As the code is finite, we only need to carefully design the abstract domain to be finitary.

We also need to make sure that the computing function (i.e. the abstract interpreter) is monotone. Error handling breaks monotonicity of the abstract interpreter, because when an error happens, we always return the bottom value Hot for an expression. It is not a threat for termination because when an error happens, we stop the fixed point computation at the end of the iteration where the error happens. Care must be paid to tests of errors, monotonicity will be broken if we simply ignore the test errors (See TryReporter).

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.

An object with unknown initialization status

A function value

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.

Error reporting

A reference to the object under initialization pointed by this

A TryReporter cannot be simply thrown away

Either abort should be called or the errors be reported.

If errors are ignored and abort is not called, the monotonicity of the computation function is not guaranteed, thus termination of fixed-point computation becomes a problem.

Abstract values

Value = Hot | Cold | Warm | ThisRef | Fun | RefSet

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

ThisRef Warm Fun RefSet │ ▲ ▲ ▲ │ │ │ │ | │ │ │ ▲ │ │ │ │ │ │ │ └─────────┴───────┴───────┘ Hot

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.

The state that threads through the interpreter

Add a checking task to the work list

Handles the evaluation of different expressions

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

Handle semantics of leaf nodes

Perform check on the work list until it becomes empty

Should only be called once from the checker.

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.

The parameter cacheResult is used to reduce the size of the cache.

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 outer select introduced during inlining.

See tpd.outerSelect and ElimOuterSelect.

Resolve C.this that appear in klass

Perform actions with initial checking state.

Semantic.withInitialState {
   Semantic.addTask(...)
   ...
   Semantic.check()
}