scala3-compiler-bootstrapped
API
Generated with
Copyright (c) 2002-2023, LAMP/EPFL
Copyright (c) 2002-2023, LAMP/EPFL
scala3-compiler-bootstrapped/dotty.tools/dotty.tools.dotc/dotty.tools.dotc.parsing/ScriptParsers/ScriptParser

ScriptParser

dotty.tools.dotc.parsing.ScriptParsers.ScriptParser
class ScriptParser(source: SourceFile)(using x$2: Context) extends Parser

Attributes

Graph
Supertypes
class Parser
class ParserCommon
class Object
trait Matchable
class Any

Members list

Type members

Inherited classlikes

object symbXMLBuilder extends SymbolicXMLBuilder

Attributes

Inherited from:
Parser
Supertypes
class Object
trait Matchable
class Any

Inherited types

type ImportConstr = (Tree, List[ImportSelector]) => Tree

Attributes

Inherited from:
Parser

Value members

Concrete methods

override def parse(): Tree

This is the parse entry point for code which is not self-contained, e.g. a script which is a series of template statements. They will be swaddled in Trees until the AST is equivalent to the one returned by compilationUnit().

This is the parse entry point for code which is not self-contained, e.g. a script which is a series of template statements. They will be swaddled in Trees until the AST is equivalent to the one returned by compilationUnit().

Attributes

Definition Classes

Inherited methods

def accept(name: Name): Int

Attributes

Inherited from:
Parser
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.

Attributes

Returns

The offset at the start of the token to accept

Inherited from:
Parser
def acceptColon(): Int

Attributes

Inherited from:
Parser
def acceptIndent(): Unit

Attributes

Inherited from:
Parser
def acceptStatSep(): Unit

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

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

Attributes

Inherited from:
Parser
def accessQualifierOpt(mods: Modifiers): Modifiers

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

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

Attributes

Inherited from:
Parser
def addFlag(mods: Modifiers, flag: FlagSet): Modifiers

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
def annot(): Tree

Annotation ::= `@' SimpleType1 {ParArgumentExprs}

Annotation ::= `@' SimpleType1 {ParArgumentExprs}

Attributes

Inherited from:
Parser
def annotType(): Tree

AnnotType ::= SimpleType {Annotation}

AnnotType ::= SimpleType {Annotation}

Attributes

Inherited from:
Parser
def annotTypeRest(t: Tree): Tree

Attributes

Inherited from:
Parser
def annotations(skipNewLines: Boolean): List[Tree]

Attributes

Inherited from:
Parser
def annotsAsMods(skipNewLines: Boolean): Modifiers

Attributes

Inherited from:
Parser
def argTypes(namedOK: Boolean, wildOK: Boolean): List[Tree]

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

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

Attributes

Inherited from:
Parser
def argumentExprs(): (List[Tree], Boolean)

ArgumentExprs ::= ParArgumentExprs | [nl] BlockExpr

ArgumentExprs ::= ParArgumentExprs | [nl] BlockExpr

Attributes

Inherited from:
Parser
def argumentExprss(fn: Tree): Tree

ArgumentExprss ::= {ArgumentExprs}

ArgumentExprss ::= {ArgumentExprs}

Attributes

Inherited from:
Parser
def argumentPatterns(): List[Tree]

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

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

Attributes

Inherited from:
Parser
def argumentStart(): Unit

Attributes

Inherited from:
Parser
def ascription(t: Tree, location: Location): Tree

Attributes

Inherited from:
Parser
def atSpan[T <: Positioned](start: Offset)(t: T): T

Attributes

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.

Attributes

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

Attributes

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.

Attributes

Inherited from:
ParserCommon
def binding(mods: Modifiers): Tree

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

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

Attributes

Inherited from:
Parser
def bindingName(): TermName

Attributes

Inherited from:
Parser
def block(simplify: Boolean): Tree

Block ::= BlockStatSeq

Block ::= BlockStatSeq

Attributes

Note

Return tree does not have a defined span.

Inherited from:
Parser
def blockExpr(): Tree

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

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

Attributes

Inherited from:
Parser
def blockStatSeq(): List[Tree]

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 |

Attributes

Inherited from:
Parser
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).

Attributes

Inherited from:
Parser
def captureRef(): Tree

CaptureRef ::= ident | this

CaptureRef ::= ident | this

Attributes

Inherited from:
Parser
def captureSet(): List[Tree]

