dotty.tools.dotc.parsing.Parsers

OutlineParser

Related Doc: package Parsers

class OutlineParser extends Parser

Linear Supertypes
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. OutlineParser
  2. Parser
  3. ParserCommon
  4. DotClass
  5. AnyRef
  6. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new OutlineParser(source: SourceFile)(implicit ctx: Context)

Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  4. 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

    Definition Classes
    Parser
  5. def acceptStatSep(): Unit

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

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

    Definition Classes
    Parser
  6. def acceptStatSepUnlessAtEnd(altEnd: Token = EOF): Unit

    Definition Classes
    Parser
  7. def accessQualifierOpt(mods: Modifiers): Modifiers

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

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

    Definition Classes
    Parser
  8. def addFlag(mods: Modifiers, flag: FlagSet): Modifiers

    Definition Classes
    Parser
  9. 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

    Definition Classes
    Parser
  10. def adjustStart(start: Offset)(tree: ast.untpd.Tree): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  11. def annot(): ast.untpd.Tree

    Annotation ::= @' SimpleType {ParArgumentExprs}

    Annotation ::= @' SimpleType {ParArgumentExprs}

    Definition Classes
    Parser
  12. def annotType(): ast.untpd.Tree

    AnnotType ::= SimpleType {Annotation}

    AnnotType ::= SimpleType {Annotation}

    Definition Classes
    Parser
  13. def annotTypeRest(t: ast.untpd.Tree): ast.untpd.Tree

    Definition Classes
    Parser
  14. def annotations(skipNewLines: Boolean = false): List[ast.untpd.Tree]

    Definition Classes
    Parser
  15. def annotsAsMods(skipNewLines: Boolean = false): Modifiers

    Definition Classes
    Parser
  16. def argTypes(namedOK: Boolean = false): List[ast.untpd.Tree]

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

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

    Definition Classes
    Parser
  17. val argumentExpr: () ⇒ ast.untpd.Tree

    Definition Classes
    Parser
  18. def argumentExprs(): List[ast.untpd.Tree]

    ArgumentExprs ::= ParArgumentExprs | [nl] BlockExpr

    ArgumentExprs ::= ParArgumentExprs | [nl] BlockExpr

    Definition Classes
    Parser
  19. def argumentExprss(fn: ast.untpd.Tree): ast.untpd.Tree

    ArgumentExprss ::= {ArgumentExprs}

    ArgumentExprss ::= {ArgumentExprs}

    Definition Classes
    Parser
  20. def argumentPatterns(): List[ast.untpd.Tree]

    ArgumentPatterns ::= (' [Patterns] )' | (' [Patterns ,'] Pattern2 :' _' *' ')

    ArgumentPatterns ::= (' [Patterns] )' | (' [Patterns ,'] Pattern2 :' _' *' ')

    Definition Classes
    Parser
  21. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  22. def ascription(t: ast.untpd.Tree, location: Location.Value): ast.untpd.Tree

    Definition Classes
    Parser
  23. def atPos[T <: Positioned](start: Offset)(t: T): T

    Definition Classes
    ParserCommon
  24. def atPos[T <: Positioned](start: Offset, point: Offset)(t: T): T

    If the last read offset is strictly greater than start, position tree to position spanning from start to last read offset, with given point.

    If the last read offset is strictly greater than start, position tree to position spanning 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 position it yet, but wait for its position to be determined by setChildPositions when the parent node is positioned.

    Definition Classes
    ParserCommon
  25. def atPos[T <: Positioned](start: Offset, point: Offset, end: Offset)(t: T): T

    Definition Classes
    ParserCommon
  26. def atPos[T <: Positioned](pos: Position)(t: T): T

    Positions tree.

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

    Definition Classes
    ParserCommon
  27. def block(): ast.untpd.Tree

    Block ::= BlockStatSeq

    Block ::= BlockStatSeq

    Definition Classes
    Parser
    Note

    Return tree does not carry source position.

  28. def blockExpr(): ast.untpd.Tree

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

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

    Definition Classes
    OutlineParserParser
  29. def blockStatSeq(): List[ast.untpd.Tree]

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

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

    Definition Classes
    Parser
  30. def caseClause(): ast.untpd.CaseDef

    CaseClause ::= case Pattern [Guard] =>' Block

    CaseClause ::= case Pattern [Guard] =>' Block

    Definition Classes
    Parser
  31. def caseClauses(): List[ast.untpd.CaseDef]

    CaseClauses ::= CaseClause {CaseClause}

    CaseClauses ::= CaseClause {CaseClause}

    Definition Classes
    Parser
  32. def checkAssoc(offset: Int, op: Name, leftAssoc: Boolean): Unit

    Definition Classes
    Parser
  33. def checkNoEscapingPlaceholders[T](op: ⇒ T): T

    Definition Classes
    Parser
  34. def classDef(start: Offset, mods: Modifiers, docstring: Option[Comment]): ast.untpd.TypeDef

    ClassDef ::= Id [ClsTypeParamClause] [ConstrMods] ClsParamClauses TemplateOpt

    ClassDef ::= Id [ClsTypeParamClause] [ConstrMods] ClsParamClauses TemplateOpt

    Definition Classes
    Parser
  35. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  36. def closureRest(start: Int, location: Location.Value, params: List[ast.untpd.Tree]): ast.untpd.Tree

    Definition Classes
    Parser
  37. def commaSeparated[T](part: () ⇒ T): List[T]

    Definition Classes
    Parser
  38. def compilationUnit(): ast.untpd.Tree

    CompilationUnit ::= {package QualId semi} TopStatSeq

    CompilationUnit ::= {package QualId semi} TopStatSeq

    Definition Classes
    Parser
  39. def condExpr(altToken: Token): ast.untpd.Tree

    Definition Classes
    Parser
  40. val constrApp: () ⇒ ast.untpd.Tree

    ConstrApp ::= SimpleType {ParArgumentExprs}

    ConstrApp ::= SimpleType {ParArgumentExprs}

    Definition Classes
    Parser
  41. def constrBlock(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  42. def constrExpr(): ast.untpd.Tree

    ConstrExpr ::= SelfInvocation | ConstrBlock

    ConstrExpr ::= SelfInvocation | ConstrBlock

    Definition Classes
    Parser
  43. def constrModsOpt(): Modifiers

    ConstrMods ::= AccessModifier | Annotation {Annotation} (AccessModifier | this')

    ConstrMods ::= AccessModifier | Annotation {Annotation} (AccessModifier | this')

    Definition Classes
    Parser
  44. def contextBounds(pname: TypeName): List[ast.untpd.Tree]

    Definition Classes
    Parser
  45. def convertToParam(tree: ast.untpd.Tree, mods: Modifiers = Modifiers(), expected: String = "formal parameter"): ast.untpd.ValDef

    Convert tree to formal parameter

    Convert tree to formal parameter

    Definition Classes
    Parser
  46. def convertToParams(tree: ast.untpd.Tree): List[ast.untpd.ValDef]

    Convert tree to formal parameter list

    Convert tree to formal parameter list

    Definition Classes
    Parser
  47. def convertToTypeId(tree: ast.untpd.Tree): ast.untpd.Tree

    Convert (qual)ident to type identifier

    Convert (qual)ident to type identifier

    Definition Classes
    Parser
  48. def defAnnotsMods(allowed: BitSet): Modifiers

    Definition Classes
    Parser
  49. def defDefOrDcl(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): ast.untpd.Tree

    DefDef ::= DefSig (:' Type [=' Expr] | "=" Expr) | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig :' Type DefSig ::= id [DefTypeParamClause] ParamClauses

    DefDef ::= DefSig (:' Type [=' Expr] | "=" Expr) | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig :' Type DefSig ::= id [DefTypeParamClause] ParamClauses

    Definition Classes
    Parser
  50. def defOrDcl(start: Int, mods: Modifiers): ast.untpd.Tree

    Def ::= val PatDef | var VarDef | def DefDef | type {nl} TypeDcl | TmplDef Dcl ::= val ValDcl | var ValDcl | def DefDcl | type {nl} TypeDcl

    Def ::= val PatDef | var VarDef | def DefDef | type {nl} TypeDcl | TmplDef Dcl ::= val ValDcl | var ValDcl | def DefDcl | type {nl} TypeDcl

    Definition Classes
    Parser
  51. def deprecationWarning(msg: ⇒ Message, offset: Int = in.offset): Unit

    Definition Classes
    Parser
  52. def dotSelectors(t: ast.untpd.Tree, finish: (ast.untpd.Tree) ⇒ ast.untpd.Tree = id): ast.untpd.Tree

    DotSelectors ::= { .' ident()

    DotSelectors ::= { .' ident()

    Accept .' separated identifiers acting as a selectors on given tree t.

    finish

    An alternative parse in case the token following a .' is not an identifier. If the alternative does not apply, its tree argument is returned unchanged.

    Definition Classes
    Parser
  53. def enclosed[T](tok: Token, body: ⇒ T): T

    Definition Classes
    Parser
  54. def enumerator(): ast.untpd.Tree

    Enumerator ::= Generator | Guard | Pattern1 =' Expr

    Enumerator ::= Generator | Guard | Pattern1 =' Expr

    Definition Classes
    Parser
  55. def enumerators(): List[ast.untpd.Tree]

    Enumerators ::= Generator {semi Enumerator | Guard}

    Enumerators ::= Generator {semi Enumerator | Guard}

    Definition Classes
    Parser
  56. def enumeratorsRest(): List[ast.untpd.Tree]

    Definition Classes
    Parser
  57. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  58. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  59. def equalsExpr(): ast.untpd.Tree

    EqualsExpr ::= =' Expr

    EqualsExpr ::= =' Expr

    Definition Classes
    Parser
  60. def errorTermTree: ast.untpd.Literal

    Definition Classes
    Parser
  61. def expr(location: Location.Value): ast.untpd.Tree

    Definition Classes
    Parser
  62. def expr(): ast.untpd.Tree

    Definition Classes
    Parser
  63. def expr1(location: Location.Value = Location.ElseWhere): ast.untpd.Tree

    Definition Classes
    Parser
  64. def expr1Rest(t: ast.untpd.Tree, location: Location.Value): ast.untpd.Tree

    Definition Classes
    Parser
  65. val exprInParens: () ⇒ ast.untpd.Tree

    Expr ::= FunParams =>' Expr | Expr1 FunParams ::= Bindings | [implicit'] Id | _' ExprInParens ::= PostfixExpr :' Type | Expr BlockResult ::= (FunParams | [implicit'] Id :' InfixType) => Block | Expr1 Expr1 ::= if' (' Expr )' {nl} Expr else Expr] | if' Expr then' Expr else Expr] | while' (' Expr )' {nl} Expr | while' Expr do' Expr | do' Expr [semi] while' Expr | try' Expr Catches [finally' Expr] | try' Expr [finally' Expr] | throw' Expr | return' [Expr] | ForExpr | [SimpleExpr .'] Id =' Expr | SimpleExpr1 ArgumentExprs =' Expr | PostfixExpr [Ascription] | PostfixExpr match' {' CaseClauses }' Bindings ::= (' [Binding {,' Binding}] )' Binding ::= (Id | _') [:' Type] Ascription ::= :' CompoundType | :' Annotation {Annotation} | :' _' *'

    Expr ::= FunParams =>' Expr | Expr1 FunParams ::= Bindings | [implicit'] Id | _' ExprInParens ::= PostfixExpr :' Type | Expr BlockResult ::= (FunParams | [implicit'] Id :' InfixType) => Block | Expr1 Expr1 ::= if' (' Expr )' {nl} Expr else Expr] | if' Expr then' Expr else Expr] | while' (' Expr )' {nl} Expr | while' Expr do' Expr | do' Expr [semi] while' Expr | try' Expr Catches [finally' Expr] | try' Expr [finally' Expr] | throw' Expr | return' [Expr] | ForExpr | [SimpleExpr .'] Id =' Expr | SimpleExpr1 ArgumentExprs =' Expr | PostfixExpr [Ascription] | PostfixExpr match' {' CaseClauses }' Bindings ::= (' [Binding {,' Binding}] )' Binding ::= (Id | _') [:' Type] Ascription ::= :' CompoundType | :' Annotation {Annotation} | :' _' *'

    Definition Classes
    Parser
  66. def exprsInParensOpt(): List[ast.untpd.Tree]

    ExprsInParens ::= ExprInParens {,' ExprInParens}

    ExprsInParens ::= ExprInParens {,' ExprInParens}

    Definition Classes
    Parser
  67. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  68. def forExpr(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  69. val funArgType: () ⇒ ast.untpd.Tree

    FunArgType ::= Type | =>' Type

    FunArgType ::= Type | =>' Type

    Definition Classes
    Parser
  70. def generator(): ast.untpd.Tree

    Generator ::= Pattern <-' Expr

    Generator ::= Pattern <-' Expr

    Definition Classes
    Parser
  71. def generatorRest(pat: ast.untpd.Tree): GenFrom

    Definition Classes
    Parser
  72. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  73. def guard(): ast.untpd.Tree

    Guard ::= if PostfixExpr

    Guard ::= if PostfixExpr

    Definition Classes
    Parser
  74. val handleImport: (ast.untpd.Tree) ⇒ ast.untpd.Tree

    Definition Classes
    Parser
  75. val handleSingletonType: (ast.untpd.Tree) ⇒ ast.untpd.Tree

    Definition Classes
    Parser
  76. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  77. def ident(): TermName

    Accept identifier and return its name as a term name.

    Accept identifier and return its name as a term name.

    Definition Classes
    Parser
  78. def implicitClosure(start: Int, location: Location.Value, implicitMod: Option[Mod] = None): ast.untpd.Tree

    Expr ::= implicit Id =>' Expr BlockResult ::= implicit Id [:' InfixType] =>' Block

    Expr ::= implicit Id =>' Expr BlockResult ::= implicit Id [:' InfixType] =>' Block

    Definition Classes
    Parser
  79. def importClause(): List[ast.untpd.Tree]

    Import ::= import ImportExpr {,' ImportExpr}

    Import ::= import ImportExpr {,' ImportExpr}

    Definition Classes
    Parser
  80. val importExpr: () ⇒ ast.untpd.Import

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

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

    Definition Classes
    Parser
  81. def importSelector(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  82. def importSelectors(): List[ast.untpd.Tree]

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

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

    Definition Classes
    Parser
  83. val in: Scanner

    Definition Classes
    ParserParserCommon
  84. def inBraces[T](body: ⇒ T): T

    Definition Classes
    Parser
  85. def inBrackets[T](body: ⇒ T): T

    Definition Classes
    Parser
  86. def inDefScopeBraces[T](body: ⇒ T): T

    Definition Classes
    Parser
  87. def inParens[T](body: ⇒ T): T

    Definition Classes
    Parser
  88. def incompleteInputError(msg: ⇒ Message): Unit

    Issue an error at current offset taht input is incomplete

    Issue an error at current offset taht input is incomplete

    Definition Classes
    Parser
  89. def infixOps(first: ast.untpd.Tree, canStartOperand: (Token) ⇒ Boolean, operand: () ⇒ ast.untpd.Tree, isType: Boolean = false, notAnOperator: Name = nme.EMPTY, maybePostfix: Boolean = false): ast.untpd.Tree

    operand { infixop operand} [postfixop], respecting rules of associativity and precedence.

    operand { infixop operand} [postfixop], respecting rules of associativity and precedence.

    notAnOperator

    a token that does not count as operator.

    maybePostfix

    postfix operators are allowed.

    Definition Classes
    Parser
  90. def infixPattern(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  91. def infixType(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  92. def infixTypeRest(t: ast.untpd.Tree): ast.untpd.Tree

    Definition Classes
    Parser
  93. def isDclIntro: Boolean

    Definition Classes
    Parser
  94. def isDefIntro(allowedMods: BitSet): Boolean

    Definition Classes
    Parser
  95. def isExprIntro: Boolean

    Definition Classes
    Parser
  96. def isIdent(name: Name): Boolean

    Definition Classes
    Parser
  97. def isIdent: Boolean

    Definition Classes
    Parser
  98. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  99. 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.

    Definition Classes
    Parser
  100. def isLiteral: Boolean

    Definition Classes
    Parser
  101. def isModifier: Boolean

    Definition Classes
    Parser
  102. def isNumericLit: Boolean

    Definition Classes
    Parser
  103. def isSimpleLiteral: Boolean

    Definition Classes
    Parser
  104. def isStatSep: Boolean

    Definition Classes
    Parser
  105. def isStatSeqEnd: Boolean

    Definition Classes
    Parser
  106. def isTemplateIntro: Boolean

    Definition Classes
    Parser
  107. def isWildcard(t: ast.untpd.Tree): Boolean

    Definition Classes
    Parser
  108. 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
    protected
    Definition Classes
    ParserCommon
  109. def literal(negOffset: Int = in.offset, inPattern: Boolean = false): ast.untpd.Tree

    SimpleExpr ::= literal | symbol | null

    SimpleExpr ::= literal | symbol | null

    negOffset

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

    Definition Classes
    Parser
  110. def localDef(start: Int, implicitFlag: FlagSet, implicitMod: Option[Mod] = None): ast.untpd.Tree

    Definition Classes
    Parser
  111. def makePackaging(start: Int, pkg: ast.untpd.Tree, stats: List[ast.untpd.Tree]): ast.untpd.PackageDef

    Create a tree representing a packaging

    Create a tree representing a packaging

    Definition Classes
    Parser
  112. def migrationWarningOrError(msg: String, offset: Int = in.offset): Unit

    Definition Classes
    Parser
  113. def mixinQualifierOpt(): TypeName

    MixinQualifier ::= [' Id ]'

    MixinQualifier ::= [' Id ]'

    Definition Classes
    Parser
  114. def modifiers(allowed: BitSet = modifierTokens, start: Modifiers = Modifiers()): Modifiers

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

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

    Definition Classes
    Parser
  115. def mustStartStat: Boolean

    Definition Classes
    Parser
  116. def nameStart: Offset

    Definition Classes
    ParserCommon
  117. val namedTypeArg: () ⇒ ast.untpd.NamedArg

    NamedTypeArg ::= id =' Type

    NamedTypeArg ::= id =' Type

    Definition Classes
    Parser
  118. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  119. def newLineOpt(): Unit

    Definition Classes
    Parser
  120. def newLineOptWhenFollowedBy(token: Int): Unit

    Definition Classes
    Parser
  121. def newLineOptWhenFollowing(p: (Int) ⇒ Boolean): Unit

    Definition Classes
    Parser
  122. def newLinesOpt(): Unit

    Definition Classes
    Parser
  123. final def notify(): Unit

    Definition Classes
    AnyRef
  124. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  125. def objectDef(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): ModuleDef

    ObjectDef ::= Id TemplateOpt

    ObjectDef ::= Id TemplateOpt

    Definition Classes
    Parser
  126. var opStack: List[OpInfo]

    Definition Classes
    Parser
  127. val openParens: ParensCounters

    Definition Classes
    Parser
  128. def packaging(start: Int): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  129. def parArgumentExprs(): List[ast.untpd.Tree]

    ParArgumentExprs ::= (' [ExprsInParens] )' | (' [ExprsInParens ,'] PostfixExpr :' _' *' ')' \

    ParArgumentExprs ::= (' [ExprsInParens] )' | (' [ExprsInParens ,'] PostfixExpr :' _' *' ')' \

    Definition Classes
    Parser
  130. def parArgumentExprss(fn: ast.untpd.Tree): ast.untpd.Tree

    ParArgumentExprss ::= {ParArgumentExprs}

    ParArgumentExprss ::= {ParArgumentExprs}

    Definition Classes
    Parser
  131. def paramClauses(owner: Name, ofCaseClass: Boolean = false): List[List[ast.untpd.ValDef]]

    ClsParamClauses ::= {ClsParamClause} (' implicit' ClsParams )'] ClsParamClause ::= [nl] (' [ClsParams] ')' ClsParams ::= ClsParam {' ClsParam} ClsParam ::= {Annotation} [{Modifier} (val' | var') | inline'] Param DefParamClauses ::= {DefParamClause} (' implicit' DefParams )'] DefParamClause ::= [nl] (' [DefParams] ')' DefParams ::= DefParam {,' DefParam} DefParam ::= {Annotation} [inline'] Param Param ::= id :' ParamType [=' Expr]

    ClsParamClauses ::= {ClsParamClause} (' implicit' ClsParams )'] ClsParamClause ::= [nl] (' [ClsParams] ')' ClsParams ::= ClsParam {' ClsParam} ClsParam ::= {Annotation} [{Modifier} (val' | var') | inline'] Param DefParamClauses ::= {DefParamClause} (' implicit' DefParams )'] DefParamClause ::= [nl] (' [DefParams] ')' DefParams ::= DefParam {,' DefParam} DefParam ::= {Annotation} [inline'] Param Param ::= id :' ParamType [=' Expr]

    Definition Classes
    Parser
  132. def paramType(): ast.untpd.Tree

    ParamType ::= [=>'] ParamValueType

    ParamType ::= [=>'] ParamValueType

    Definition Classes
    Parser
  133. def paramValueType(): ast.untpd.Tree

    ParamValueType ::= Type [*']

    ParamValueType ::= Type [*']

    Definition Classes
    Parser
  134. def parse(): ast.untpd.Tree

    This is the general parse entry point.

    This is the general parse entry point. Overridden by ScriptParser

    Definition Classes
    Parser
  135. def patDefOrDcl(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  136. def path(thisOK: Boolean, finish: (ast.untpd.Tree) ⇒ ast.untpd.Tree = id): ast.untpd.Tree

    Path ::= StableId | [Ident .'] this

    Path ::= StableId | [Ident .'] this

    thisOK

    If true, [Ident .'] this is acceptable as the path. If false, another selection is required after the this.

    finish

    An alternative parse in case the token following a .' is not an identifier. If the alternative does not apply, its tree argument is returned unchanged.

    Definition Classes
    Parser
  137. val pattern: () ⇒ ast.untpd.Tree

    Pattern ::= Pattern1 { |' Pattern1 }

    Pattern ::= Pattern1 { |' Pattern1 }

    Definition Classes
    Parser
  138. def pattern1(): ast.untpd.Tree

    Pattern1 ::= PatVar Ascription | Pattern2

    Pattern1 ::= PatVar Ascription | Pattern2

    Definition Classes
    Parser
  139. val pattern2: () ⇒ ast.untpd.Tree

    Pattern2 ::= [varid @'] InfixPattern

    Pattern2 ::= [varid @'] InfixPattern

    Definition Classes
    Parser
  140. def patternAlts(): List[ast.untpd.Tree]

    Definition Classes
    Parser
  141. def patterns(): List[ast.untpd.Tree]

    Patterns ::= Pattern [,' Pattern]

    Patterns ::= Pattern [,' Pattern]

    Definition Classes
    Parser
  142. def patternsOpt(): List[ast.untpd.Tree]

    Definition Classes
    Parser
  143. var placeholderParams: List[ast.untpd.ValDef]

    The implicit parameters introduced by _ in the current expression.

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

    Definition Classes
    Parser
  144. def posMods(start: Int, mods: Modifiers): Modifiers

    Definition Classes
    Parser
  145. def postfixExpr(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  146. val prefixExpr: () ⇒ ast.untpd.Tree

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

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

    Definition Classes
    Parser
  147. def qualId(): ast.untpd.Tree

    QualId ::= Id {.' Id}

    QualId ::= Id {.' Id}

    Definition Classes
    Parser
  148. def reduceStack(base: List[OpInfo], top: ast.untpd.Tree, prec: Int, leftAssoc: Boolean): ast.untpd.Tree

    Definition Classes
    Parser
  149. def refineStatSeq(): List[ast.untpd.Tree]

    RefineStatSeq ::= RefineStat {semi RefineStat} RefineStat ::= Dcl | (in reality we admit Defs and filter them out afterwards)

    RefineStatSeq ::= RefineStat {semi RefineStat} RefineStat ::= Dcl | (in reality we admit Defs and filter them out afterwards)

    Definition Classes
    Parser
  150. val refinedType: () ⇒ ast.untpd.Tree

    RefinedType ::= WithType {Annotation | [nl] Refinement}

    RefinedType ::= WithType {Annotation | [nl] Refinement}

    Definition Classes
    Parser
  151. def refinedTypeRest(t: ast.untpd.Tree): ast.untpd.Tree

    Definition Classes
    Parser
  152. def refinement(): List[ast.untpd.Tree]

    Refinement ::= {' RefineStatSeq }'

    Refinement ::= {' RefineStatSeq }'

    Definition Classes
    Parser
  153. def selector(t: ast.untpd.Tree): ast.untpd.Tree

    Accept identifier acting as a selector on given tree t.

    Accept identifier acting as a selector on given tree t.

    Definition Classes
    Parser
  154. def selectors(t: ast.untpd.Tree, finish: (ast.untpd.Tree) ⇒ ast.untpd.Tree): ast.untpd.Tree

    Selectors ::= ident { .' ident()

    Selectors ::= ident { .' ident()

    Accept .' separated identifiers acting as a selectors on given tree t.

    finish

    An alternative parse in case the next token is not an identifier. If the alternative does not apply, its tree argument is returned unchanged.

    Definition Classes
    Parser
  155. def selfInvocation(): ast.untpd.Tree

    SelfInvocation ::= this ArgumentExprs {ArgumentExprs}

    SelfInvocation ::= this ArgumentExprs {ArgumentExprs}

    Definition Classes
    Parser
  156. def setLastStatOffset(): Unit

    Definition Classes
    Parser
  157. def simpleExpr(): ast.untpd.Tree

    SimpleExpr ::= new Template | BlockExpr | SimpleExpr1 [_'] SimpleExpr1 ::= literal | xmlLiteral | Path | (' [ExprsInParens] )' | SimpleExpr .' Id | SimpleExpr (TypeArgs | NamedTypeArgs) | SimpleExpr1 ArgumentExprs

    SimpleExpr ::= new Template | BlockExpr | SimpleExpr1 [_'] SimpleExpr1 ::= literal | xmlLiteral | Path | (' [ExprsInParens] )' | SimpleExpr .' Id | SimpleExpr (TypeArgs | NamedTypeArgs) | SimpleExpr1 ArgumentExprs

    Definition Classes
    Parser
  158. def simpleExprRest(t: ast.untpd.Tree, canApply: Boolean = true): ast.untpd.Tree

    Definition Classes
    Parser
  159. val simplePattern: () ⇒ ast.untpd.Tree

    SimplePattern ::= PatVar | Literal | XmlPattern | (' [Patterns] )' | SimplePattern1 [TypeArgs] [ArgumentPatterns] SimplePattern1 ::= Path | {' Block }' | SimplePattern1 .' Id PatVar ::= Id | _'

    SimplePattern ::= PatVar | Literal | XmlPattern | (' [Patterns] )' | SimplePattern1 [TypeArgs] [ArgumentPatterns] SimplePattern1 ::= Path | {' Block }' | SimplePattern1 .' Id PatVar ::= Id | _'

    Definition Classes
    Parser
  160. def simplePatternRest(t: ast.untpd.Tree): ast.untpd.Tree

    Definition Classes
    Parser
  161. def simpleType(): ast.untpd.Tree

    SimpleType ::= SimpleType TypeArgs | SimpleType #' Id | StableId | Path .' type | (' ArgTypes )' | _' TypeBounds | Refinement | Literal

    SimpleType ::= SimpleType TypeArgs | SimpleType #' Id | StableId | Path .' type | (' ArgTypes )' | _' TypeBounds | Refinement | Literal

    Definition Classes
    Parser
  162. def skip(): Unit

    Skip on error to next safe point.

    Skip on error to next safe point. Safe points are:

    • Closing braces, provided they match an opening brace before the error point.
    • Closing parens and brackets, provided they match an opening parent or bracket before the error point and there are no intervening other kinds of parens.
    • Semicolons and newlines, provided there are no intervening braces.
    • Definite statement starts on new lines, provided they are not more indented than the last known statement start before the error point.
    Attributes
    protected
    Definition Classes
    Parser
  163. def skipBraces[T](body: T): T

  164. val source: SourceFile

    Definition Classes
    ParserCommon
  165. def sourcePos(off: Int = in.offset): SourcePosition

    Definition Classes
    ParserCommon
  166. def stableId(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  167. object symbXMLBuilder extends SymbolicXMLBuilder

    Definition Classes
    Parser
  168. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  169. def syntaxError(msg: ⇒ Message, pos: Position): Unit

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

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

    Definition Classes
    ParserCommon
  170. def syntaxError(msg: ⇒ Message, offset: Int = in.offset): 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.

    Definition Classes
    ParserCommon
  171. def syntaxErrorOrIncomplete(msg: ⇒ Message): Unit

    If at end of file, issue an incompleteInputError.

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

    Definition Classes
    Parser
  172. def template(constr: ast.untpd.DefDef): (ast.untpd.Template, Boolean)

    Template ::= ConstrApps [TemplateBody] | TemplateBody ConstrApps ::= ConstrApp {with' ConstrApp}

    Template ::= ConstrApps [TemplateBody] | TemplateBody ConstrApps ::= ConstrApp {with' ConstrApp}

    returns

    a pair consisting of the template, and a boolean which indicates whether the template misses a body (i.e. no {...} part).

    Definition Classes
    Parser
  173. def templateBody(): (ast.untpd.ValDef, List[ast.untpd.Thicket])

    Definition Classes
    OutlineParserParser
  174. def templateBodyOpt(constr: ast.untpd.DefDef, parents: List[ast.untpd.Tree]): ast.untpd.Template

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

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

    Definition Classes
    Parser
  175. def templateOpt(constr: ast.untpd.DefDef): ast.untpd.Template

    TemplateOpt = [extends' Template | TemplateBody]

    TemplateOpt = [extends' Template | TemplateBody]

    Definition Classes
    Parser
  176. def templateStatSeq(): (ast.untpd.ValDef, List[ast.untpd.Tree])

    TemplateStatSeq ::= [id [:' Type] =>'] TemplateStat {semi TemplateStat} TemplateStat ::= Import | Annotations Modifiers Def | Annotations Modifiers Dcl | Expr1 | super ArgumentExprs {ArgumentExprs} |

    TemplateStatSeq ::= [id [:' Type] =>'] TemplateStat {semi TemplateStat} TemplateStat ::= Import | Annotations Modifiers Def | Annotations Modifiers Dcl | Expr1 | super ArgumentExprs {ArgumentExprs} |

    Definition Classes
    Parser
  177. def termIdent(): ast.untpd.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.

    Definition Classes
    Parser
  178. def termIdentOrWildcard(): ast.untpd.Ident

    Definition Classes
    Parser
  179. def tmplDef(start: Int, mods: Modifiers): ast.untpd.Tree

    TmplDef ::= ([case'] class' | trait') ClassDef | [case'] object' ObjectDef

    TmplDef ::= ([case'] class' | trait') ClassDef | [case'] object' ObjectDef

    Definition Classes
    Parser
  180. def toString(): String

    Definition Classes
    AnyRef → Any
  181. def tokenSeparated[T](separator: Int, part: () ⇒ T): List[T]

    part { separator part }

    part { separator part }

    Definition Classes
    Parser
  182. def topStatSeq(): List[ast.untpd.Tree]

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

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

    Definition Classes
    Parser
  183. def toplevelTyp(): ast.untpd.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.

    Definition Classes
    Parser
  184. def typ(): ast.untpd.Tree

    Type ::= FunArgTypes =>' Type | HkTypeParamClause ->' Type | InfixType FunArgTypes ::= InfixType | (' [ FunArgType {,' FunArgType } ] )'

    Type ::= FunArgTypes =>' Type | HkTypeParamClause ->' Type | InfixType FunArgTypes ::= InfixType | (' [ FunArgType {,' FunArgType } ] )'

    Definition Classes
    Parser
  185. def typeArgs(namedOK: Boolean = false): List[ast.untpd.Tree]

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

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

    Definition Classes
    Parser
  186. def typeBounds(): ast.untpd.TypeBoundsTree

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

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

    Definition Classes
    Parser
  187. def typeDefOrDcl(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): ast.untpd.Tree

    TypeDef ::= type Id [TypeParamClause] =' Type TypeDcl ::= type Id [TypeParamClause] TypeBounds

    TypeDef ::= type Id [TypeParamClause] =' Type TypeDcl ::= type Id [TypeParamClause] TypeBounds

    Definition Classes
    Parser
  188. def typeDependingOn(location: Location.Value): ast.untpd.Tree

    Definition Classes
    Parser
  189. def typeIdent(): ast.untpd.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.

    Definition Classes
    Parser
  190. def typeParamBounds(pname: TypeName): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  191. def typeParamClause(ownerKind: ParamOwner.Value): List[ast.untpd.TypeDef]

    ClsTypeParamClause::= [' ClsTypeParam {,' ClsTypeParam} ]' ClsTypeParam ::= {Annotation} [{Modifier} type] [+' | -'] Id [HkTypeParamClause] TypeParamBounds

    ClsTypeParamClause::= [' ClsTypeParam {,' ClsTypeParam} ]' ClsTypeParam ::= {Annotation} [{Modifier} type] [+' | -'] Id [HkTypeParamClause] TypeParamBounds

    DefTypeParamClause::= [' DefTypeParam {,' DefTypeParam} ]' DefTypeParam ::= {Annotation} Id [HkTypeParamClause] TypeParamBounds

    TypTypeParamCaluse::= [' TypTypeParam {,' TypTypeParam} ]' TypTypeParam ::= {Annotation} Id [HkTypePamClause] TypeBounds

    HkTypeParamClause ::= [' HkTypeParam {,' HkTypeParam} ]' HkTypeParam ::= {Annotation} ['+' | -'] (Id[HkTypePamClause] | _') TypeBounds

    Definition Classes
    Parser
  192. def typeParamClauseOpt(ownerKind: ParamOwner.Value): List[ast.untpd.TypeDef]

    Definition Classes
    Parser
  193. def typedOpt(): ast.untpd.Tree

    Definition Classes
    Parser
  194. def unsupported(methodName: String): Nothing

    Throws an UnsupportedOperationException with the given method name.

    Throws an UnsupportedOperationException with the given method name.

    Definition Classes
    DotClass
  195. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  196. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  197. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  198. def warning(msg: ⇒ Message, offset: Int = in.offset): Unit

    Definition Classes
    Parser
  199. def warning(msg: ⇒ Message, sourcePos: SourcePosition): Unit

    Definition Classes
    Parser
  200. def wildcardIdent(): ast.untpd.Ident

    Definition Classes
    Parser
  201. def withType(): ast.untpd.Tree

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

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

    Definition Classes
    Parser
  202. def withTypeRest(t: ast.untpd.Tree): ast.untpd.Tree

    Definition Classes
    Parser
  203. def wrapNew(tpt: ast.untpd.Tree): ast.untpd.Select

    Wrap annotation or constructor in New(...).<init>

    Wrap annotation or constructor in New(...).<init>

    Definition Classes
    Parser
  204. def xmlLiteral(): ast.untpd.Tree

    Definition Classes
    Parser
  205. def xmlLiteralPattern(): ast.untpd.Tree

    Definition Classes
    Parser
  206. lazy val xmlp: MarkupParser

    the markup parser

    the markup parser

    Definition Classes
    Parser

Inherited from Parser

Inherited from ParserCommon

Inherited from DotClass

Inherited from AnyRef

Inherited from Any

Ungrouped