Work in Progress

We are still in the process of writing the documentation for Scala 3. You can help us to improve the documentation.

Are you searching for the Scala 2 documentation?

Guide to Scala 3 Compiler Contribution

Contexts

Language

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: