OutlineParser

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

    OutlineParser → Parser

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

    Parser → ParserCommon

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

     OutlineParser → Parser

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