AbstractParser

abstract val dialect: Dialect

abstract val in: TokenIterator

abstract val origin: Origin

abstract def parseStartRule: () ⇒ internal.ast.Source

abstract def xmlLiteral(): internal.ast.Term

abstract def xmlLiteralPattern(): internal.ast.Pat

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object InfixMode extends Enumeration

Modes for infix types.

object OpCtx

object OwnedByClass extends TemplateOwner

object OwnedByObject extends TemplateOwner

object OwnedByTrait extends TemplateOwner

def accept[T](implicit arg0: TokenMetadata[T]): Unit

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

def acceptOpt[T](implicit arg0: TokenMetadata[T]): Unit

If current token is T consume it.

def acceptStatSep(): Unit

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

def acceptStatSepOpt(): Unit

def accessModifierOpt(): Option[internal.ast.Mod]

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

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

Scoping operator used to temporarily look into the future.

def annot(): Annot

def annotTypeRest(t: internal.ast.Type): internal.ast.Type

def annots(skipNewLines: Boolean): collection.immutable.List[Annot]

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

def argsToTerm(args: collection.immutable.List[Arg]): internal.ast.Term

def argumentExprs(): collection.immutable.List[Arg]

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

def argumentExprsOrPrefixExpr(): collection.immutable.List[Arg]

def argumentPatterns(): collection.immutable.List[Arg]

final def asInstanceOf[T0]: T0

def assignmentToMaybeNamedArg(tree: internal.ast.Term): Arg

Translates an Assign(_, _) node to AssignOrNamedArg(_, _) if the lhs is a simple ident.

def block(): internal.ast.Term

Block ::= BlockStatSeq

def blockExpr(): internal.ast.Term

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

def blockStatSeq(): collection.immutable.List[internal.ast.Stat]

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

def bound[T](implicit arg0: TokenMetadata[T]): Option[internal.ast.Type]

def caseClause(): internal.ast.Case

def caseClauses(): collection.immutable.List[internal.ast.Case]

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

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

def checkAssoc(op: internal.ast.Name, leftAssoc: Boolean): Unit

def checkHeadAssoc[T](leftAssoc: Boolean)(implicit arg0: OpCtx[T]): Unit

def classDef(mods: collection.immutable.List[internal.ast.Mod]): Class

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

def clone(): AnyRef

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

def compilationUnit(): internal.ast.Source

CompilationUnit ::= {package QualId semi} TopStatSeq

def condExpr(): internal.ast.Term

def constrBlock(): (collection.immutable.List[collection.immutable.List[Arg]], collection.immutable.List[internal.ast.Stat])

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

def constrExpr(): (collection.immutable.List[collection.immutable.List[Arg]], collection.immutable.List[internal.ast.Stat])

ConstrExpr      ::=  SelfInvocation
                  |  ConstrBlock

def constructorAnnots(): collection.immutable.List[Annot]

def convertToParam(tree: internal.ast.Term): Option[Param]

Convert tree to formal parameter.

def convertToParams(tree: internal.ast.Term): collection.immutable.List[Param]

Convert tree to formal parameter list.

def convertToTypeId(ref: internal.ast.Term.Ref): Option[internal.ast.Type]

def defOrDclOrCtor(mods: collection.immutable.List[internal.ast.Mod]): internal.ast.Stat

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

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

def ensureEarlyDef(tree: internal.ast.Stat): internal.ast.Stat

def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[internal.ast.Enum]

def enumerators(): collection.immutable.List[internal.ast.Enum]

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def existentialStats(): collection.immutable.List[internal.ast.Stat]

def expr(location: Location): internal.ast.Term

def expr(): internal.ast.Term

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 exprSimpleType(): internal.ast.Type

def exprTypeArgs(): collection.immutable.List[internal.ast.Type]

def finalize(): Unit

def finishBinaryOp[T](opinfo: OpInfo[T], rhs: T)(implicit arg0: OpCtx[T]): T

def finishPostfixOp(base: collection.immutable.List[OpInfo[collection.immutable.List[Arg]]], opinfo: OpInfo[collection.immutable.List[Arg]]): collection.immutable.List[Arg]

def funDefOrDclOrCtor(mods: collection.immutable.List[internal.ast.Mod]): internal.ast.Stat

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

def funDefRest(mods: collection.immutable.List[internal.ast.Mod], name: internal.ast.Term.Name): internal.ast.Stat