CaptureSet ::= { CaptureRef {, CaptureRef} } -- under captureChecking

CaptureSet ::= { CaptureRef {, CaptureRef} } -- under captureChecking

Attributes

Inherited from:
Parser
def capturesAndResult(core: () => Tree): Tree

Attributes

Inherited from:
Parser
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

Attributes

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

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

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

Attributes

Inherited from:
Parser
def caseTemplate(constr: DefDef): Template

[`extends' ConstrApps]

[`extends' ConstrApps]

Attributes

Inherited from:
Parser
def checkAssoc(offset: Token, op1: Name, op2: Name, op2LeftAssoc: Boolean): Unit

Attributes

Inherited from:
Parser
def checkEndMarker[T <: Tree](stats: ListBuffer[T]): Unit

Attributes

Inherited from:
Parser
def checkExtensionMethod(tparams: List[Tree], vparamss: List[List[Tree]], stat: Tree): Unit

Attributes

Inherited from:
Parser
def checkNextNotIndented(): 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.

Attributes

Inherited from:
Parser
def checkNoEscapingPlaceholders[T](op: => T): T

Attributes

Inherited from:
Parser
def checkNonParamTuple(t: Tree): Option[Unit] | Unit

Checks that tuples don't contain a parameter.

Checks that tuples don't contain a parameter.

Attributes

Inherited from:
Parser
def classConstr(isCaseClass: Boolean): DefDef

ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsTermParamClauses

ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsTermParamClauses

Attributes

Inherited from:
Parser
def classDef(start: Offset, mods: Modifiers): TypeDef

ClassDef ::= id ClassConstr TemplateOpt

ClassDef ::= id ClassConstr TemplateOpt

Attributes

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

Attributes

Inherited from:
Parser
def closingElimRegion(): (Offset, Offset)

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.

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
def closureRest(start: Int, location: Location, params: List[Tree]): Tree

Attributes

Inherited from:
Parser
def colonAtEOLOpt(): Unit

Attributes

Inherited from:
Parser
def commaSeparated[T](part: () => T): List[T]

{ , }

{ , }

Attributes

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

{, }

{, }

currentRegion.commasExpected has to be set separately.

Attributes

Inherited from:
Parser
def compilationUnit(): Tree

CompilationUnit ::= {package QualId semi} TopStatSeq

CompilationUnit ::= {package QualId semi} TopStatSeq

Attributes

Inherited from:
Parser
def condExpr(altToken: Token): Tree

Attributes

Inherited from:
Parser
def constrApps(exclude: Token): List[Tree]

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

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

Attributes

Inherited from:
Parser
def constrModsOpt(): Modifiers

ConstrMods ::= {Annotation} [AccessModifier]

ConstrMods ::= {Annotation} [AccessModifier]

Attributes

Inherited from:
Parser
def contextBounds(pname: TypeName): List[Tree]

Attributes

Inherited from:
Parser
def contextTypes(ofClass: Boolean, numLeadParams: Int, impliedMods: Modifiers): List[ValDef]

ContextTypes ::= FunArgType {‘,’ FunArgType}

ContextTypes ::= FunArgType {‘,’ FunArgType}

Attributes

Inherited from:
Parser
def convertToParam(tree: Tree, mods: Modifiers): ValDef

Convert tree to formal parameter

Convert tree to formal parameter

Attributes

Inherited from:
Parser
def convertToParams(tree: Tree): List[ValDef]

Convert tree to formal parameter list

Convert tree to formal parameter list

Attributes

Inherited from:
Parser
def convertToTypeId(tree: Tree): Tree

Convert (qual)ident to type identifier

Convert (qual)ident to type identifier

Attributes

Inherited from:
Parser
def defAnnotsMods(allowed: BitSet): Modifiers

Attributes

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

DefDef ::= DefSig [‘:’ Type] ‘=’ Expr | this TypelessClauses [DefImplicitClause] =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id [DefTypeParamClause] DefTermParamClauses

DefDef ::= DefSig [‘:’ Type] ‘=’ Expr | this TypelessClauses [DefImplicitClause] =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id [DefTypeParamClause] DefTermParamClauses

if clauseInterleaving is enabled: DefSig ::= id [DefParamClauses] [DefImplicitClause]

Attributes

Inherited from:
Parser
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)

Attributes

Inherited from:
Parser
def deprecationWarning(msg: Message, offset: Int): Unit

