Parser

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

def freshName (prefix: String): Name

def freshTermName (prefix: String): TermName

def freshTypeName (prefix: String): TypeName

val in : Scanner

def incompleteInputError (msg: String): Unit

def o2p (offset: Int): Position

def parseStartRule : () ⇒ Tree

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

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

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

def xmlLiteral (): Tree

def xmlLiteralPattern (): Tree

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

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]

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

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

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

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 .

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) FunDcl ::= FunSig [:' Type] FunSig ::= id [FunTypeParamClause] ParamClauses

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

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

def getClass (): java.lang.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 | _') }'

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

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

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

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

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

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.

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

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

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

def isDclIntro : Boolean

def isDefIntro : Boolean

def isExprIntro : Boolean

def isExprIntroToken (token: Int): Boolean

def isIdent : Boolean

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): 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 { .

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

Create a tree representing a packaging

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.

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]

def notify (): Unit

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]

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 [.

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. Parameters appear in reverse order

def placeholderTypeBoundary (op: ⇒ Tree): Tree

var placeholderTypes : List[TypeDef]

The placeholderTypes introduced by _' in the current type. Parameters appear in reverse order

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 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

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

def skip (targetToken: Int): Unit

def stableId (): Tree

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

def startAnnotType (): Tree

def startInfixType (): Tree

def statement (location: Int): Tree

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']

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

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

part { sep part } Or if sepFirst is true, { 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 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]

def wait (): Unit

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

def wait (arg0: Long): Unit

def warning (msg: String): Unit

def wildcardOrIdent (): Name

def wildcardType (start: Int): Ident

WildcardType ::= _' TypeBounds