def generator(eqOK: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[internal.ast.Enum]

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

final def getClass(): Class[_]

def guard(): Option[internal.ast.Term]

Guard ::= if PostfixExpr

def hashCode(): Int

def implicitClosure(location: Location): internal.ast.Term.Function

Expr ::= implicit Id => Expr

def importClause(): Clause

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

def importSelector(): internal.ast.Selector

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

def importSelectors(): collection.immutable.List[internal.ast.Selector]

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

def importStmt(): Import

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

def importWildcardOrName(): internal.ast.Selector

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

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

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

final def inBracesOrUnit[T](body: ⇒ internal.ast.Term): internal.ast.Term

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

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

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

final def inParensOrUnit[T, Ret >: Lit](body: ⇒ Ret): Ret

def interpolate[Ctx, Ret](arg: () ⇒ Ctx, result: (internal.ast.Term.Name, collection.immutable.List[String], collection.immutable.List[Ctx]) ⇒ Ret): Ret

def interpolatePat(): Interpolate

def interpolateTerm(): Interpolate

def isIdentAnd(pred: (String) ⇒ Boolean): Boolean

def isIdentExcept(except: String): Boolean

def isIdentOf(name: String): Boolean

final def isInstanceOf[T0]: Boolean

def isRawBar: Boolean

def isRawStar: Boolean

def isUnaryOp: Boolean

def literal(isNegated: Boolean = false): Lit

SimpleExpr    ::= literal
                | symbol
                | null

def localDef(implicitMod: Option[Implicit]): internal.ast.Stat

def localModifiers(): collection.immutable.List[internal.ast.Mod]

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

def makeTuple[T <: internal.ast.Tree](body: collection.immutable.List[T], zero: () ⇒ T, tuple: (collection.immutable.List[T]) ⇒ T): T

def makeTuplePatParens(bodyf: ⇒ collection.immutable.List[Arg]): internal.ast.Pat

def makeTupleTerm(body: collection.immutable.List[internal.ast.Term]): internal.ast.Term

def makeTupleTermParens(bodyf: ⇒ collection.immutable.List[internal.ast.Term]): internal.ast.Term

def makeTupleType(body: collection.immutable.List[internal.ast.Type]): internal.ast.Type

def mixinQualifierOpt(): Option[String]

MixinQualifier ::= `[' Id `]'

def mkBlock(stats: collection.immutable.List[internal.ast.Stat]): internal.ast.Term

def modifiers(isLocal: Boolean = false): collection.immutable.List[internal.ast.Mod]

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

def multipleArgumentExprs(): collection.immutable.List[collection.immutable.List[Arg]]

A succession of argument lists.

def name[T](ctor: (String, Boolean) ⇒ T, advance: Boolean): T

final def ne(arg0: AnyRef): Boolean

def newLineOpt(): Unit

def newLineOptWhenFollowedBy[T](implicit arg0: TokenMetadata[T]): Unit

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

def newLinesOpt(): Unit

def next(): Token

object noSeq extends SeqContextSensitive

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

def nonLocalDefOrDcl: internal.ast.Stat

final def notify(): Unit

final def notifyAll(): Unit

def objectDef(mods: collection.immutable.List[internal.ast.Mod]): Object

ObjectDef       ::= Id ClassTemplateOpt

def opctx[T](implicit ctx: OpCtx[T]): OpCtx[T]

object outPattern extends PatternContextSensitive

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

def packageObject(): Object

def packageOrPackageObject(): internal.ast.Stat

def param(ownerIsCase: Boolean, ownerIsType: Boolean, isImplicit: Boolean): Param

def paramClauses(ownerIsType: Boolean, ownerIsCase: Boolean = false): collection.immutable.List[collection.immutable.List[Param]]

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(): Arg

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

def parseCase(): internal.ast.Case

def parseCtorRef(): internal.ast.Ctor.Ref

def parseEnum(): internal.ast.Enum

def parseMod(): internal.ast.Mod

def parseParam(): Param

These are alternative entry points for quasiquotes.

def parsePat(): Arg

def parseRule[T](rule: (AbstractParser.this.type) ⇒ T): T

def parseSelector(): internal.ast.Selector

def parseSource(): internal.ast.Source

This is the general parse entry point.

def parseStat(): internal.ast.Stat

This is the alternative entry point for repl, script runner, toolbox and parsing in macros.

def parseStats(): collection.immutable.List[internal.ast.Stat]

def parseTempl(): internal.ast.Templ

def parseTerm(): internal.ast.Term

These are alternative entry points for quasiquotes.

def parseTermArg(): Arg

def parseTparam(): Param

def parseType(): Arg

def patDefOrDcl(mods: collection.immutable.List[internal.ast.Mod]): internal.ast.Stat

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

def path(thisOK: Boolean = true): internal.ast.Term.Ref

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

def pattern(): Arg

Default entry points into some pattern contexts.

def peekingAhead[T](tree: ⇒ T): T

Perform an operation while peeking ahead.

