MutableTyperState
Related Doc:
package core
Commit typer state so that its information is copied into current typer state In addition (1) the owning state of undetermined or temporarily instantiated type variables changes from this typer state to the current one.
Commit typer state so that its information is copied into current typer state In addition (1) the owning state of undetermined or temporarily instantiated type variables changes from this typer state to the current one. (2) Variables that were temporarily instantiated in the current typer state are permanently instantiated instead.
A note on merging: An interesting test case is isApplicableSafe.scala. It turns out that this
requires a context merge using the new &' operator. Sequence of actions:
1) Typecheck argument in typerstate 1.
2) Cache argument.
3) Evolve same typer state (to typecheck other arguments, say)
leading to a different constraint.
4) Take typechecked argument in same state.
It turns out that the merge is needed not just for isApplicableSafe but also for (e.g. erased-lubs.scala) as well as many parts of dotty itself.
The current constraint set
The current constraint set
The ephemeral flag is set as a side effect if an operation accesses the underlying type of a type variable.
The ephemeral flag is set as a side effect if an operation accesses the underlying type of a type variable. The reason we need this flag is that any such operation is not referentially transparent; it might logically change its value at the moment the type variable is instantiated. Caching code needs to check the ephemeral flag; If the flag is set during an operation, the result of that operation should not be cached.
A fallback text representation, if the pattern matching in Printers does not have a case for this showable element
A fallback text representation, if the pattern matching in Printers does not have a case for this showable element
A fresh typer state with the same constraint as this one.
A fresh typer state with the same constraint as this one.
The constraint can be committed to an enclosing context.
Make type variable instances permanent by assigning to inst field if
type variable instantiation cannot be retracted anymore.
Make type variable instances permanent by assigning to inst field if
type variable instantiation cannot be retracted anymore. Then, remove
no-longer needed constraint entries.
Gives for each instantiated type var that does not yet have its inst field
set, the instance value stored in the constraint.
Gives for each instantiated type var that does not yet have its inst field
set, the instance value stored in the constraint. Storing instances in constraints
is done only in a temporary way for contexts that may be retracted
without also retracting the type var as a whole.
Is it allowed to commit this state?
Is it allowed to commit this state?
Can this state be transitively committed until the top-level?
Can this state be transitively committed until the top-level?
The current reporter
The current reporter
The string representation of this showable element.
The string representation of this showable element.
The summarized string representation of this showable element.
The summarized string representation of this showable element. Recursion depth is limited to some smallish value. Default is Config.summarizeDepth.
The text representation of this showable element.
The text representation of this showable element. This normally dispatches to a pattern matching method in Printers.
Try operation op; if it produces errors, execute fallback with constraint and
reporter as they were before op was executed.
Try operation op; if it produces errors, execute fallback with constraint and
reporter as they were before op was executed. This is similar to typer/tryEither,
but with one important difference: Any type variable instantiations produced by op
are persisted even if op fails. This is normally not what one wants and therefore
it is recommended to use
tryEither { implicit ctx => op } { (_, _) => fallBack }
instead of
ctx.tryWithFallback(op)(fallBack)
tryWithFallback is only used when an implicit parameter search fails
and the whole expression is subsequently retype-checked with a Wildcard
expected type (so as to allow an implicit conversion on the result and
avoid over-constraining the implicit parameter search). In this case,
the only type variables that might be falsely instantiated by op but
not by fallBack are type variables in the typed expression itself, and
these will be thrown away and new ones will be created on re-typing.
So tryWithFallback is safe. It is also necessary because without it
we do not propagate enough instantiation information into the implicit search
and this might lead to a missing parameter type error. This is exhibited
at several places in the test suite (for instance in pos_typers).
Overall, this is rather ugly, but despite trying for 2 days I have not
found a better solution.
The closest ancestor of this typer state (including possibly this typer state itself) which is not yet committed, or which does not have a parent.
The closest ancestor of this typer state (including possibly this typer state itself) which is not yet committed, or which does not have a parent.
The uninstantiated variables
The uninstantiated variables
Throws an UnsupportedOperationException with the given method name.
Throws an UnsupportedOperationException with the given method name.
A fresh type state with the same constraint as this one and the given reporter
A fresh type state with the same constraint as this one and the given reporter