Packages

•  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes

  root

•  package scala

  Definition Classes

  root

•  package tools

  Definition Classes

  scala

•  package nsc

  Definition Classes

  tools

•  package typechecker

  Definition Classes

  nsc

•  trait Contexts extends AnyRef
  Definition Classes

  typechecker

•  class Context extends AnyRef

  A motley collection of the state and loosely associated behaviour of the type checker.

  A motley collection of the state and loosely associated behaviour of the type checker. Each Typer has an associated context, and as it descends into the tree new (Typer, Context) pairs are spawned.

  Meet the crew; first the state:

  • A tree, symbol, and scope representing the focus of the typechecker
  • An enclosing context, outer.
  • The current compilation unit.
  • A variety of bits that track the current error reporting policy (more on this later); whether or not implicits/macros are enabled, whether we are in a self or super call or in a constructor suffix. These are represented as bits in the mask contextMode.
  • Some odds and ends: undetermined type parameters of the current line of type inference; contextual augmentation for error messages, tracking of the nesting depth.

  And behaviour:

  • The central point for issuing errors and warnings from the typechecker, with a means to buffer these for use in 'silent' type checking, when some recovery might be possible.

  • Context is something of a Zipper for the tree were are typechecking: it enclosingContextChain is the path back to the root. This is exactly what we need to resolve names (lookupSymbol) and to collect in-scope implicit definitions (implicitss) Supporting these are imports, which represents all Import trees in in the enclosing context chain.
  • In a similar vein, we can assess accessibility (isAccessible.)

  More on error buffering: When are type errors recoverable? In quite a few places, it turns out. Some examples: trying to type an application with/without the expected type, or with/without implicit views enabled. This is usually mediated by Typer.silent, Inferencer#tryTwice.

  Initially, starting from the typer phase, the contexts either buffer or report errors; afterwards errors are thrown. This is configured in rootContext. Additionally, more fine grained control is needed based on the kind of error; ambiguity errors are often suppressed during exploratory typing, such as determining whether a == b in an argument position is an assignment or a named argument, when Inferencer#isApplicableSafe type checks applications with and without an expected type, or when Typer#tryTypedApply tries to fit arguments to a function type with/without implicit views.

  When the error policies entail error/warning buffering, the mutable ContextReporter records everything that is issued. It is important to note, that child Contexts created with make "inherit" the very same ContextReporter instance, whereas children spawned through makeSilent receive a separate, fresh buffer.

  Definition Classes

  Contexts

• TryTwice

scala.tools.nsc.typechecker.Contexts.Context

TryTwice