Attributes

Inherited from:
Parser
def dotSelectors(t: Tree): Tree

DotSelectors ::= { `.' id }

DotSelectors ::= { `.' id }

Attributes

Inherited from:
Parser
def dropParensOrBraces(start: Offset, endStr: String): Unit

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

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

Attributes

Inherited from:
Parser
def dropTerminator(): Unit

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

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

Attributes

Inherited from:
Parser
def enclosed[T](tok: Token, body: => T): T

Attributes

Inherited from:
Parser
def endOffset(t: Positioned): Int

Attributes

Inherited from:
ParserCommon
def enumCase(start: Offset, mods: Modifiers): DefTree

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

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

Attributes

Inherited from:
Parser
def enumDef(start: Offset, mods: Modifiers): TypeDef

EnumDef ::= id ClassConstr InheritClauses EnumBody

EnumDef ::= id ClassConstr InheritClauses EnumBody

Attributes

Inherited from:
Parser
def enumerator(): Tree

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

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

Attributes

Inherited from:
Parser
def enumerators(): List[Tree]

Enumerators ::= Generator {semi Enumerator | Guard}

Enumerators ::= Generator {semi Enumerator | Guard}

Attributes

Inherited from:
Parser
def enumeratorsRest(): List[Tree]

Attributes

Inherited from:
Parser
def errorTermTree(start: Offset): Literal

Attributes

Inherited from:
Parser
def expectedOffset: Int

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.

Attributes

Inherited from:
ParserCommon
def exportClause(): List[Tree]

Attributes

Inherited from:
Parser
def expr(location: Location): Tree

Attributes

Inherited from:
Parser
def expr1(location: Location): Tree

Attributes

Inherited from:
Parser
def expr1Rest(t: Tree, location: Location): Tree

Attributes

Inherited from:
Parser
def exprsInParensOrBindings(): List[Tree]

ExprsInParens ::= ExprInParens {,' ExprInParens} Bindings ::= Binding {,' Binding}

ExprsInParens ::= ExprInParens {,' ExprInParens} Bindings ::= Binding {,' Binding}

Attributes

Inherited from:
Parser
def extMethod(numLeadParams: Int): DefDef

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

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

Attributes

Inherited from:
Parser
def extMethods(numLeadParams: Int): List[Tree]

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

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

Attributes

Inherited from:
Parser
def extension(): ExtMethods

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

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

Attributes

Inherited from:
Parser
def finalizeDef(md: MemberDef, mods: Modifiers, start: Int): ThisTree[Untyped]

Attributes

Inherited from:
Parser
def firstXmlPos: SourcePosition

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.

Attributes

Inherited from:
Parser
def followedByToken(query: Token): Boolean

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?

Attributes

Inherited from:
Parser
def followingIsEnclosedGenerators(): Boolean

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

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

Attributes

Inherited from:
Parser
def followingIsExtension(): Boolean

Attributes

Inherited from:
Parser
def followingIsGivenSig(): Boolean

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

Attributes

Inherited from:
Parser
def followingIsLambdaAfterColon(): Boolean

Is the token sequence following the current : token classified as a lambda? This is the case if the input starts with an identifier, a wildcard, or something enclosed in (...) or [...], and this is followed by a => or ?=> and an INDENT.

Is the token sequence following the current : token classified as a lambda? This is the case if the input starts with an identifier, a wildcard, or something enclosed in (...) or [...], and this is followed by a => or ?=> and an INDENT.

Attributes

Inherited from:
Parser
def followingIsLambdaParams(): Boolean

When encountering a :, is that in the binding of a lambda?

When encountering a :, is that in the binding of a lambda?

Attributes

Inherited from:
Parser
def followingIsSelfType(): Boolean

Attributes

Inherited from:
Parser
def followingIsVararg(): Boolean

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.

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
def funParamClause(): List[ValDef]

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

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

Attributes

Inherited from:
Parser
def funParamClauses(): List[List[ValDef]]

Attributes

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

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

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

Attributes

Inherited from:
Parser
def generator(): Tree

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

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

Attributes

Inherited from:
Parser
def generatorRest(pat: Tree, casePat: Boolean): GenFrom

Attributes

Inherited from:
Parser
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} ‘:’

Attributes

Inherited from:
Parser
def guard(): Tree

Guard ::= if PostfixExpr

Guard ::= if PostfixExpr

