Scala Compiler2.13.2 < Back


# 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 ast
  Definition Classes
    nsc
-  package backend
  Definition Classes
    nsc
-  package classpath
  Definition Classes
    nsc
-  package doc
  Definition Classes
    nsc
-  package fsc
  Definition Classes
    nsc
-  package interactive
  Definition Classes
    nsc
-  package tests
- CancelException
- CommentPreservingTypers
- CompilerControl
- CondPickler
- ContextTrees
- FreshRunReq
- Global
- InteractiveAnalyzer
- InteractiveReporter
- Lexer
- LogReplay
- Logger
- Main
- MissingResponse
- NoSuchUnitError
- NullLogger
- Pickler
- Picklers
- PresentationCompilerThread
- PrettyWriter
- Problem
- REPL
- RangePositions
- Replayer
- Response
- RichCompilationUnits
- ShutdownReq
-  package interpreter
  Definition Classes
    nsc
-  package io
  Definition Classes
    nsc
-  package javac
  Definition Classes
    nsc
-  package plugins
  Definition Classes
    nsc
-  package profile
  Definition Classes
    nsc
-  package reporters
  Definition Classes
    nsc
-  package settings
  Definition Classes
    nsc
-  package symtab
  Definition Classes
    nsc
-  package transform
  Definition Classes
    nsc
-  package typechecker
  Definition Classes
    nsc
-  package util
  Definition Classes
    nsc

p

scala.tools.nsc

# interactive

#### package interactive

Content Hierarchy

Ordering

1. Alphabetic

Visibility

1. Public
2. Protected

### Package Members

1.  package tests

### Type Members

1.  trait CommentPreservingTypers extends Typers

   This trait allows the IDE to have an instance of the PC that does not clear the comments table at every new typer run (those being many and close between in this context).

2.  trait CompilerControl extends AnyRef

   Interface of interactive compiler to a client such as an IDE The model the presentation compiler consists of the following parts:

   Interface of interactive compiler to a client such as an IDE The model the presentation compiler consists of the following parts:

   unitOfFile: The map from sourcefiles to loaded units. A sourcefile/unit is loaded if it occurs in that map.

   manipulated by: removeUnitOf, reloadSources.

   A call to reloadSources will add the given sources to the loaded units, and start a new background compiler pass to compile all loaded units (with the indicated sources first). Each background compiler pass has its own typer run. The background compiler thread can be interrupted each time an AST node is completely typechecked in the following ways:

   1. by a new call to reloadSources. This starts a new background compiler pass with a new typer run. 2. by a call to askTypeTree. This starts a new typer run if the forceReload parameter = true 3. by a call to askTypeAt, askTypeCompletion, askScopeCompletion, askToDoFirst, askLinkPos, askLastType. 4. by raising an exception in the scheduler. 5. by passing a high-priority action wrapped in ask { ... }.

   Actions under 1-3 can themselves be interrupted if they involve typechecking AST nodes. High-priority actions under 5 cannot; they always run to completion. So these high-priority actions should to be short.

   Normally, an interrupted action continues after the interrupting action is finished. However, if the interrupting action created a new typer run, the interrupted action is aborted. If there's an outstanding response, it will be set to a Right value with a FreshRunReq exception.

3.  abstract class CondPickler[T] extends Pickler[T]

   A subclass of Pickler can indicate whether a particular value can be pickled by instances of this class.

4.  trait ContextTrees extends AnyRef
5.  class FreshRunReq extends ControlThrowable

   Signals a request for a fresh background compiler run.

   Signals a request for a fresh background compiler run. Note: The object has to stay top-level so that the PresentationCompilerThread may access it.

6.  class Global extends nsc.Global with CompilerControl with ContextTrees with RichCompilationUnits with Picklers

   The main class of the presentation compiler in an interactive environment such as an IDE

7.  trait InteractiveAnalyzer extends Analyzer
8.  abstract class InteractiveReporter extends FilteringReporter
9.  class Lexer extends AnyRef

   A simple lexer for tokens as they are used in JSON, plus parens `(`, `)` Tokens understood are:

   A simple lexer for tokens as they are used in JSON, plus parens `(`, `)` Tokens understood are:

   `(`, `)`, `[`, `]`, `{`, `}`, `:`, `,`, `true`, `false`, `null`, strings (syntax as in JSON), integer numbers (syntax as in JSON: -?(0|\d+) floating point numbers (syntax as in JSON: -?(0|\d+)(\.\d+)?((e|E)(+|-)?\d+)?) The end of input is represented as its own token, EOF. Lexers can keep one token lookahead

10.  abstract class LogReplay extends AnyRef
11.  class Logger extends LogReplay
12.  class MissingResponse extends Exception
13.  class NoSuchUnitError extends Exception
14.  abstract class Pickler[T] extends AnyRef

    An abstract class for writing and reading Scala objects to and from a legible representation.

    An abstract class for writing and reading Scala objects to and from a legible representation. The representation follows the following grammar:

        Pickled = `true` | `false` | `null` | NumericLit | StringLit |
                  Labelled | Pickled `,` Pickled
        Labelled = StringLit `(` Pickled? `)`

    All ...Lit classes are as in JSON. @see scala.tools.nsc.io.Lexer

    Subclasses of `Pickler` each can write and read individual classes of values.

    T

      the type of values handled by this pickler. These Picklers build on the work of Andrew Kennedy. They are most closely inspired by Iulian Dragos' picklers for Scala to XML. See: http://code.google.com/p/gdata-scala-client/wiki/DevelopersGuide

15.  trait Picklers extends AnyRef
16.  final class PresentationCompilerThread extends Thread

    A presentation compiler thread.

    A presentation compiler thread. This is a lightweight class, delegating most of its functionality to the compiler instance.

17.  class PrettyWriter extends Writer
18.  case class Problem(pos: Position, msg: String, severityLevel: Int) extends Product with Serializable
19.  class Replayer extends LogReplay
20.  class Response[T] extends AnyRef

    Typical interaction, given a predicate <user-input>, a function <display>, and an exception handler <handle>:

    Typical interaction, given a predicate <user-input>, a function <display>, and an exception handler <handle>:

    val TIMEOUT = 100 // (milliseconds) or something like that val r = new Response() while (!r.isComplete && !r.isCancelled) { if (<user-input>) r.cancel() else r.get(TIMEOUT) match { case Some(Left(data)) => <display>(data) case Some(Right(exc)) => <handle>(exc) case None => } }

21.  trait RichCompilationUnits extends AnyRef

### Deprecated Type Members

1.  trait RangePositions extends Positions with Trees with Positions
   Annotations
     @deprecated
   Deprecated

     (Since version 2.11.0) Use scala.reflect.internal.Positions

### Value Members

1.  object CancelException extends Exception
2.  object Lexer

   Companion object of class `Lexer` which defines tokens and some utility concepts used for tokens and lexers

3.  object Main extends MainClass

   The main class for NSC, a compiler for the programming language Scala.

4.  object NullLogger extends LogReplay
5.  object Pickler
6.  object REPL

   Interface of interactive compiler to a client such as an IDE

7.  object ShutdownReq extends ControlThrowable

   Signals a request for a shutdown of the presentation compiler.

   Signals a request for a shutdown of the presentation compiler. Note: The object has to stay top-level so that the PresentationCompilerThread may access it.

### Ungrouped