Parser

abstract def deprecationWarning(off: Int, msg: String): Unit

abstract def freshName(prefix: String): Name

abstract def freshTermName(prefix: String): TermName

abstract def freshTypeName(prefix: String): TypeName

abstract val in: Scanner

abstract def incompleteInputError(msg: String): Unit

abstract def o2p(offset: Int): Position

abstract def parseStartRule: () ⇒ Tree

abstract def r2p(start: Int, mid: Int, end: Int): Position

abstract def syntaxError(offset: Int, msg: String): Unit

abstract def warning(offset: Int, msg: String): Unit

abstract def xmlLiteral(): Tree

abstract def xmlLiteralPattern(): Tree

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object InfixMode extends Enumeration

Modes for infix types.

def accept(token: Int): Int

Consume one token of the specified type, or signal an error if it is not there.

def acceptStatSep(): Unit

 semi = nl {nl} | `;`
 nl  = `\n' // where allowed

def acceptStatSepOpt(): Unit

def accessModifierOpt(): Modifiers

 AccessModifier ::= (private | protected) [AccessQualifier]

def accessQualifierOpt(mods: Modifiers): Modifiers

 AccessQualifier ::= `[' (Id | this) `]'

def annotTypeRest(t: Tree): Tree

def annotationExpr(): Tree

def annotations(skipNewLines: Boolean): List[Tree]

 Annotations      ::= {`@' SimpleType {ArgumentExprs}}
 ConsrAnnotations ::= {`@' SimpleType ArgumentExprs}

def argumentExprs(): List[Tree]

 ArgumentExprs ::= `(' [Exprs] `)'
                 | [nl] BlockExpr

def argumentPatterns(): List[Tree]

final def asInstanceOf[T0]: T0

var assumedClosingParens: Map[Int, Int]

def atPos[T <: Tree](pos: Position)(t: T): T

def atPos[T <: Tree](start: Int, point: Int, end: Int)(t: T): T

def atPos[T <: Tree](start: Int, point: Int)(t: T): T

def atPos[T <: Tree](offset: Int)(t: T): T

def block(): Tree

 Block ::= BlockStatSeq

def blockExpr(): Tree

 BlockExpr ::= `{' (CaseClauses | Block) `}'

def blockStatSeq(): List[Tree]

 BlockStatSeq ::= { BlockStat semi } [ResultExpr]
 BlockStat    ::= Import
                | Annotations [implicit] [lazy] Def
                | Annotations LocalModifiers TmplDef
                | Expr1
                |

def bound(tok: Int, default: TypeName): Tree

def caseBlock(): Tree

