Parser

class Parser(source: SourceFile)(using x$2: Context) extends ParserCommon
class Object
trait Matchable
class Any

Type members

Classlikes

Value members

Concrete methods

def accept(token: Int): Int

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

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

Returns:

The offset at the start of the token to accept

def accept(name: Name): Int

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

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

AccessQualifier ::= "[" (id | this) "]"

AccessQualifier ::= "[" (id | this) "]"

def addFlag(mods: Modifiers, flag: FlagSet): Modifiers
def addMod(mods: Modifiers, mod: Mod): Modifiers

Always add the syntactic mod, but check and conditionally add semantic mod.flags

Always add the syntactic mod, but check and conditionally add semantic mod.flags

def adjustStart(start: Offset)(tree: Tree): Tree

Adjust start of annotation or constructor to offset of preceding @ or new

Adjust start of annotation or constructor to offset of preceding @ or new

def annot(): Tree

Annotation ::= `@' SimpleType1 {ParArgumentExprs}

Annotation ::= `@' SimpleType1 {ParArgumentExprs}

AnnotType ::= SimpleType {Annotation}

AnnotType ::= SimpleType {Annotation}

def annotations(skipNewLines: Boolean): List[Tree]
def annotsAsMods(skipNewLines: Boolean): Modifiers
def applyToClosure(t: Tree, start: Offset, params: List[ValDef]): Tree
def argTypes(namedOK: Boolean, wildOK: Boolean): List[Tree]

ArgTypes ::= Type {,' Type} | NamedTypeArg {,' NamedTypeArg} NamedTypeArg ::= id `=' Type

ArgTypes ::= Type {,' Type} | NamedTypeArg {,' NamedTypeArg} NamedTypeArg ::= id `=' Type

ArgumentExprs ::= ParArgumentExprs | [nl] BlockExpr

ArgumentExprs ::= ParArgumentExprs | [nl] BlockExpr

ArgumentExprss ::= {ArgumentExprs}

ArgumentExprss ::= {ArgumentExprs}

ArgumentPatterns ::= ‘(’ [Patterns] ‘)’ | ‘(’ [Patterns ‘,’] PatVar ‘*’ ‘)’

ArgumentPatterns ::= ‘(’ [Patterns] ‘)’ | ‘(’ [Patterns ‘,’] PatVar ‘*’ ‘)’

def ascription(t: Tree, location: Location): Tree
def binding(mods: Modifiers): Tree

Binding ::= (id | _') [:' Type]

Binding ::= (id | _') [:' Type]

def block(simplify: Boolean): Tree

Block ::= BlockStatSeq

Block ::= BlockStatSeq

Note:

Return tree does not have a defined span.

BlockExpr ::= <<< (CaseClauses | Block) >>>

BlockExpr ::= <<< (CaseClauses | Block) >>>

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

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

def bracesToIndented[T](body: => T, rewriteWithColon: Boolean): T

Parse brace-enclosed body and rewrite it to be an indentation region instead, if possible. If possible means:

Parse brace-enclosed body and rewrite it to be an indentation region instead, if possible. If possible means:

  1. not inside (...), [...], case ... =>
  2. opening brace { is at end of line
  3. closing brace } is at start of line
  4. there is at least one token between the braces
  5. the closing brace is also at the end of the line, or it is followed by one of then, else, do, catch, finally, yield, or match.
  6. the opening brace does not follow a =>. The reason for this condition is that rewriting back to braces does not work after => (since in most cases braces are omitted after a => it would be annoying if braces were inserted).
def caseClause(exprOnly: Boolean): CaseDef

CaseClause ::= ‘case’ Pattern [Guard] `=>' Block ExprCaseClause ::= ‘case’ Pattern [Guard] ‘=>’ Expr

CaseClause ::= ‘case’ Pattern [Guard] `=>' Block ExprCaseClause ::= ‘case’ Pattern [Guard] ‘=>’ Expr

def caseClauses(clause: () => CaseDef): List[CaseDef]

CaseClauses ::= CaseClause {CaseClause} TypeCaseClauses ::= TypeCaseClause {TypeCaseClause}

CaseClauses ::= CaseClause {CaseClause} TypeCaseClauses ::= TypeCaseClause {TypeCaseClause}

[`extends' ConstrApps]

[`extends' ConstrApps]

def checkAssoc(offset: Token, op1: Name, op2: Name, op2LeftAssoc: Boolean): Unit
def checkEndMarker[T <: Tree](stats: ListBuffer[T]): Unit
def checkExtensionMethod(tparams: List[Tree], vparamss: List[List[Tree]], stat: Tree): Unit

Check that this is not the start of a statement that's indented relative to the current region.

Check that this is not the start of a statement that's indented relative to the current region.

def checkNoEscapingPlaceholders[T](op: => T): T
def classConstr(isCaseClass: Boolean): DefDef

ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsParamClauses

ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsParamClauses

def classDef(start: Offset, mods: Modifiers): TypeDef

ClassDef ::= id ClassConstr TemplateOpt

ClassDef ::= id ClassConstr TemplateOpt

def classDefRest(start: Offset, mods: Modifiers, name: TypeName): TypeDef

The region to eliminate when replacing a closing ) or } that starts a new line The ) or } precedes in.lastOffset.

The region to eliminate when replacing a closing ) or } that starts a new line The ) or } precedes in.lastOffset.

def closure(start: Int, location: Location, implicitMods: Modifiers): Tree