Attributes

Inherited from:
Parser
def ident(): TermName

Accept identifier and return its name as a term name.

Accept identifier and return its name as a term name.

Attributes

Inherited from:
Parser
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]

Attributes

Inherited from:
Parser
def importClause(outermost: Boolean): List[Tree]

Attributes

Inherited from:
Parser
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]

Attributes

Inherited from:
Parser
def importOrExportClause(leading: Token, mkTree: ImportConstr): List[Tree]

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

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

Attributes

Inherited from:
Parser
def inBraces[T](body: => T): T

Attributes

Inherited from:
Parser
def inBracesOrIndented[T](body: => T, rewriteWithColon: Boolean): T

Attributes

Inherited from:
Parser
def inBrackets[T](body: => T): T

Attributes

Inherited from:
Parser
def inDefScopeBraces[T](body: => T, rewriteWithColon: Boolean): T

Attributes

Inherited from:
Parser
def inParens[T](body: => T): T

Attributes

Inherited from:
Parser
def inSepRegion[T](f: Region => Region)(op: => T): T

Attributes

Inherited from:
Parser
def incompleteInputError(msg: Message): Unit

Issue an error at current offset that input is incomplete

Issue an error at current offset that input is incomplete

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
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.

Attributes

Inherited from:
Parser
def infixPattern(): Tree

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

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

Attributes

Inherited from:
Parser
def infixType(): Tree

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

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

Attributes

Inherited from:
Parser
def infixTypeRest(t: Tree): Tree

Attributes

Inherited from:
Parser
def isBindingIntro: Boolean

Attributes

Inherited from:
Parser
def isColonLambda: Boolean

True if we are seeing a lambda argument after a colon of the form: : (params) => body

True if we are seeing a lambda argument after a colon of the form: : (params) => body

Attributes

Inherited from:
Parser
def isDclIntro: Boolean

Attributes

Inherited from:
Parser
def isDefIntro(allowedMods: BitSet, excludedSoftModifiers: Set[TermName]): Boolean

Attributes

Inherited from:
Parser
def isErased: Boolean

Attributes

Inherited from:
Parser
def isErasedKw: Boolean

Attributes

Inherited from:
Parser
def isExprIntro: Boolean

Attributes

Inherited from:
Parser
def isIdent(name: Name): Boolean

Attributes

Inherited from:
Parser
def isIdent: Boolean

Attributes

Inherited from:
Parser
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.

Attributes

Inherited from:
Parser
def isLiteral: Boolean

Attributes

Inherited from:
Parser
def isModifier: Boolean

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

Attributes

Inherited from:
Parser
def isNumericLit: Boolean

Attributes

Inherited from:
Parser
def isPureArrow: Boolean

Attributes

Inherited from:
Parser
def isPureArrow(name: Name): Boolean

Attributes

Inherited from:
Parser
def isSimpleLiteral: Boolean

Attributes

Inherited from:
Parser
def isSplice: Boolean

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 '{...'

Attributes

Inherited from:
Parser
def isStatSep: Boolean

Attributes

Inherited from:
Parser
def isStatSeqEnd: Boolean

Attributes

Inherited from:
Parser
def isTemplateIntro: Boolean

Attributes

Inherited from:
Parser
def isWildcard(t: Tree): Boolean

Attributes

Inherited from:
Parser
def isWildcardType(t: Tree): Boolean

Attributes

Inherited from:
Parser
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.

Attributes

Inherited from:
Parser
def localDef(start: Int, implicitMods: Modifiers): Tree

Attributes

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

Create a tree representing a packaging

Create a tree representing a packaging

Attributes

Inherited from:
Parser
def matchClause(t: Tree): Match

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

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

Attributes

Inherited from:
Parser
def matchType(t: Tree): MatchTypeTree

match'{' TypeCaseClauses `}'

match'{' TypeCaseClauses `}'

Attributes

Inherited from:
Parser
def mixinQualifierOpt(): Ident