def caseClauses(): List[CaseDef]

 CaseClauses ::= CaseClause {CaseClause}
 CaseClause  ::= case Pattern [Guard] `=>' Block

final def caseSeparated[T](part: ⇒ T): List[T]

def checkAssoc(offset: Int, op: Name, leftAssoc: Boolean): Unit

def checkLegalExistential(t: Tree): Unit

Check that tree is a legal clause of a forSome.

def checkNoEscapingPlaceholders[T](op: ⇒ T): T

def checkNotByNameOrVarargs(tpt: Tree): Unit

Check that type parameter is not by name or repeated.

def checkSize(kind: String, size: Int, max: Int): Unit

def classDef(start: Int, mods: Modifiers): ClassDef

 ClassDef ::= Id [TypeParamClause] {Annotation}
              [AccessModifier] ClassParamClauses RequiresTypeOpt ClassTemplateOpt
 TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

def clone(): AnyRef

final def commaSeparated[T](part: ⇒ T): List[T]

def compilationUnit(): Tree

 CompilationUnit ::= {package QualId semi} TopStatSeq

def condExpr(): Tree

def constrBlock(vparamss: List[List[ValDef]]): Tree

 ConstrBlock    ::=  `{' SelfInvocation {semi BlockStat} `}'

def constrExpr(vparamss: List[List[ValDef]]): Tree

 ConstrExpr      ::=  SelfInvocation
                   |  ConstrBlock

def constructorAnnotations(): List[Tree]

def convertToParam(tree: Tree): ValDef

Convert tree to formal parameter.

def convertToParams(tree: Tree): List[ValDef]

Convert tree to formal parameter list.

def convertToTypeId(tree: Tree): Tree

Convert (qual)ident to type identifier.

def defOrDcl(pos: Int, mods: Modifiers): List[Tree]

 Def    ::= val PatDef
          | var PatDef
          | def FunDef
          | type [nl] TypeDef
          | TmplDef
 Dcl    ::= val PatDcl
          | var PatDcl
          | def FunDcl
          | type [nl] TypeDcl

def enumerators(): List[Enumerator]

 Enumerators ::= Generator {semi Enumerator}
 Enumerator  ::=  Generator
               |  Guard
               |  val Pattern1 `=' Expr

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def equalsExpr(): Tree

 EqualsExpr ::= `=' Expr

def errorPatternTree: Ident

def errorTermTree: Literal

def errorTypeTree: TypeTree

def expectedMsg(token: Int): String

def expr(location: Int): Tree

def expr(): Tree

 Expr       ::= (Bindings | [`implicit'] Id | `_')  `=>' Expr
              | Expr1
 ResultExpr ::= (Bindings | Id `:' CompoundType) `=>' Block
              | Expr1
 Expr1      ::= if `(' Expr `)' {nl} Expr [[semi] else Expr]
              | try (`{' Block `}' | Expr) [catch `{' CaseClauses `}'] [finally Expr]
              | while `(' Expr `)' {nl} Expr
              | do Expr [semi] while `(' Expr `)'
              | for (`(' Enumerators `)' | `{' Enumerators `}') {nl} [yield] Expr
              | throw Expr
              | return [Expr]
              | [SimpleExpr `.'] Id `=' Expr
              | SimpleExpr1 ArgumentExprs `=' Expr
              | PostfixExpr Ascription
              | PostfixExpr match `{' CaseClauses `}'
 Bindings   ::= `(' [Binding {`,' Binding}] `)'
 Binding    ::= (Id | `_') [`:' Type]
 Ascription ::= `:' CompoundType
              | `:' Annotation {Annotation}
              | `:' `_' `*'

def expr0(location: Int): Tree

def exprSimpleType(): Tree

def exprTypeArgs(): List[Tree]

def finalize(): Unit

def funDefOrDcl(start: Int, mods: Modifiers): Tree

 FunDef ::= FunSig `:' Type `=' Expr
          | FunSig [nl] `{' Block `}'
          | this ParamClause ParamClauses (`=' ConstrExpr | [nl] ConstrBlock)
          | `macro' FunSig [`:' Type] `=' Expr
 FunDcl ::= FunSig [`:' Type]
 FunSig ::= id [FunTypeParamClause] ParamClauses

def funDefRest(start: Int, nameOffset: Int, mods: Modifiers, name: Name): Tree

def generator(enums: ListBuffer[Enumerator], eqOK: Boolean): Unit

 Generator ::= Pattern1 (`<-' | `=') Expr [Guard]

final def getClass(): Class[_]

def guard(): Tree

 Guard ::= if PostfixExpr

def hashCode(): Int

def ident(): Name

def ident(skipIt: Boolean): Name

Assumed (provisionally) to be TermNames.

def identForType(skipIt: Boolean): TypeName

def identForType(): TypeName

For when it's known already to be a type name.

def implicitClosure(start: Int, location: Int): Tree

 Expr ::= implicit Id => Expr

def importClause(): List[Tree]

 Import  ::= import ImportExpr {`,' ImportExpr}

def importExpr(): Tree

 ImportExpr ::= StableId `.' (Id | `_' | ImportSelectors)

def importSelector(): ImportSelector

 ImportSelector ::= Id [`=>' Id | `=>' `_']

def importSelectors(): List[ImportSelector]

 ImportSelectors ::= `{' {ImportSelector `,'} (ImportSelector | `_') `}'

final def inBraces[T](body: ⇒ T): T

final def inBracesOrError[T](body: ⇒ T, alt: T): T

final def inBracesOrNil[T](body: ⇒ List[T]): List[T]

final def inBracesOrUnit[T](body: ⇒ Tree): Tree

final def inBrackets[T](body: ⇒ T): T

final def inParens[T](body: ⇒ T): T

Methods inParensOrError and similar take a second argument which, should the next token not be the expected opener (e.

final def inParensOrError[T](body: ⇒ T, alt: T): T

final def inParensOrNil[T](body: ⇒ List[T]): List[T]

final def inParensOrUnit[T](body: ⇒ Tree): Tree

def isDclIntro: Boolean

def isDefIntro: Boolean

def isExprIntro: Boolean

def isExprIntroToken(token: Int): Boolean

def isIdent: Boolean

final def isInstanceOf[T0]: Boolean

def isInterface(mods: Modifiers, body: List[Tree]): Boolean

def isLiteral: Boolean

def isLiteralToken(token: Int): Boolean

def isLocalModifier: Boolean

def isModifier: Boolean

def isNumericLit: Boolean

def isRawBar: Boolean

def isRawStar: Boolean

def isStatSep: Boolean

def isStatSep(token: Int): Boolean

def isStatSeqEnd: Boolean

def isTemplateIntro: Boolean

def isTypeIntro: Boolean

def isTypeIntroToken(token: Int): Boolean

def isUnaryOp: Boolean

def isWildcard(t: Tree): Boolean

def joinComment(trees: ⇒ List[Tree]): List[Tree]

Join the comment associated with a definition.

def literal(isNegated: Boolean = false): Tree

 SimpleExpr    ::= literal
                 | symbol
                 | null

def localDef(implicitMod: Int): List[Tree]

overridable IDE hook for local definitions of blockStatSeq Here's an idea how to fill in start and end positions.

def localModifiers(): Modifiers

 LocalModifiers ::= {LocalModifier}
 LocalModifier  ::= abstract | final | sealed | implicit | lazy

def makeFilter(start: Int, tree: Tree): Filter

def makePackageObject(start: Int, objDef: ModuleDef): PackageDef

Create a tree representing a package object, converting

   package object foo { ... }

   package foo {
     object `package` { ... }
   }

def makePackaging(start: Int, pkg: Tree, stats: List[Tree]): PackageDef

Create a tree representing a packaging.

final def makeParens(body: ⇒ List[Tree]): Parens

Creates an actual Parens node (only used during parsing.

def mixinQualifierOpt(): TypeName

  MixinQualifier ::= `[' Id `]'

def modifiers(): Modifiers

 Modifiers ::= {Modifier}
 Modifier  ::= LocalModifier
             |  AccessModifier
             |  override

def multipleArgumentExprs(): List[List[Tree]]

A succession of argument lists.

final def ne(arg0: AnyRef): Boolean

def newLineOpt(): Unit

def newLineOptWhenFollowedBy(token: Int): Unit

def newLineOptWhenFollowing(p: (Int) ⇒ Boolean): Unit

def newLinesOpt(): Unit

object noSeq extends SeqContextSensitive

The implementation for parsing inside of patterns at points where sequences are disallowed.

def nonLocalDefOrDcl: List[Tree]

final def notify(): Unit

final def notifyAll(): Unit

def objectDef(start: Int, mods: Modifiers): ModuleDef

 ObjectDef       ::= Id ClassTemplateOpt

var opstack: List[OpInfo]

object outPattern extends PatternContextSensitive

The implementation of the context sensitive methods for parsing outside of patterns.

def packaging(start: Int): Tree

 Packaging ::= package QualId [nl] `{' TopStatSeq `}'

def paramClauses(owner: Name, contextBounds: List[Tree], ofCaseClass: Boolean): List[List[ValDef]]

 ParamClauses      ::= {ParamClause} [[nl] `(' implicit Params `)']
 ParamClause       ::= [nl] `(' [Params] `)'
 Params            ::= Param {`,' Param}
 Param             ::= {Annotation} Id [`:' ParamType] [`=' Expr]
 ClassParamClauses ::= {ClassParamClause} [[nl] `(' implicit ClassParams `)']
 ClassParamClause  ::= [nl] `(' [ClassParams] `)'
 ClassParams       ::= ClassParam {`,' ClassParam}
 ClassParam        ::= {Annotation}  [{Modifier} (`val' | `var')] Id [`:' ParamType] [`=' Expr]

def paramType(useStartAsPosition: Boolean): Tree

def paramType(): Tree

 ParamType ::= Type | `=>' Type | Type `*'

def parse(): Tree

This is the general parse entry point.

def patDefOrDcl(pos: Int, mods: Modifiers): List[Tree]

 PatDef ::= Pattern2 {`,' Pattern2} [`:' Type] `=' Expr
 ValDcl ::= Id {`,' Id} `:' Type
 VarDef ::= PatDef | Id {`,' Id} `:' Type `=' `_'

def path(thisOK: Boolean, typeOK: Boolean): Tree

 Path       ::= StableId
             |  [Ident `.'] this
 AnnotType ::= Path [`.' type]

def pattern(): Tree

Default entry points into some pattern contexts.

def patterns(): List[Tree]

var placeholderParams: List[ValDef]

The implicit parameters introduced by _ in the current expression.

def placeholderTypeBoundary(op: ⇒ Tree): Tree

var placeholderTypes: List[TypeDef]

The placeholderTypes introduced by _ in the current type.

def postfixExpr(): Tree

 PostfixExpr   ::= InfixExpr [Id [nl]]
 InfixExpr     ::= PrefixExpr
                 | InfixExpr Id [nl] InfixExpr

def precedence(operator: Name): Int

def prefixExpr(): Tree

 PrefixExpr   ::= [`-' | `+' | `~' | `!' | `&'] SimpleExpr

def qualId(): Tree

  QualId ::= Id {`.' Id}

def rawIdent(): Name

final def readAnnots[T](part: ⇒ T): List[T]

def reduceStack(isExpr: Boolean, base: List[OpInfo], top0: Tree, prec: Int, leftAssoc: Boolean): Tree

def refineStatSeq(): List[Tree]

 RefineStatSeq    ::= RefineStat {semi RefineStat}
 RefineStat       ::= Dcl
                    | type TypeDef
                    |

def refinement(): List[Tree]

 Refinement ::= [nl] `{' RefineStat {semi RefineStat} `}'

def resetPackage(): Unit

def scriptBody(): Tree

This is the parse entry point for code which is not self-contained, e.

def selector(t: Tree): Tree

def selectors(t: Tree, typeOK: Boolean, dotOffset: Int): Tree

def selfInvocation(vparamss: List[List[ValDef]]): Tree

 SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

object seqOK extends SeqContextSensitive

The implementation for parsing inside of patterns at points where sequences are allowed.

def seqPatterns(): List[Tree]

def simpleExpr(): Tree

 SimpleExpr    ::= new (ClassTemplate | TemplateBody)
                 |  BlockExpr
                 |  SimpleExpr1 [`_']
 SimpleExpr1   ::= literal
                 |  xLiteral
                 |  Path
                 |  `(' [Exprs] `)'
                 |  SimpleExpr `.' Id
                 |  SimpleExpr TypeArgs
                 |  SimpleExpr1 ArgumentExprs

def simpleExprRest(t: Tree, canApply: Boolean): Tree

def skip(targetToken: Int): Unit

def stableId(): Tree

 StableId ::= Id
           |  Path `.' Id
           |  [id `.'] super [`[' id `]']`.' id

def startAnnotType(): Tree

def startInfixType(): Tree

def statement(location: Int): Tree

final def synchronized[T0](arg0: ⇒ T0): T0

def syntaxError(offset: Int, msg: String, skipIt: Boolean): Unit

def syntaxError(msg: String, skipIt: Boolean): Unit

def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean): Unit

def template(isTrait: Boolean): (List[Tree], List[List[Tree]], ValDef, List[Tree])

 ClassTemplate ::= [EarlyDefs with] ClassParents [TemplateBody]
 TraitTemplate ::= [EarlyDefs with] TraitParents [TemplateBody]
 EarlyDefs     ::= `{' [EarlyDef {semi EarlyDef}] `}'
 EarlyDef      ::= Annotations Modifiers PatDef

def templateBody(isPre: Boolean): (ValDef, List[Tree])

 TemplateBody ::= [nl] `{' TemplateStatSeq `}'

def templateBodyOpt(traitParentSeen: Boolean): (ValDef, List[Tree])

def templateOpt(mods: Modifiers, name: Name, constrMods: Modifiers, vparamss: List[List[ValDef]], tstart: Int): Template

 ClassTemplateOpt ::= `extends' ClassTemplate | [[`extends'] TemplateBody]
 TraitTemplateOpt ::= TraitExtends TraitTemplate | [[`extends'] TemplateBody] | `<:' TemplateBody
 TraitExtends     ::= `extends' | `<:'

def templateParents(isTrait: Boolean): (List[Tree], List[List[Tree]])

 ClassParents       ::= AnnotType {`(' [Exprs] `)'} {with AnnotType}
 TraitParents       ::= AnnotType {with AnnotType}

def templateStatSeq(isPre: Boolean): (ValDef, List[Tree])

 TemplateStatSeq  ::= [id [`:' Type] `=>'] TemplateStat {semi TemplateStat}
 TemplateStat     ::= Import
                    | Annotations Modifiers Def
                    | Annotations Modifiers Dcl
                    | Expr1
                    | super ArgumentExprs {ArgumentExprs}
                    |

def tmplDef(pos: Int, mods: Modifiers): Tree

 TmplDef ::= [case] class ClassDef
           |  [case] object ObjectDef
           |  [override] trait TraitDef

def toString(): String

final def tokenSeparated[T](separator: Int, sepFirst: Boolean, part: ⇒ T): List[T]

,or if sepFirst is true,

 part { `sep` part } 

 { `sep` part } 

def topLevelTmplDef: Tree

Hook for IDE, for top-level classes/objects.

def topStatSeq(): List[Tree]

 TopStatSeq ::= TopStat {semi TopStat}
 TopStat ::= Annotations Modifiers TmplDef
           | Packaging
           | package object objectDef
           | Import
           |

object treeBuilder extends TreeBuilder

def typ(): Tree

These are default entry points into the pattern context sensitive methods: they are all initiated from non-pattern context.

def typeBounds(): TypeBoundsTree

 TypeBounds ::= [`>:' Type] [`<:' Type]

def typeDefOrDcl(start: Int, mods: Modifiers): Tree

 TypeDef ::= type Id [TypeParamClause] `=' Type
           | `macro' FunSig `=' Expr
 TypeDcl ::= type Id [TypeParamClause] TypeBounds

def typeOrInfixType(location: Int): Tree

def typeParamClauseOpt(owner: Name, contextBoundBuf: ListBuffer[Tree]): List[TypeDef]

 TypeParamClauseOpt    ::= [TypeParamClause]
 TypeParamClause       ::= `[' VariantTypeParam {`,' VariantTypeParam} `]']
 VariantTypeParam      ::= {Annotation} [`+' | `-'] TypeParam
 FunTypeParamClauseOpt ::= [FunTypeParamClause]
 FunTypeParamClause    ::= `[' TypeParam {`,' TypeParam} `]']
 TypeParam             ::= Id TypeParamClauseOpt TypeBounds {<% Type} {":" Type}

def typedOpt(): Tree

 TypedOpt ::= [`:' Type]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def warning(msg: String): Unit

def wildcardOrIdent(): Name

def wildcardType(start: Int): Ident

 WildcardType ::= `_' TypeBounds