Expr ::= [‘implicit’] FunParams =>' Expr BlockResult ::= implicit id [:' InfixType] `=>' Block // Scala2 only

Expr ::= [‘implicit’] FunParams =>' Expr BlockResult ::= implicit id [:' InfixType] `=>' Block // Scala2 only

def closureRest(start: Int, location: Location, params: List[Tree]): Tree
def commaSeparated[T](part: () => T): List[T]

{, }

{, }

def commaSeparatedRest[T](leading: T, part: () => T): List[T]

{, }

{, }

currentRegion.commasExpected has to be set separately.

CompilationUnit ::= {package QualId semi} TopStatSeq

CompilationUnit ::= {package QualId semi} TopStatSeq

def condExpr(altToken: Token): Tree
def constrApps(exclude: Token): List[Tree]

ConstrApps ::= ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})

ConstrApps ::= ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})

ConstrMods ::= {Annotation} [AccessModifier]

ConstrMods ::= {Annotation} [AccessModifier]

def contextTypes(ofClass: Boolean, nparams: Int, impliedMods: Modifiers): List[ValDef]

ContextTypes ::= FunArgType {‘,’ FunArgType}

ContextTypes ::= FunArgType {‘,’ FunArgType}

def convertToParam(tree: Tree, mods: Modifiers, expected: String): ValDef

Convert tree to formal parameter

Convert tree to formal parameter

Convert tree to formal parameter list

Convert tree to formal parameter list

Convert (qual)ident to type identifier

Convert (qual)ident to type identifier

def defDefOrDcl(start: Offset, mods: Modifiers, numLeadParams: Int): DefDef

DefDef ::= DefSig [‘:’ Type] ‘=’ Expr | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id [DefTypeParamClause] DefParamClauses | ExtParamClause [nl] [‘.’] id DefParamClauses

DefDef ::= DefSig [‘:’ Type] ‘=’ Expr | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id [DefTypeParamClause] DefParamClauses | ExtParamClause [nl] [‘.’] id DefParamClauses

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

Def ::= val PatDef | var VarDef | def DefDef | type {nl} TypeDcl | TmplDef Dcl ::= val ValDcl | var ValDcl | def DefDcl | type {nl} TypeDcl EnumCase ::= case' (id ClassConstr [extends' ConstrApps]] | ids)

Def ::= val PatDef | var VarDef | def DefDef | type {nl} TypeDcl | TmplDef Dcl ::= val ValDcl | var ValDcl | def DefDcl | type {nl} TypeDcl EnumCase ::= case' (id ClassConstr [extends' ConstrApps]] | ids)

def deprecationWarning(msg: Message, offset: Int): Unit

DotSelectors ::= { `.' id }

DotSelectors ::= { `.' id }

def dropParensOrBraces(start: Offset, endStr: String): Unit

Drop (...) or { ... }, replacing the closing element with endStr

Drop (...) or { ... }, replacing the closing element with endStr

Drop current token, if it is a then or do.

Drop current token, if it is a then or do.

def enclosed[T](tok: Token, body: => T): T
def enumCase(start: Offset, mods: Modifiers): DefTree

EnumCase = case' (id ClassConstr [extends' ConstrApps] | ids)

EnumCase = case' (id ClassConstr [extends' ConstrApps] | ids)

def enumDef(start: Offset, mods: Modifiers): TypeDef

EnumDef ::= id ClassConstr InheritClauses EnumBody

EnumDef ::= id ClassConstr InheritClauses EnumBody

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

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

Enumerators ::= Generator {semi Enumerator | Guard}

Enumerators ::= Generator {semi Enumerator | Guard}

def expr(location: Location): Tree
def expr1(location: Location): Tree
def expr1Rest(t: Tree, location: Location): Tree