MixinQualifier ::= [' id]'

MixinQualifier ::= [' id]'

Attributes

Inherited from:
Parser
def mkApply(fn: Tree, args: (List[Tree], Boolean)): Tree

Attributes

Inherited from:
Parser
def mkImport(outermost: Boolean): ImportConstr

Create an import node and handle source version imports

Create an import node and handle source version imports

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
def mustStartStat: Boolean

Attributes

Inherited from:
Parser
def nameStart: Offset

Attributes

Inherited from:
ParserCommon
def newExpr(): Tree

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

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

Attributes

Inherited from:
Parser
def newLineOpt(): Unit

Attributes

Inherited from:
Parser
def newLineOptWhenFollowedBy(token: Int): Unit

Attributes

Inherited from:
Parser
def newLineOptWhenFollowing(p: Int => Boolean): Unit

Attributes

Inherited from:
Parser
def newLinesOpt(): Unit

Attributes

Inherited from:
Parser
def newLinesOptWhenFollowedBy(name: Name): Unit

Attributes

Inherited from:
Parser
def newLinesOptWhenFollowedBy(token: Int): Unit

Attributes

Inherited from:
Parser
def objectDef(start: Offset, mods: Modifiers): ModuleDef

ObjectDef ::= id TemplateOpt

ObjectDef ::= id TemplateOpt

Attributes

Inherited from:
Parser
def packaging(start: Int): Tree

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

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

Attributes

Inherited from:
Parser
def parArgumentExprs(): (List[Tree], Boolean)

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

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

Attributes

Inherited from:
Parser
def parArgumentExprss(fn: Tree): Tree

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.

Attributes

Inherited from:
Parser
def paramType(): Tree

ParamType ::= ParamValueType | =>' ParamValueType |->' [CaptureSet] ParamValueType

ParamType ::= ParamValueType | =>' ParamValueType |->' [CaptureSet] ParamValueType

Attributes

Inherited from:
Parser
def paramTypeOf(core: () => Tree): Tree

Attributes

Inherited from:
Parser
def paramValueType(): Tree

ParamValueType ::= [into] Type [`*']

ParamValueType ::= [into] Type [`*']

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
def pattern(location: Location): Tree

Pattern ::= Pattern1 { `|' Pattern1 }

Pattern ::= Pattern1 { `|' Pattern1 }

Attributes

Inherited from:
Parser
def pattern1(location: Location): Tree

Pattern1 ::= PatVar Ascription | [‘-’] integerLiteral Ascription | [‘-’] floatingPointLiteral Ascription | Pattern2

Pattern1 ::= PatVar Ascription | [‘-’] integerLiteral Ascription | [‘-’] floatingPointLiteral Ascription | Pattern2

Attributes

Inherited from:
Parser
def pattern3(): Tree

Pattern3 ::= InfixPattern | PatVar ‘*’

Pattern3 ::= InfixPattern | PatVar ‘*’

Attributes

Inherited from:
Parser
def patternAlts(location: Location): List[Tree]

Attributes

Inherited from:
Parser
def patterns(location: Location): List[Tree]

Patterns ::= Pattern [`,' Pattern]

Patterns ::= Pattern [`,' Pattern]

Attributes

Inherited from:
Parser
def patternsOpt(location: Location): List[Tree]

Attributes

Inherited from:
Parser
def pointOffset(t: Positioned): Int

Attributes

Inherited from:
ParserCommon
def possibleTemplateStart(isNew: Boolean): Unit

Attributes

Inherited from:
Parser
def postfixExpr(location: Location): Tree

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

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

Attributes

Inherited from:
Parser
def postfixExprRest(t: Tree, location: Location): Tree

Attributes

Inherited from:
Parser
def qualId(): Tree

QualId ::= id {`.' id}

QualId ::= id {`.' id}

Attributes

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

Attributes

Inherited from:
Parser
def refineStatSeq(): List[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)

Attributes

Inherited from:
Parser
def refinedType(): Tree

Attributes

Inherited from:
Parser
def refinedTypeRest(t: Tree): Tree

Attributes

Inherited from:
Parser
def refinement(indentOK: Boolean): List[Tree]

Refinement ::= {' RefineStatSeq}'

Refinement ::= {' RefineStatSeq}'

Attributes

Inherited from:
Parser
def rejectWildcardType(t: Tree, fallbackTree: Tree): Tree

Attributes

Inherited from:
Parser
def revertToParens(t: Tree): Unit

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

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

Attributes

Inherited from:
Parser
def rewriteNotice(version: SourceVersion, additionalOption: String): String

Attributes

Inherited from:
Parser
def rewriteToNewSyntax(span: Span): Boolean

Attributes

Inherited from:
Parser
def rewriteToOldSyntax(span: Span): Boolean

Attributes

Inherited from:
Parser
def selector(t: Tree): Tree

Attributes

Inherited from:
Parser
def selectorOrMatch(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

Attributes

Inherited from:
Parser
def selfInvocation(): Tree

SelfInvocation ::= this ArgumentExprs {ArgumentExprs}

SelfInvocation ::= this ArgumentExprs {ArgumentExprs}

Attributes

Inherited from:
Parser
def selfType(): ValDef

SelfType ::= id [‘:’ InfixType] ‘=>’ | ‘this’ ‘:’ InfixType ‘=>’

SelfType ::= id [‘:’ InfixType] ‘=>’ | ‘this’ ‘:’ InfixType ‘=>’

Attributes

Inherited from:
Parser
def simpleExpr(location: Location): Tree

SimpleExpr ::= ‘new’ ConstrApp {with ConstrApp} [TemplateBody] | ‘new’ TemplateBody | BlockExpr | ExprSplice | Quoted | quoteId | SimpleExpr1 [_] SimpleExpr1 ::= literal | xmlLiteral | SimpleRef | ( [ExprsInParens] ) | SimpleExpr . id | SimpleExpr . MatchClause | SimpleExpr (TypeArgs | NamedTypeArgs) | SimpleExpr1 ArgumentExprs | SimpleExpr1 ColonArgument ColonArgument ::= colon [LambdaStart] indent (CaseClauses | Block) outdent LambdaStart ::= FunParams (‘=>’ | ‘?=>’) | HkTypeParamClause ‘=>’ ColonArgBody ::= indent (CaseClauses | Block) outdent Quoted ::= ‘'’ ‘{’ Block ‘}’ | ‘'’ ‘[’ Type ‘]’

SimpleExpr ::= ‘new’ ConstrApp {with ConstrApp} [TemplateBody] | ‘new’ TemplateBody | BlockExpr | ExprSplice | Quoted | quoteId | SimpleExpr1 [_] SimpleExpr1 ::= literal | xmlLiteral | SimpleRef | ( [ExprsInParens] ) | SimpleExpr . id | SimpleExpr . MatchClause | SimpleExpr (TypeArgs | NamedTypeArgs) | SimpleExpr1 ArgumentExprs | SimpleExpr1 ColonArgument ColonArgument ::= colon [LambdaStart] indent (CaseClauses | Block) outdent LambdaStart ::= FunParams (‘=>’ | ‘?=>’) | HkTypeParamClause ‘=>’ ColonArgBody ::= indent (CaseClauses | Block) outdent Quoted ::= ‘'’ ‘{’ Block ‘}’ | ‘'’ ‘[’ Type ‘]’

Attributes

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

Attributes

Inherited from:
Parser
def simpleLiteral(): Tree

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

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

Attributes

Inherited from:
Parser
def simplePattern(): Tree

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

Attributes

Inherited from:
Parser
def simplePatternRest(t: Tree): Tree

Attributes

Inherited from:
Parser
def simpleRef(): Tree

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

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

Attributes

Inherited from:
Parser
def simpleType(): Tree

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

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

Attributes

Inherited from:
Parser
def simpleType1(): Tree

SimpleType1 ::= id | Singleton .' id | Singleton.' type | ‘(’ ArgTypes ‘)’ | Refinement | TypeSplice -- deprecated syntax (since 3.0.0) | SimpleType1 TypeArgs | SimpleType1 `#' id

SimpleType1 ::= id | Singleton .' id | Singleton.' type | ‘(’ ArgTypes ‘)’ | Refinement | TypeSplice -- deprecated syntax (since 3.0.0) | SimpleType1 TypeArgs | SimpleType1 `#' id

Attributes

Inherited from:
Parser
def singleton(): Tree

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 ‘]’

Attributes

Inherited from:
Parser
def skip(): Unit

Skip on error to next safe point.

Skip on error to next safe point.

Attributes

Inherited from:
Parser
def skipBlanks(idx: Int, step: Int): Int

Attributes

Inherited from:
Parser
def splice(isType: Boolean): Tree

ExprSplice ::= ‘$’ spliceId -- if inside quoted block | ‘$’ ‘{’ Block ‘}’ -- unless inside quoted pattern | ‘$’ ‘{’ Pattern ‘}’ -- when inside quoted pattern TypeSplice ::= ‘$’ spliceId -- if inside quoted type | ‘$’ ‘{’ Block ‘}’ -- unless inside quoted type pattern | ‘$’ ‘{’ Pattern ‘}’ -- when inside quoted type pattern

ExprSplice ::= ‘$’ spliceId -- if inside quoted block | ‘$’ ‘{’ Block ‘}’ -- unless inside quoted pattern | ‘$’ ‘{’ Pattern ‘}’ -- when inside quoted pattern TypeSplice ::= ‘$’ spliceId -- if inside quoted type | ‘$’ ‘{’ Block ‘}’ -- unless inside quoted type pattern | ‘$’ ‘{’ Pattern ‘}’ -- when inside quoted type pattern

Attributes

Inherited from:
Parser
def stagedBlock(): Tree[Untyped]

The block in a quote or splice

The block in a quote or splice

Attributes

Inherited from:
Parser
def startOffset(t: Positioned): Int

Attributes

Inherited from:
ParserCommon
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.

Attributes

Inherited from:
Parser
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

Attributes

Returns

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

Inherited from:
Parser
def subExpr(): Tree[Untyped]

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
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.

Attributes

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.

Attributes

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

Attributes

Inherited from:
Parser
def syntaxErrorOrIncomplete(msg: Message, offset: Int): Unit

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.

Attributes

Inherited from:
Parser
def syntaxVersionError(option: String, span: Span): Unit

Attributes

Inherited from:
Parser
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}]

Attributes

Inherited from:
Parser
def templateBody(parents: List[Tree], rewriteWithColon: Boolean): (ValDef, List[Tree])

Attributes

Inherited from:
Parser
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} ‘}’

Attributes

Inherited from:
Parser
def templateOpt(constr: DefDef): Template

TemplateOpt = [Template]

TemplateOpt = [Template]

Attributes

Inherited from:
Parser
def templateStatSeq(): (ValDef, List[Tree])

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

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

Attributes

Inherited from:
Parser
def termIdent(): Ident

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

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

Attributes

Inherited from:
Parser
def termParamClause(numLeadParams: Int, ofClass: Boolean, ofCaseClass: Boolean, prefix: Boolean, givenOnly: Boolean, firstClause: Boolean): List[ValDef]

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

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

TypelessClause ::= DefTermParamClause | UsingParamClause

DefTermParamClause::= [nl] ‘(’ [DefTermParams] ‘)’ UsingParamClause ::= ‘(’ ‘using’ (DefTermParams | ContextTypes) ‘)’ DefImplicitClause ::= [nl] ‘(’ ‘implicit’ DefTermParams ‘)’ DefTermParams ::= DefTermParam {‘,’ DefTermParam} DefTermParam ::= {Annotation} [‘erased’] [‘inline’] Param

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

Attributes

Returns

the list of parameter definitions

Inherited from:
Parser
def termParamClauses(ofClass: Boolean, ofCaseClass: Boolean, givenOnly: Boolean, numLeadParams: Int): List[List[ValDef]]

ClsTermParamClauses ::= {ClsTermParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’] TypelessClauses ::= TypelessClause {TypelessClause}

ClsTermParamClauses ::= {ClsTermParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’] TypelessClauses ::= TypelessClause {TypelessClause}

Attributes

Returns

The parameter definitions

Inherited from:
Parser
def testChar(idx: Int, c: Char): Boolean

Attributes

Inherited from:
Parser
def testChar(idx: Int, p: Char => Boolean): Boolean

Attributes

Inherited from:
Parser
def testChars(from: Int, str: String): Boolean

Attributes

Inherited from:
Parser
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

Attributes

Inherited from:
Parser
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?

Attributes

Inherited from:
Parser
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 |

Attributes

Inherited from:
Parser
def toplevelTyp(): Tree

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.

Attributes

Inherited from:
Parser
def typ(): Tree

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

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

Attributes

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

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

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

Attributes

Inherited from:
Parser
def typeBounds(): TypeBoundsTree

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

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

Attributes

Inherited from:
Parser
def typeCaseClause(): CaseDef

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

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

Attributes

Inherited from:
Parser
def typeDefOrDcl(start: Offset, mods: Modifiers): Tree

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

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

Attributes

Inherited from:
Parser
def typeDependingOn(location: Location): Tree

Attributes

Inherited from:
Parser
def typeIdent(): Ident

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

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

Attributes

Inherited from:
Parser
def typeOrTermParamClauses(ownerKind: ParamOwner, numLeadParams: Int): List[List[TypeDef] | List[ValDef]]

DefParamClauses ::= DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent DefParamClause ::= DefTypeParamClause | DefTermParamClause | UsingParamClause

DefParamClauses ::= DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent DefParamClause ::= DefTypeParamClause | DefTermParamClause | UsingParamClause

Attributes

Inherited from:
Parser
def typeParamBounds(pname: TypeName): Tree

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

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

Attributes

Inherited from:
Parser
def typeParamClause(ownerKind: ParamOwner): List[TypeDef]

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

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

DefTypeParamClause::= ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’ DefTypeParam ::= {Annotation} [sealed] -- under captureChecking id [HkTypeParamClause] TypeParamBounds

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

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

Attributes

Inherited from:
Parser
def typeParamClauseOpt(ownerKind: ParamOwner): List[TypeDef]

Attributes

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

TypedFunParam ::= id ':' Type

TypedFunParam ::= id ':' Type

Attributes

Inherited from:
Parser
def typedOpt(): Tree

Attributes

Inherited from:
Parser
def unimplementedExpr(using Context): Select

Attributes

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

Attributes

Inherited from:
Parser
def widenIfWholeLine(span: Span): Span

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.

Attributes

Inherited from:
Parser
def wildcardIdent(): Ident

Attributes

Inherited from:
Parser
def withConstrApps(): List[Tree]

{withConstrApp} but no EOL allowed afterwith`.

{withConstrApp} but no EOL allowed afterwith`.

Attributes

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

with Template, with EOL interpreted

with Template, with EOL interpreted

Attributes

Inherited from:
Parser
def withType(): Tree

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

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

Attributes

Inherited from:
Parser
def withTypeRest(t: Tree): Tree

Attributes

Inherited from:
Parser
def withinStaged[T](kind: StageKind)(op: => T): T

Attributes

Inherited from:
Parser
def wrapNew(tpt: Tree): Select

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

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

Attributes

Inherited from:
Parser
def xmlLiteral(): Tree

Attributes

Inherited from:
Parser
def xmlLiteralPattern(): Tree

Attributes

Inherited from:
Parser

Inherited fields

val argumentExpr: () => Tree

Attributes

Inherited from:
Parser
val constrApp: () => Tree

ConstrApp ::= SimpleType1 {Annotation} {ParArgumentExprs}

ConstrApp ::= SimpleType1 {Annotation} {ParArgumentExprs}

Attributes

Inherited from:
Parser
val constrExpr: () => Tree

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

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

Attributes

Inherited from:
Parser
val expr: () => Tree

Attributes

Inherited from:
Parser
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)

Attributes

Inherited from:
Parser
val funArgType: () => Tree

FunArgType ::= Type | =>' Type |->' [CaptureSet] Type

FunArgType ::= Type | =>' Type |->' [CaptureSet] Type

Attributes

Inherited from:
Parser
val in: Scanner

Attributes

Inherited from:
Parser
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.

Attributes

Inherited from:
ParserCommon
var opStack: List[OpInfo]

Attributes

Inherited from:
Parser
val pattern2: () => Tree

Pattern2 ::= [id `@'] Pattern3

Pattern2 ::= [id `@'] Pattern3

Attributes

Inherited from:
Parser
var placeholderParams: List[ValDef]

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.

Attributes

Inherited from:
Parser
var possibleColonOffset: Int

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.

Attributes

Inherited from:
Parser
val prefixExpr: Location => Tree

PrefixExpr ::= [PrefixOperator'] SimpleExpr PrefixOperator ::= ‘-’ | ‘+’ | ‘~’ | ‘!’ (if not backquoted)

PrefixExpr ::= [PrefixOperator'] SimpleExpr PrefixOperator ::= ‘-’ | ‘+’ | ‘~’ | ‘!’ (if not backquoted)

Attributes

Inherited from:
Parser
val refinedTypeFn: Location => Tree

RefinedType ::= WithType {[nl] Refinement} [^ CaptureSet]

RefinedType ::= WithType {[nl] Refinement} [^ CaptureSet]

Attributes

Inherited from:
Parser
val simplePatternFn: Location => Tree

Attributes

Inherited from:
Parser
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.

Attributes

Inherited from:
Parser
Generated with
Copyright (c) 2002-2023, LAMP/EPFL
Copyright (c) 2002-2023, LAMP/EPFL