dotc
has almost no global state (with the exception of the name table,
which hashes strings into unique names). Instead, all
essential bits of information that can vary over a compiler run are collected
in a Context
(defined in Contexts).
Most methods in the compiler depend on an implicit anonymous Context
parameter,
and a typical definition looks like the following:
import dotty.tools.dotc.Contexts.{Context, ctx}
def doFoo(using Context): Unit =
val current = ctx.run // access the Context parameter with `ctx`
Memory Leaks
Careful: Contexts can be heavy so beware of memory leaks
It is good practice to ensure that implicit contexts are not
captured in closures or other long-lived objects, in order to avoid space leaks
in the case where a closure can survive several compiler runs (e.g. a
lazy completer for a library class that is never required). In that case, the
convention is that the Context
be an explicit parameter, to track its usage.
Context Properties
Context property | description |
---|---|
compilationUnit |
current compilation unit |
phase |
current phase |
run |
current run |
period |
current period |
settings |
the config passed to the compiler |
reporter |
operations for logging errors/warnings |
definitions |
the standard built in definitions |
platform |
operations for the underlying platform |
tree |
current tree |
scope |
current scope |
typer |
current typer |
owner |
current owner symbol |
outer |
outer Context |
mode |
type checking mode |
typerState |
|
searchHistory |
|
implicits |
|
… | and so on |
Contributors to this page:
Contents
- About This Guide
- Getting Started
- Contributing to Scala 3
- Cheatsheets
- Reproducing an Issue
- Finding the Cause of an Issue
- Common Issue Locations
- How to Inspect Values
- Improving Your Workflow
- Testing Your Changes
- Pull Request Checklist
- High Level Architecture
- Compiler Overview
- Contexts
- Compiler Phases
- Compiler Types
- Time in the Compiler
- Symbols