ExprsInParens ::= ExprInParens {`,' ExprInParens}

ExprsInParens ::= ExprInParens {`,' ExprInParens}

def extMethod(numLeadParams: Int): DefDef

ExtMethod ::= {Annotation [nl]} {Modifier} ‘def’ DefDef

ExtMethod ::= {Annotation [nl]} {Modifier} ‘def’ DefDef

def extMethods(numLeadParams: Int): List[DefDef]

ExtMethods ::= ExtMethod | [nl] ‘{’ ExtMethod {semi ExtMethod ‘}’

ExtMethods ::= ExtMethod | [nl] ‘{’ ExtMethod {semi ExtMethod ‘}’

Extension ::= ‘extension’ [DefTypeParamClause] {UsingParamClause} ‘(’ DefParam ‘)’ {UsingParamClause} ExtMethods

Extension ::= ‘extension’ [DefTypeParamClause] {UsingParamClause} ‘(’ DefParam ‘)’ {UsingParamClause} ExtMethods

The position of the first XML literal encountered while parsing, NoSourcePosition if there were no XML literals.

The position of the first XML literal encountered while parsing, NoSourcePosition if there were no XML literals.

In the tokens following the current one, does query precede any of the tokens that

In the tokens following the current one, does query precede any of the tokens that

  • must start a statement, or
  • separate two statements, or
  • continue a statement (e.g. else, catch`), or
  • terminate the current scope?

Is the following sequence the generators of a for-expression enclosed in (...)?

Is the following sequence the generators of a for-expression enclosed in (...)?

Are the next token the "GivenSig" part of a given definition, i.e. an identifier followed by type and value parameters, followed by :?

Are the next token the "GivenSig" part of a given definition, i.e. an identifier followed by type and value parameters, followed by :?

Is current ident a *, and is it followed by a ), , ), ,EOF? The latter two are not syntactically valid, but we need to include them here for error recovery.

Is current ident a *, and is it followed by a ), , ), ,EOF? The latter two are not syntactically valid, but we need to include them here for error recovery.

def forExpr(): Tree

ForExpr ::= ‘for’ ‘(’ Enumerators ‘)’ {nl} [‘do‘ | ‘yield’] Expr | ‘for’ ‘{’ Enumerators ‘}’ {nl} [‘do‘ | ‘yield’] Expr | ‘for’ Enumerators (‘do‘ | ‘yield’) Expr

ForExpr ::= ‘for’ ‘(’ Enumerators ‘)’ {nl} [‘do‘ | ‘yield’] Expr | ‘for’ ‘{’ Enumerators ‘}’ {nl} [‘do‘ | ‘yield’] Expr | ‘for’ Enumerators (‘do‘ | ‘yield’) Expr

FunParamClause ::= ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’

FunParamClause ::= ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’

def funParams(mods: Modifiers, location: Location): List[Tree]

FunParams ::= Bindings | id | _' Bindings ::=(' [[‘erased’] Binding {,' Binding}])'

FunParams ::= Bindings | id | _' Bindings ::=(' [[‘erased’] Binding {,' Binding}])'

Generator ::= [‘case’] Pattern `<-' Expr

Generator ::= [‘case’] Pattern `<-' Expr

def generatorRest(pat: Tree, casePat: Boolean): GenFrom
def givenDef(start: Offset, mods: Modifiers, givenMod: Mod): MemberDef[Untyped]

GivenDef ::= [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance) GivenSig ::= [id] [DefTypeParamClause] {UsingParamClauses} ‘:’

GivenDef ::= [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance) GivenSig ::= [id] [DefTypeParamClause] {UsingParamClauses} ‘:’

def guard(): Tree

Guard ::= if PostfixExpr

Guard ::= if PostfixExpr

Accept identifier and return its name as a term name.

Accept identifier and return its name as a term name.

def ifExpr(start: Offset, mkIf: (Tree, Tree, Tree) => If): If

if'(' Expr )' {nl} Expr [[semi] else Expr]if' Expr `then' Expr [[semi] else Expr]

if'(' Expr )' {nl} Expr [[semi] else Expr]if' Expr `then' Expr [[semi] else Expr]

def importClause(leading: Token, mkTree: ImportConstr): List[Tree]

Import ::= import' ImportExpr {‘,’ ImportExpr} Export ::=export' ImportExpr {‘,’ ImportExpr}

Import ::= import' ImportExpr {‘,’ ImportExpr} Export ::=export' ImportExpr {‘,’ ImportExpr}

def importExpr(mkTree: ImportConstr): () => Tree

ImportExpr ::= SimpleRef {‘.’ id} ‘.’ ImportSpec | SimpleRef ‘as’ id ImportSpec ::= NamedSelector | WildcardSelector | ‘{’ ImportSelectors ‘}’ ImportSelectors ::= NamedSelector [‘,’ ImportSelectors] | WildCardSelector {‘,’ WildCardSelector} NamedSelector ::= id [‘as’ (id | ‘_’)] WildCardSelector ::= ‘*' | ‘given’ [InfixType]

ImportExpr ::= SimpleRef {‘.’ id} ‘.’ ImportSpec | SimpleRef ‘as’ id ImportSpec ::= NamedSelector | WildcardSelector | ‘{’ ImportSelectors ‘}’ ImportSelectors ::= NamedSelector [‘,’ ImportSelectors] | WildCardSelector {‘,’ WildCardSelector} NamedSelector ::= id [‘as’ (id | ‘_’)] WildCardSelector ::= ‘*' | ‘given’ [InfixType]

def inBraces[T](body: => T): T
def inBracesOrIndented[T](body: => T, rewriteWithColon: Boolean): T
def inBrackets[T](body: => T): T
def inDefScopeBraces[T](body: => T, rewriteWithColon: Boolean): T
def inParens[T](body: => T): T
def inSepRegion[T](f: Region => Region)(op: => T): T

Issue an error at current offset that input is incomplete

Issue an error at current offset that input is incomplete

def indentedToBraces[T](body: => T): T

Parse indentation region body and rewrite it to be in braces instead

Parse indentation region body and rewrite it to be in braces instead

def infixOps(first: Tree, canStartOperand: Token => Boolean, operand: Location => Tree, location: Location, kind: ParseKind, isOperator: => Boolean): Tree

operand { infixop operand | MatchClause } [postfixop],

operand { infixop operand | MatchClause } [postfixop],

respecting rules of associativity and precedence.

Value parameters:
isOperator

the current token counts as an operator.

maybePostfix

postfix operators are allowed.

InfixPattern ::= SimplePattern {id [nl] SimplePattern}

InfixPattern ::= SimplePattern {id [nl] SimplePattern}

InfixType ::= RefinedType {id [nl] RefinedType}

InfixType ::= RefinedType {id [nl] RefinedType}

def isDefIntro(allowedMods: BitSet, excludedSoftModifiers: Set[TermName]): Boolean
def isIdent(name: Name): Boolean
def isLeqIndented(offset1: Int, offset2: Int): Boolean

Is offset1 less or equally indented than offset2? This is the case if the characters between the preceding end-of-line and offset1 are a prefix of the characters between the preceding end-of-line and offset2.

Is offset1 less or equally indented than offset2? This is the case if the characters between the preceding end-of-line and offset1 are a prefix of the characters between the preceding end-of-line and offset2.

Is current token a hard or soft modifier (in modifier position or not)?

Is current token a hard or soft modifier (in modifier position or not)?

A '$' identifier is treated as a splice if followed by a {. A longer identifier starting with $ is treated as a splice/id combination in a quoted block '{...'

A '$' identifier is treated as a splice if followed by a {. A longer identifier starting with $ is treated as a splice/id combination in a quoted block '{...'

def literal(negOffset: Int, inPattern: Boolean, inTypeOrSingleton: Boolean, inStringInterpolation: Boolean): Tree

Literal ::= SimpleLiteral | processedStringLiteral | symbolLiteral | ‘null’

Literal ::= SimpleLiteral | processedStringLiteral | symbolLiteral | ‘null’

Value parameters:
negOffset

The offset of a preceding `-' sign, if any. If the literal is not negated, negOffset == in.offset.

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

Create a tree representing a packaging

Create a tree representing a packaging

MatchClause ::= match'{' CaseClauses `}'

MatchClause ::= match'{' CaseClauses `}'

match'{' TypeCaseClauses `}'

match'{' TypeCaseClauses `}'

MixinQualifier ::= [' id]'

MixinQualifier ::= [' id]'

def mkApply(fn: Tree, args: (List[Tree], Boolean)): Tree
def mkImport(outermost: Boolean): ImportConstr

Create an import node and handle source version imports

Create an import node and handle source version imports

def modifiers(allowed: BitSet, start: Modifiers): Modifiers

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier ::= LocalModifier | AccessModifier | override | opaque LocalModifier ::= abstract | final | sealed | open | implicit | lazy | erased | inline | transparent

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier ::= LocalModifier | AccessModifier | override | opaque LocalModifier ::= abstract | final | sealed | open | implicit | lazy | erased | inline | transparent

def newExpr(): Tree

SimpleExpr ::= ‘new’ ConstrApp {with ConstrApp} [TemplateBody] | ‘new’ TemplateBody

SimpleExpr ::= ‘new’ ConstrApp {with ConstrApp} [TemplateBody] | ‘new’ TemplateBody

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

ObjectDef ::= id TemplateOpt

ObjectDef ::= id TemplateOpt

def packaging(start: Int): Tree

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

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

ParArgumentExprs ::= (' [‘using’] [ExprsInParens])' | (' [ExprsInParens,'] PostfixExpr `*' ')'

ParArgumentExprs ::= (' [‘using’] [ExprsInParens])' | (' [ExprsInParens,'] PostfixExpr `*' ')'

ParArgumentExprss ::= {ParArgumentExprs}

ParArgumentExprss ::= {ParArgumentExprs}

Special treatment for arguments to primary constructor annotations. (...) is considered an argument only if it does not look like a formal parameter list, i.e. does not start with ( <annot>* <mod>* ident : Furthermore, () is considered a annotation argument only if it comes first.

def paramClause(nparams: Int, ofClass: Boolean, ofCaseClass: Boolean, prefix: Boolean, givenOnly: Boolean, firstClause: Boolean): List[ValDef]

ClsParamClause ::= ‘(’ [‘erased’] ClsParams ‘)’ | UsingClsParamClause UsingClsParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’ ClsParams ::= ClsParam {‘,’ ClsParam} ClsParam ::= {Annotation}

ClsParamClause ::= ‘(’ [‘erased’] ClsParams ‘)’ | UsingClsParamClause UsingClsParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’ ClsParams ::= ClsParam {‘,’ ClsParam} ClsParam ::= {Annotation}

DefParamClause ::= ‘(’ [‘erased’] DefParams ‘)’ | UsingParamClause UsingParamClause ::= ‘(’ ‘using’ [‘erased’] (DefParams | ContextTypes) ‘)’ DefParams ::= DefParam {‘,’ DefParam} DefParam ::= {Annotation} [‘inline’] Param

Param ::= id :' ParamType [=' Expr]

Returns:

the list of parameter definitions

def paramClauses(ofClass: Boolean, ofCaseClass: Boolean, givenOnly: Boolean, numLeadParams: Int): List[List[ValDef]]

ClsParamClauses ::= {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’] DefParamClauses ::= {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]

ClsParamClauses ::= {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’] DefParamClauses ::= {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]

Returns:

The parameter definitions

ParamType ::= [`=>'] ParamValueType

ParamType ::= [`=>'] ParamValueType

ParamValueType ::= Type [`*']

ParamValueType ::= Type [`*']

def parse(): Tree

This is the general parse entry point. Overridden by ScriptParser

This is the general parse entry point. Overridden by ScriptParser

def patDefOrDcl(start: Offset, mods: Modifiers): Tree

PatDef ::= ids [‘:’ Type] ‘=’ Expr | Pattern2 [‘:’ Type] ‘=’ Expr VarDef ::= PatDef | id {,' id}:' Type ='_' (deprecated in 3.x) ValDcl ::= id {,' id}:' Type VarDcl ::= id {,' id}:' Type

PatDef ::= ids [‘:’ Type] ‘=’ Expr | Pattern2 [‘:’ Type] ‘=’ Expr VarDef ::= PatDef | id {,' id}:' Type ='_' (deprecated in 3.x) ValDcl ::= id {,' id}:' Type VarDcl ::= id {,' id}:' Type

def pattern(location: Location): Tree

Pattern ::= Pattern1 { `|' Pattern1 }

Pattern ::= Pattern1 { `|' Pattern1 }

def pattern1(location: Location): Tree

Pattern1 ::= Pattern2 [Ascription]

Pattern1 ::= Pattern2 [Ascription]

def pattern3(): Tree

Pattern3 ::= InfixPattern | PatVar ‘*’

Pattern3 ::= InfixPattern | PatVar ‘*’

def patternAlts(location: Location): List[Tree]
def patterns(location: Location): List[Tree]

Patterns ::= Pattern [`,' Pattern]

Patterns ::= Pattern [`,' Pattern]

def patternsOpt(location: Location): List[Tree]
def postfixExpr(location: Location): Tree

PostfixExpr ::= InfixExpr [id [nl]] InfixExpr ::= PrefixExpr | InfixExpr id [nl] InfixExpr | InfixExpr id : IndentedExpr | InfixExpr MatchClause

PostfixExpr ::= InfixExpr [id [nl]] InfixExpr ::= PrefixExpr | InfixExpr id [nl] InfixExpr | InfixExpr id : IndentedExpr | InfixExpr MatchClause

def postfixExprRest(t: Tree, location: Location): Tree
def qualId(): Tree

QualId ::= id {`.' id}

QualId ::= id {`.' id}

def reduceStack(base: List[OpInfo], top: Tree, prec: Int, leftAssoc: Boolean, op2: Name, isType: Boolean): Tree

RefineStatSeq ::= RefineStat {semi RefineStat} RefineStat ::= ‘val’ VarDcl | ‘def’ DefDcl | ‘type’ {nl} TypeDcl (in reality we admit Defs and vars and filter them out afterwards in checkLegal)

RefineStatSeq ::= RefineStat {semi RefineStat} RefineStat ::= ‘val’ VarDcl | ‘def’ DefDcl | ‘type’ {nl} TypeDcl (in reality we admit Defs and vars and filter them out afterwards in checkLegal)

def refinement(indentOK: Boolean): List[Tree]

Refinement ::= {' RefineStatSeq}'

Refinement ::= {' RefineStatSeq}'

def rejectWildcardType(t: Tree, fallbackTree: Tree): Tree

rewrite code with (...) around the source code of t

rewrite code with (...) around the source code of t

def rewriteNotice(version: String, additionalOption: String): String
def selector(t: Tree): Tree

Accept identifier or match clause acting as a selector on given tree t

Accept identifier or match clause acting as a selector on given tree t

SelfInvocation ::= this ArgumentExprs {ArgumentExprs}

SelfInvocation ::= this ArgumentExprs {ArgumentExprs}

def simpleExpr(location: Location): Tree

SimpleExpr ::= ‘new’ ConstrApp {with ConstrApp} [TemplateBody] | ‘new’ TemplateBody | BlockExpr | ‘$’ ‘{’ Block ‘}’ | Quoted | quoteId | SimpleExpr1 [_] SimpleExpr1 ::= literal | xmlLiteral | SimpleRef | ( [ExprsInParens] ) | SimpleExpr . id | SimpleExpr . MatchClause | SimpleExpr (TypeArgs | NamedTypeArgs) | SimpleExpr1 ArgumentExprs | SimpleExpr1 : IndentedExpr -- under language.experimental.fewerBraces | SimpleExpr1 FunParams (‘=>’ | ‘?=>’) IndentedExpr -- under language.experimental.fewerBraces IndentedExpr ::= indent (CaseClauses | Block) outdent Quoted ::= ‘'’ ‘{’ Block ‘}’ | ‘'’ ‘[’ Type ‘]’

SimpleExpr ::= ‘new’ ConstrApp {with ConstrApp} [TemplateBody] | ‘new’ TemplateBody | BlockExpr | ‘$’ ‘{’ Block ‘}’ | Quoted | quoteId | SimpleExpr1 [_] SimpleExpr1 ::= literal | xmlLiteral | SimpleRef | ( [ExprsInParens] ) | SimpleExpr . id | SimpleExpr . MatchClause | SimpleExpr (TypeArgs | NamedTypeArgs) | SimpleExpr1 ArgumentExprs | SimpleExpr1 : IndentedExpr -- under language.experimental.fewerBraces | SimpleExpr1 FunParams (‘=>’ | ‘?=>’) IndentedExpr -- under language.experimental.fewerBraces IndentedExpr ::= indent (CaseClauses | Block) outdent Quoted ::= ‘'’ ‘{’ Block ‘}’ | ‘'’ ‘[’ Type ‘]’

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

SimpleLiteral ::= [‘-’] integerLiteral | [‘-’] floatingPointLiteral | booleanLiteral | characterLiteral | stringLiteral

SimpleLiteral ::= [‘-’] integerLiteral | [‘-’] floatingPointLiteral | booleanLiteral | characterLiteral | stringLiteral

SimplePattern ::= PatVar | Literal | Quoted | XmlPattern | (' [Patterns])' | SimplePattern1 [TypeArgs] [ArgumentPatterns] SimplePattern1 ::= SimpleRef | SimplePattern1 .' id PatVar ::= id |_'

SimplePattern ::= PatVar | Literal | Quoted | XmlPattern | (' [Patterns])' | SimplePattern1 [TypeArgs] [ArgumentPatterns] SimplePattern1 ::= SimpleRef | SimplePattern1 .' id PatVar ::= id |_'

SimpleRef ::= id | [id ‘.’] ‘this’ | [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id

SimpleRef ::= id | [id ‘.’] ‘this’ | [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id

SimpleType ::= SimpleLiteral | ‘?’ SubtypeBounds | SimpleType1 | SimpeType ‘(’ Singletons ‘)’ -- under language.experimental.dependent, checked in Typer Singletons ::= Singleton {‘,’ Singleton}

SimpleType ::= SimpleLiteral | ‘?’ SubtypeBounds | SimpleType1 | SimpeType ‘(’ Singletons ‘)’ -- under language.experimental.dependent, checked in Typer Singletons ::= Singleton {‘,’ Singleton}

SimpleType1 ::= id | Singleton .' id | Singleton.' type | ‘(’ ArgTypes ‘)’ | Refinement | ‘$’ ‘{’ Block ‘}’ | SimpleType1 TypeArgs | SimpleType1 `#' id

SimpleType1 ::= id | Singleton .' id | Singleton.' type | ‘(’ ArgTypes ‘)’ | Refinement | ‘$’ ‘{’ Block ‘}’ | SimpleType1 TypeArgs | SimpleType1 `#' id

Singleton ::= SimpleRef | SimpleLiteral | Singleton ‘.’ id -- not yet | Singleton ‘(’ Singletons ‘)’ -- not yet | Singleton ‘[’ Types ‘]’

Singleton ::= SimpleRef | SimpleLiteral | Singleton ‘.’ id -- not yet | Singleton ‘(’ Singletons ‘)’ -- not yet | Singleton ‘[’ Types ‘]’

def skip(): Unit

Skip on error to next safe point.

Skip on error to next safe point.

def skipBlanks(idx: Int, step: Int): Int
def splice(isType: Boolean): Tree

SimpleExpr ::= spliceId | ‘$’ ‘{’ Block ‘}’) unless inside quoted pattern SimpleType ::= spliceId | ‘$’ ‘{’ Block ‘}’) unless inside quoted pattern

SimpleExpr ::= spliceId | ‘$’ ‘{’ Block ‘}’) unless inside quoted pattern SimpleType ::= spliceId | ‘$’ ‘{’ Block ‘}’) unless inside quoted pattern

SimpleExpr ::= spliceId | ‘$’ ‘{’ Pattern ‘}’) when inside quoted pattern SimpleType ::= spliceId | ‘$’ ‘{’ Pattern ‘}’) when inside quoted pattern

The block in a quote or splice

The block in a quote or splice

def startingElimRegion(colonRequired: Boolean): (Offset, Offset)

The region to eliminate when replacing an opening ( or { that ends a line. The ( or { is at in.offset.

The region to eliminate when replacing an opening ( or { that ends a line. The ( or { is at in.offset.

def statSepOrEnd[T <: Tree](stats: ListBuffer[T], noPrevStat: Boolean, what: String, altEnd: Token): Boolean

Parse statement separators and end markers. Ensure that there is at least one statement separator unless the next token terminates a statement´sequence.

Parse statement separators and end markers. Ensure that there is at least one statement separator unless the next token terminates a statement´sequence.

Value parameters:
altEnd

a token that is also considered as a terminator of the statement sequence (the default EOF already assumes to terminate a statement sequence).

noPrevStat

true if there was no immediately preceding statement parsed

stats

the statements parsed to far

what

a string indicating what kind of statement is parsed

Returns:

true if the statement sequence continues, false if it terminates.

def subPart[T](body: () => T): T

Parse body while checking (under -no-indent) that a { is not missing before it. This is done as follows: If the next token S is indented relative to the current region, and the end of body is followed by a new line and another statement, check that that other statement is indented less than S

Parse body while checking (under -no-indent) that a { is not missing before it. This is done as follows: If the next token S is indented relative to the current region, and the end of body is followed by a new line and another statement, check that that other statement is indented less than S

If at end of file, issue an incompleteInputError. Otherwise issue a syntax error and skip to next safe point.

If at end of file, issue an incompleteInputError. Otherwise issue a syntax error and skip to next safe point.

def syntaxVersionError(option: String, span: Span): Unit
def template(constr: DefDef, isEnum: Boolean): Template

Template ::= InheritClauses [TemplateBody] InheritClauses ::= [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]

Template ::= InheritClauses [TemplateBody] InheritClauses ::= [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]

def templateBody(parents: List[Tree], rewriteWithColon: Boolean): (ValDef, List[Tree])
def templateBodyOpt(constr: DefDef, parents: List[Tree], derived: List[Tree]): Template

TemplateBody ::= [nl] {' TemplateStatSeq}' EnumBody ::= [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’

TemplateBody ::= [nl] {' TemplateStatSeq}' EnumBody ::= [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’

TemplateOpt = [Template]

TemplateOpt = [Template]

TemplateStatSeq ::= [id [:' Type]=>'] TemplateStat {semi TemplateStat} TemplateStat ::= Import | Export | Annotations Modifiers Def | Annotations Modifiers Dcl | Extension | Expr1 | EnumStat ::= TemplateStat | Annotations Modifiers EnumCase

TemplateStatSeq ::= [id [:' Type]=>'] TemplateStat {semi TemplateStat} TemplateStat ::= Import | Export | Annotations Modifiers Def | Annotations Modifiers Dcl | Extension | Expr1 | EnumStat ::= TemplateStat | Annotations Modifiers EnumCase

Accept identifier and return Ident with its name as a term name.

Accept identifier and return Ident with its name as a term name.

def testChar(idx: Int, p: Char => Boolean): Boolean
def testChar(idx: Int, c: Char): Boolean
def testChars(from: Int, str: String): Boolean
def tmplDef(start: Int, mods: Modifiers): Tree

TmplDef ::= ([‘case’] ‘class’ | ‘trait’) ClassDef | [‘case’] ‘object’ ObjectDef | ‘enum’ EnumDef | ‘given’ GivenDef

TmplDef ::= ([‘case’] ‘class’ | ‘trait’) ClassDef | [‘case’] ‘object’ ObjectDef | ‘enum’ EnumDef | ‘given’ GivenDef

def toBeContinued(altToken: Token): Boolean

Does the current conditional expression continue after the initially parsed (...) region?

Does the current conditional expression continue after the initially parsed (...) region?

def topStatSeq(outermost: Boolean): List[Tree]

TopStatSeq ::= TopStat {semi TopStat} TopStat ::= Import | Export | Annotations Modifiers Def | Packaging | package object objectDef | Extension |

TopStatSeq ::= TopStat {semi TopStat} TopStat ::= Import | Export | Annotations Modifiers Def | Packaging | package object objectDef | Extension |

Same as typ, but if this results in a wildcard it emits a syntax error and returns a tree for type Any instead.

Same as typ, but if this results in a wildcard it emits a syntax error and returns a tree for type Any instead.

def typ(): Tree

Type ::= FunType | HkTypeParamClause ‘=>>’ Type | FunParamClause ‘=>>’ Type | MatchType | InfixType FunType ::= (MonoFunType | PolyFunType) MonoFunType ::= FunTypeArgs (‘=>’ | ‘?=>’) Type PolyFunType ::= HKTypeParamClause '=>' Type FunTypeArgs ::= InfixType | (' [ [ ‘[using]’ ‘['erased'] FunArgType {,' FunArgType } ] `)' | '(' [ ‘[using]’ ‘['erased'] TypedFunParam {',' TypedFunParam } ')'

Type ::= FunType | HkTypeParamClause ‘=>>’ Type | FunParamClause ‘=>>’ Type | MatchType | InfixType FunType ::= (MonoFunType | PolyFunType) MonoFunType ::= FunTypeArgs (‘=>’ | ‘?=>’) Type PolyFunType ::= HKTypeParamClause '=>' Type FunTypeArgs ::= InfixType | (' [ [ ‘[using]’ ‘['erased'] FunArgType {,' FunArgType } ] `)' | '(' [ ‘[using]’ ‘['erased'] TypedFunParam {',' TypedFunParam } ')'

def typeArgs(namedOK: Boolean, wildOK: Boolean): List[Tree]

TypeArgs ::= [' Type {,' Type} ]' NamedTypeArgs ::=[' NamedTypeArg {,' NamedTypeArg}]'

TypeArgs ::= [' Type {,' Type} ]' NamedTypeArgs ::=[' NamedTypeArg {,' NamedTypeArg}]'

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

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

TypeCaseClause ::= ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]

TypeCaseClause ::= ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]

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

TypeDcl ::= id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]

TypeDcl ::= id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]

def typeDependingOn(location: Location): Tree

Accept identifier and return Ident with its name as a type name.

Accept identifier and return Ident with its name as a type name.

TypeParamBounds ::= TypeBounds {<%' Type} {:' Type}

TypeParamBounds ::= TypeBounds {<%' Type} {:' Type}

ClsTypeParamClause::= ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’ ClsTypeParam ::= {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeParamBounds

ClsTypeParamClause::= ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’ ClsTypeParam ::= {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeParamBounds

DefTypeParamClause::= ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’ DefTypeParam ::= {Annotation} id [HkTypeParamClause] TypeParamBounds

TypTypeParamClause::= ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’ TypTypeParam ::= {Annotation} id [HkTypePamClause] TypeBounds

HkTypeParamClause ::= ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’ HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (id [HkTypePamClause] | ‘_’) TypeBounds

def typedFunParam(start: Offset, name: TermName, mods: Modifiers): ValDef

TypedFunParam ::= id ':' Type

TypedFunParam ::= id ':' Type

def typedOpt(): Tree
def warning(msg: Message, sourcePos: SourcePosition): Unit
def warning(msg: Message, offset: Int): Unit

If all other characters on the same line as span are blanks, widen to the whole line.

If all other characters on the same line as span are blanks, widen to the whole line.

{withConstrApp} but no EOL allowed afterwith`.

{withConstrApp} but no EOL allowed afterwith`.

def withTemplate(constr: DefDef, parents: List[Tree]): Template

with Template, with EOL interpreted

with Template, with EOL interpreted

def withType(): Tree

WithType ::= AnnotType {`with' AnnotType} (deprecated)

WithType ::= AnnotType {`with' AnnotType} (deprecated)

def withinStaged[T](kind: StageKind)(op: => T): T
def wrapNew(tpt: Tree): Select

Wrap annotation or constructor in New(...).

Wrap annotation or constructor in New(...).

Inherited methods

def atSpan[T <: Positioned](start: Offset)(t: T): T
Inherited from:
ParserCommon
def atSpan[T <: Positioned](start: Offset, point: Offset)(t: T): T

If the last read offset is strictly greater than start, assign tree the span from start to last read offset, with given point. If the last offset is less than or equal to start, the tree t did not consume any source for its construction. In this case, don't assign a span yet, but wait for its span to be determined by setChildSpans when the parent node is positioned.

If the last read offset is strictly greater than start, assign tree the span from start to last read offset, with given point. If the last offset is less than or equal to start, the tree t did not consume any source for its construction. In this case, don't assign a span yet, but wait for its span to be determined by setChildSpans when the parent node is positioned.

Inherited from:
ParserCommon
def atSpan[T <: Positioned](start: Offset, point: Offset, end: Offset)(t: T): T
Inherited from:
ParserCommon
def atSpan[T <: Positioned](span: Span)(t: T): T

Positions tree. If t does not have a span yet, set its span to the given one.

Positions tree. If t does not have a span yet, set its span to the given one.

Inherited from:
ParserCommon
Inherited from:
ParserCommon

in.offset, except if this is at a new line, in which case lastOffset is preferred.

in.offset, except if this is at a new line, in which case lastOffset is preferred.

Inherited from:
ParserCommon
Inherited from:
ParserCommon
Inherited from:
ParserCommon
Inherited from:
ParserCommon
def syntaxError(msg: Message, span: Span): Unit

Unconditionally issue an error at given span, without updating lastErrorOffset.

Unconditionally issue an error at given span, without updating lastErrorOffset.

Inherited from:
ParserCommon
def syntaxError(msg: Message, offset: Int): Unit

Issue an error at given offset if beyond last error offset and update lastErrorOffset.

Issue an error at given offset if beyond last error offset and update lastErrorOffset.

Inherited from:
ParserCommon
Inherited from:
ParserCommon

Concrete fields

val argumentExpr: () => Tree
val constrApp: () => Tree

ConstrApp ::= SimpleType1 {Annotation} {ParArgumentExprs}

ConstrApp ::= SimpleType1 {Annotation} {ParArgumentExprs}

val constrExpr: () => Tree

ConstrExpr ::= SelfInvocation | {' SelfInvocation {semi BlockStat}}'

ConstrExpr ::= SelfInvocation | {' SelfInvocation {semi BlockStat}}'

val expr: () => Tree
val exprInParens: () => Tree

Expr ::= [implicit'] FunParams (‘=>’ | ‘?=>’) Expr | HkTypeParamClause ‘=>’ Expr | Expr1 FunParams ::= Bindings | id |' ExprInParens ::= PostfixExpr :' Type | Expr BlockResult ::= [‘implicit’] FunParams (‘=>’ | ‘?=>’) Block | HkTypeParamClause ‘=>’ Block | Expr1 Expr1 ::= [‘inline’]if' (' Expr)' {nl} Expr [[semi] else Expr] | [‘inline’] if' Exprthen' Expr [[semi] else Expr] | while'(' Expr )' {nl} Expr |while' Expr do' Expr |try' Expr Catches [finally' Expr] |try' Expr [finally' Expr] |throw' Expr | return' [Expr] | ForExpr | [SimpleExpr.'] id =' Expr | PrefixOperator SimpleExpr=' Expr | SimpleExpr1 ArgumentExprs =' Expr | PostfixExpr [Ascription] | ‘inline’ InfixExpr MatchClause Bindings ::=(' [Binding {,' Binding}])' Binding ::= (id | _') [:' Type] Ascription ::= :' InfixType |:' Annotation {Annotation} | :'' `*' Catches ::= ‘catch’ (Expr | ExprCaseClause)

Expr ::= [implicit'] FunParams (‘=>’ | ‘?=>’) Expr | HkTypeParamClause ‘=>’ Expr | Expr1 FunParams ::= Bindings | id |' ExprInParens ::= PostfixExpr :' Type | Expr BlockResult ::= [‘implicit’] FunParams (‘=>’ | ‘?=>’) Block | HkTypeParamClause ‘=>’ Block | Expr1 Expr1 ::= [‘inline’]if' (' Expr)' {nl} Expr [[semi] else Expr] | [‘inline’] if' Exprthen' Expr [[semi] else Expr] | while'(' Expr )' {nl} Expr |while' Expr do' Expr |try' Expr Catches [finally' Expr] |try' Expr [finally' Expr] |throw' Expr | return' [Expr] | ForExpr | [SimpleExpr.'] id =' Expr | PrefixOperator SimpleExpr=' Expr | SimpleExpr1 ArgumentExprs =' Expr | PostfixExpr [Ascription] | ‘inline’ InfixExpr MatchClause Bindings ::=(' [Binding {,' Binding}])' Binding ::= (id | _') [:' Type] Ascription ::= :' InfixType |:' Annotation {Annotation} | :'' `*' Catches ::= ‘catch’ (Expr | ExprCaseClause)

val funArgType: () => Tree

FunArgType ::= Type | `=>' Type

FunArgType ::= Type | `=>' Type

val in: Scanner
val pattern2: () => Tree

Pattern2 ::= [id `@'] Pattern3

Pattern2 ::= [id `@'] Pattern3

The implicit parameters introduced by _ in the current expression. Parameters appear in reverse order.

The implicit parameters introduced by _ in the current expression. Parameters appear in reverse order.

The last offset where a colon at the end of line would be required if a subsequent { ... } block would be converted to an indentation region.

The last offset where a colon at the end of line would be required if a subsequent { ... } block would be converted to an indentation region.

PrefixExpr ::= [PrefixOperator'] SimpleExpr PrefixOperator ::= ‘-’ | ‘+’ | ‘~’ | ‘!’

PrefixExpr ::= [PrefixOperator'] SimpleExpr PrefixOperator ::= ‘-’ | ‘+’ | ‘~’ | ‘!’

RefinedType ::= WithType {[nl] Refinement}

RefinedType ::= WithType {[nl] Refinement}

lazy val xmlp: MarkupParser

The markup parser. The first time this lazy val is accessed, we assume we were trying to parse an XML literal. The current position is recorded for later error reporting if it turns out that we don't have scala-xml on the compilation classpath.

The markup parser. The first time this lazy val is accessed, we assume we were trying to parse an XML literal. The current position is recorded for later error reporting if it turns out that we don't have scala-xml on the compilation classpath.

Inherited fields

protected var lastErrorOffset: Int

The offset where the last syntax error was reported, or if a skip to a safepoint occurred afterwards, the offset of the safe point.

The offset where the last syntax error was reported, or if a skip to a safepoint occurred afterwards, the offset of the safe point.

Inherited from:
ParserCommon