def postfixExpr(): internal.ast.Term

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

def prefixExpr(): internal.ast.Term

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

def primaryCtor(ownerIsCase: Boolean): Primary

def qualId(): internal.ast.Term.Ref

QualId ::= Id {`.' Id}

def readAnnots(part: ⇒ Annot): collection.immutable.List[Annot]

def reduceStack[T](base: collection.immutable.List[OpInfo[T]], top: T, opPrecedence: Int, leftAssoc: Boolean)(implicit arg0: OpCtx[T]): T

def reduceStack[T](base: collection.immutable.List[OpInfo[T]], top: T)(implicit arg0: OpCtx[T]): T

def refineStat(): Option[internal.ast.Stat]

def refineStatSeq(): collection.immutable.List[internal.ast.Stat]

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

def refinement(): collection.immutable.List[internal.ast.Stat]

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

val reporter: Reporter

def selector(t: internal.ast.Term): Select

def selectors(t: internal.ast.Term.Ref): internal.ast.Term.Ref

def selfInvocation(): collection.immutable.List[collection.immutable.List[Arg]]

SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

object seqOK extends SeqContextSensitive

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

def seqPatterns(): collection.immutable.List[Arg]

def simpleExpr(): internal.ast.Term

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

def simpleExprRest(t: internal.ast.Term, canApply: Boolean): internal.ast.Term

def stableId(): internal.ast.Term.Ref

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

def startInfixType(): internal.ast.Type

def startModType(): internal.ast.Type

def statSeq[T <: internal.ast.Tree](statpf: PartialFunction[Token, T], errorMsg: String = "illegal start of definition"): collection.immutable.List[T]

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

def syntaxErrorExpected[T](implicit arg0: TokenMetadata[T]): Nothing

def template(): (collection.immutable.List[internal.ast.Stat], collection.immutable.List[internal.ast.Ctor.Ref], Param, collection.immutable.List[internal.ast.Stat], Boolean)

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

def templateBody(isPre: Boolean): (Param, collection.immutable.List[internal.ast.Stat])

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

def templateBodyOpt(parenMeansSyntaxError: Boolean): (Param, collection.immutable.List[internal.ast.Stat], Boolean)

def templateOpt(owner: TemplateOwner): internal.ast.Templ

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

def templateParents(): collection.immutable.List[internal.ast.Ctor.Ref]

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

def templateStat: PartialFunction[Token, internal.ast.Stat]

def templateStatSeq(isPre: Boolean): (Param, collection.immutable.List[internal.ast.Stat])

TemplateStatSeq  ::= [id [`:' Type] `=>'] TemplateStats

def templateStats(): collection.immutable.List[internal.ast.Stat]

TemplateStats    ::= TemplateStat {semi TemplateStat}
TemplateStat     ::= Import
                   | Annotations Modifiers Def
                   | Annotations Modifiers Dcl
                   | Expr1
                   | super ArgumentExprs {ArgumentExprs}
                   |

def termName(advance: Boolean = true): internal.ast.Term.Name

def tmplDef(mods: collection.immutable.List[internal.ast.Mod]): internal.ast.Member with internal.ast.Stat

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

def toString(): String

def token: Token

final def tokenSeparated[Sep, T](sepFirst: Boolean, part: ⇒ T)(implicit arg0: TokenMetadata[Sep]): collection.immutable.List[T]

,or if sepFirst is true,

part { `sep` part }

{ `sep` part }

def topLevelTmplDef: internal.ast.Member with internal.ast.Stat

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

def topStat: PartialFunction[Token, internal.ast.Stat]

def topStatSeq(): collection.immutable.List[internal.ast.Stat]

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

def traitDef(mods: collection.immutable.List[internal.ast.Mod]): Trait

TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

def typ(): internal.ast.Type

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

def typeBounds(): Bounds

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

def typeDefOrDcl(mods: collection.immutable.List[internal.ast.Mod]): internal.ast.Member.Type with internal.ast.Stat

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

def typeName(advance: Boolean = true): internal.ast.Type.Name

def typeOrInfixType(location: Location): internal.ast.Type

def typeParam(annots: collection.immutable.List[Annot], ownerIsType: Boolean, ctxBoundsAllowed: Boolean): Param

def typeParamClauseOpt(ownerIsType: Boolean, ctxBoundsAllowed: Boolean): collection.immutable.List[Param]

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

def typedOpt(): Option[internal.ast.Type]

TypedOpt ::= [`:' Type]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wildcardType(): internal.ast.Type

WildcardType ::= `_' TypeBounds

object xmlSeqOK extends SeqContextSensitive

For use from xml pattern, where sequence is allowed and encouraged.

def xmlSeqPatterns(): collection.immutable.List[Arg]