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

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

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]

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]

final 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

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

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]

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

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

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]

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