scala.tools.nsc.ast.parser.Parsers

# Parser

#### abstract class Parser extends ParserCommon

Self Type
  Parser
Source
  Parsers.scala

Linear Supertypes
Parsers.ParserCommon, AnyRef, Any
Known Subclasses
OutlineParser, QuasiquoteParser, SourceFileParser, UnitParser
Type Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Parser
2. ParserCommon
3. AnyRef
4. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show all

Learn more about member selection
Visibility

1. Public
2. All

### Instance Constructors

1. #### new Parser()

### Type Members

1. #### class ParserTreeBuilder extends TreeBuilder

2. #### trait PatternContextSensitive extends AnyRef

   Methods which implicitly propagate the context in which they were called: either in a pattern context or not.

   Methods which implicitly propagate the context in which they were called: either in a pattern context or not. Formerly, this was threaded through numerous methods as boolean isPattern.

3. #### trait SeqContextSensitive extends PatternContextSensitive

   Methods which implicitly propagate whether the initial call took place in a context where sequences are allowed.

   Methods which implicitly propagate whether the initial call took place in a context where sequences are allowed. Formerly, this was threaded through methods as boolean seqOK.

### Abstract Value Members

1. #### abstract def deprecationWarning(off: Parsers.Offset, msg: String): Unit

   Definition Classes
     ParserCommon

2. #### abstract val in: Parsers.Scanner

   Definition Classes
     Parser → ParserCommon

3. #### abstract def incompleteInputError(msg: String): Unit

4. #### abstract def parseStartRule: () ⇒ Global.Tree

5. #### abstract def source: SourceFile

6. #### abstract def syntaxError(offset: Parsers.Offset, msg: String): Unit

7. #### abstract def unit: Global.CompilationUnit

8. #### abstract def warning(offset: Parsers.Offset, msg: String): Unit

9. #### abstract def xmlLiteral(): Global.Tree

10. #### abstract def xmlLiteralPattern(): Global.Tree

### Concrete Value Members

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

   Definition Classes
     AnyRef → Any

2. #### final def ##(): Int

   Definition Classes
     AnyRef → Any

3. #### def +(other: String): String

   Implicit information
     This member is added by an implicit conversion from Parser to any2stringadd[Parser] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd

4. #### def ->[B](y: B): (Parser, B)

   Implicit information
     This member is added by an implicit conversion from Parser to ArrowAssoc[Parser] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()

5. #### final def ==(arg0: Any): Boolean

   Definition Classes
     AnyRef → Any

6. #### object InfixMode extends Enumeration

   Modes for infix types.

7. #### def accept(token: Parsers.Token): Parsers.Offset

   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.

   Definition Classes
     Parser → ParserCommon

8. #### def acceptStatSep(): Unit

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

9. #### def acceptStatSepOpt(): Unit

10. #### def accessModifierOpt(): Global.Modifiers

        AccessModifier ::= (private | protected) [AccessQualifier]

11. #### def accessQualifierOpt(mods: Global.Modifiers): Global.Modifiers

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

12. #### def annotTypeRest(t: Global.Tree): Global.Tree

13. #### def annotationExpr(): Global.Tree

14. #### def annotations(skipNewLines: Boolean): List[Global.Tree]

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

15. #### def argumentExprs(): List[Global.Tree]

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

16. #### def argumentPatterns(): List[Global.Tree]

17. #### final def asInstanceOf[T0]: T0

    Definition Classes
      Any

18. #### val assumedClosingParens: Map[Int, Int]

19. #### def atInPos[T <: Global.Tree](t: T): T

20. #### def atPos[T <: Global.Tree](pos: Global.Position)(t: T): T

21. #### def atPos[T <: Global.Tree](start: Parsers.Offset, point: Parsers.Offset, end: Parsers.Offset)(t: T): T

22. #### def atPos[T <: Global.Tree](start: Parsers.Offset, point: Parsers.Offset)(t: T): T

23. #### def atPos[T <: Global.Tree](offset: Parsers.Offset)(t: T): T

24. #### def block(): Global.Tree

        Block ::= BlockStatSeq

    Note

      Return tree does not carry position.

25. #### def blockExpr(): Global.Tree

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

26. #### def blockStatSeq(): List[Global.Tree]

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

27. #### def bound(tok: Parsers.Token): Global.Tree

28. #### def caseBlock(): Global.Tree

29. #### def caseClause(): Global.CaseDef

30. #### def caseClauses(): List[Global.CaseDef]

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

31. #### final def caseSeparated[T](part: ⇒ T): List[T]

    Annotations
      @inline()

32. #### def checkAssoc(offset: Parsers.Offset, op: Global.Name, leftAssoc: Boolean): Unit

33. #### def checkHeadAssoc(leftAssoc: Boolean): Unit

34. #### def checkNoEscapingPlaceholders[T](op: ⇒ T): T

35. #### def checkNotByNameOrVarargs(tpt: Global.Tree): Unit

    Check that type parameter is not by name or repeated.

36. #### def classDef(start: Parsers.Offset, mods: Global.Modifiers): Global.ClassDef

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

37. #### def clone(): AnyRef

    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

38. #### final def commaSeparated[T](part: ⇒ T): List[T]

    Annotations
      @inline()

39. #### def compilationUnit(): Global.PackageDef

        CompilationUnit ::= {package QualId semi} TopStatSeq

40. #### def condExpr(): Global.Tree

41. #### def constrBlock(vparamss: List[List[Global.ValDef]]): Global.Tree

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

42. #### def constrExpr(vparamss: List[List[Global.ValDef]]): Global.Tree

        ConstrExpr      ::=  SelfInvocation
        |  ConstrBlock

43. #### def constructorAnnotations(): List[Global.Tree]

44. #### def convertToParam(tree: Global.Tree): Global.ValDef

    Convert tree to formal parameter.

45. #### def convertToParams(tree: Global.Tree): List[Global.ValDef]

    Convert tree to formal parameter list.

46. #### def convertToTypeId(tree: Global.Tree): Global.Tree

    Convert (qual)ident to type identifier.

47. #### def defOrDcl(pos: Parsers.Offset, mods: Global.Modifiers): List[Global.Tree]

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

48. #### final def dropAnyBraces[T](body: ⇒ T): T

    Definition Classes
      ParserCommon
    Annotations
      @inline()

49. #### def ensureEarlyDef(tree: Global.Tree): Global.Tree

50. #### def ensuring(cond: (Parser) ⇒ Boolean, msg: ⇒ Any): Parser

    Implicit information
      This member is added by an implicit conversion from Parser to Ensuring[Parser] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

51. #### def ensuring(cond: (Parser) ⇒ Boolean): Parser

    Implicit information
      This member is added by an implicit conversion from Parser to Ensuring[Parser] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

52. #### def ensuring(cond: Boolean, msg: ⇒ Any): Parser

    Implicit information
      This member is added by an implicit conversion from Parser to Ensuring[Parser] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

53. #### def ensuring(cond: Boolean): Parser

    Implicit information
      This member is added by an implicit conversion from Parser to Ensuring[Parser] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring

54. #### def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): List[Global.Tree]

55. #### def enumerators(): List[Global.Tree]

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

56. #### final def eq(arg0: AnyRef): Boolean

    Definition Classes
      AnyRef

57. #### def equals(arg0: Any): Boolean

    Definition Classes
      AnyRef → Any

58. #### def errorPatternTree: Global.Ident

59. #### def errorTermTree: Global.Literal

60. #### def errorTypeTree: Global.TypeTree

61. #### def expectedMsg(token: Parsers.Token): String

62. #### def expectedMsgTemplate(exp: String, fnd: String): String

63. #### def expr(location: Location): Global.Tree

64. #### def expr(): Global.Tree

        Expr       ::= (Bindings | [`implicit'] Id | `_')  `=>' Expr
                     | Expr1
        ResultExpr ::= (Bindings | Id `:' CompoundType) `=>' Block
                     | Expr1
        Expr1      ::= if `(' Expr `)' {nl} Expr [[semi] else Expr]
                     | try (`{' Block `}' | Expr) [catch `{' CaseClauses `}'] [finally Expr]
                     | while `(' Expr `)' {nl} Expr
                     | do Expr [semi] while `(' Expr `)'
                     | for (`(' Enumerators `)' | `{' Enumerators `}') {nl} [yield] Expr
                     | throw Expr
                     | return [Expr]
                     | [SimpleExpr `.'] Id `=' Expr
                     | SimpleExpr1 ArgumentExprs `=' Expr
                     | PostfixExpr Ascription
                     | PostfixExpr match `{' CaseClauses `}'
        Bindings   ::= `(' [Binding {`,' Binding}] `)'
        Binding    ::= (Id | `_') [`:' Type]
        Ascription ::= `:' CompoundType
                     | `:' Annotation {Annotation}
                     | `:' `_' `*'

65. #### def expr0(location: Location): Global.Tree

66. #### def exprSimpleType(): Global.Tree

67. #### def exprTypeArgs(): List[Global.Tree]

68. #### def finalize(): Unit

    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )

69. #### def finishBinaryOp(isExpr: Boolean, opinfo: OpInfo, rhs: Global.Tree): Global.Tree

70. #### def finishPostfixOp(start: Int, base: List[OpInfo], opinfo: OpInfo): Global.Tree

71. #### def formatted(fmtstr: String): String

    Implicit information
      This member is added by an implicit conversion from Parser to StringFormat[Parser] performed by method StringFormat in scala.Predef.
    Definition Classes
      StringFormat
    Annotations
      @inline()

72. #### implicit def fresh: FreshNameCreator

73. #### def funDefOrDcl(start: Int, mods: Global.Modifiers): Global.Tree

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

74. #### def funDefRest(start: Parsers.Offset, nameOffset: Parsers.Offset, mods: Global.Modifiers, name: Global.Name): Global.Tree

75. #### def generator(eqOK: Boolean, allowNestedIf: Boolean = true): List[Global.Tree]

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

76. #### final def getClass(): Class[_]

    Definition Classes
      AnyRef → Any

77. #### def guard(): Global.Tree

        Guard ::= if PostfixExpr

78. #### def hashCode(): Int

    Definition Classes
      AnyRef → Any

79. #### def ident(): Global.Name

80. #### def ident(skipIt: Boolean): Global.Name

    Assumed (provisionally) to be TermNames.

81. #### def identForType(skipIt: Boolean): Global.TypeName

82. #### def identForType(): Global.TypeName

    For when it's known already to be a type name.

83. #### def identOrMacro(): Global.Name

84. #### def implicitClosure(start: Parsers.Offset, location: Location): Global.Tree

        Expr ::= implicit Id => Expr

85. #### def importClause(): List[Global.Tree]

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

86. #### def importExpr(): Global.Tree

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

87. #### def importSelector(): Global.ImportSelector

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

88. #### def importSelectors(): List[Global.ImportSelector]

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

89. #### final def inBraces[T](body: ⇒ T): T

    Definition Classes
      ParserCommon
    Annotations
      @inline()

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

91. #### final def inBracesOrNil[T](body: ⇒ List[T]): List[T]

    Definition Classes
      ParserCommon
    Annotations
      @inline()

92. #### final def inBracesOrUnit[T](body: ⇒ Global.Tree): Global.Tree

    Definition Classes
      ParserCommon
    Annotations
      @inline()

93. #### final def inBrackets[T](body: ⇒ T): T

    Definition Classes
      ParserCommon
    Annotations
      @inline()

94. #### final def inParens[T](body: ⇒ T): T

    Methods inParensOrError and similar take a second argument which, should the next token not be the expected opener (e.g.

    Methods inParensOrError and similar take a second argument which, should the next token not be the expected opener (e.g. LPAREN) will be returned instead of the contents of the groupers. However in all cases accept(LPAREN) will be called, so a parse error will still result. If the grouping is optional, in.token should be tested before calling these methods.

    Definition Classes
      ParserCommon
    Annotations
      @inline()

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

96. #### final def inParensOrNil[T](body: ⇒ List[T]): List[T]

    Definition Classes
      ParserCommon
    Annotations
      @inline()

97. #### final def inParensOrUnit[T](body: ⇒ Global.Tree): Global.Tree

    Definition Classes
      ParserCommon
    Annotations
      @inline()

98. #### def isAnnotation: Boolean

99. #### def isCaseDefEnd: Boolean

100. #### def isDclIntro: Boolean

101. #### def isDefIntro: Boolean

102. #### def isExprIntro: Boolean

103. #### def isExprIntroToken(token: Parsers.Token): Boolean

104. #### def isIdent: Boolean

105. #### def isIdentExcept(except: Global.Name): Boolean

106. #### def isIdentOf(name: Global.Name): Boolean

107. #### final def isInstanceOf[T0]: Boolean

     Definition Classes
       Any

108. #### def isLiteral: Boolean

109. #### def isLiteralToken(token: Parsers.Token): Boolean

110. #### def isLocalModifier: Boolean

111. #### def isMacro: Boolean

112. #### def isModifier: Boolean

113. #### def isNumericLit: Boolean

114. #### def isRawBar: Boolean

115. #### def isRawIdent: Boolean

116. #### def isRawStar: Boolean

117. #### def isStatSep: Boolean

118. #### def isStatSep(token: Parsers.Token): Boolean

119. #### def isStatSeqEnd: Boolean

120. #### def isTemplateIntro: Boolean

121. #### def isTypeIntroToken(token: Parsers.Token): Boolean

122. #### def isTypedParam(t: Global.Tree): Boolean

123. #### def isUnaryOp: Boolean

124. #### def isWildcard(t: Global.Tree): Boolean

125. #### def joinComment(trees: ⇒ List[Global.Tree]): List[Global.Tree]

     A hook for joining the comment associated with a definition.

     A hook for joining the comment associated with a definition. Overridden by scaladoc.

126. #### def literal(isNegated: Boolean = false, inPattern: Boolean = false, start: Parsers.Offset = in.offset): Global.Tree

         SimpleExpr    ::= literal
         | symbol
         | null

127. #### def localDef(implicitMod: Int): List[Global.Tree]

     overridable IDE hook for local definitions of blockStatSeq Here's an idea how to fill in start and end positions.

     overridable IDE hook for local definitions of blockStatSeq Here's an idea how to fill in start and end positions. def localDef : List[Tree] = { atEndPos { atStartPos(in.offset) { val annots = annotations(skipNewLines = true) val mods = localModifiers() withAnnotations annots if (!(mods hasFlag ~(Flags.IMPLICIT | Flags.LAZY))) defOrDcl(mods) else List(tmplDef(mods)) } } (in.offset) }

128. #### def localModifiers(): Global.Modifiers

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

129. #### final def lookingAhead[T](body: ⇒ T): T

     Scoping operator used to temporarily look into the future.

     Scoping operator used to temporarily look into the future. Backs up scanner data before evaluating a block and restores it after.

     Annotations
       @inline()

130. #### def makeEmptyPackage(start: Parsers.Offset, stats: List[Global.Tree]): Global.PackageDef

131. #### def makeFilter(start: Parsers.Offset, tree: Global.Tree): Global.Apply

132. #### def makePackageObject(start: Parsers.Offset, objDef: Global.ModuleDef): Global.PackageDef

133. #### def makePackaging(start: Parsers.Offset, pkg: Global.Tree, stats: List[Global.Tree]): Global.PackageDef

     Create a tree representing a packaging.

134. #### final def makeParens(body: ⇒ List[Global.Tree]): Global.Parens

     Creates an actual Parens node (only used during parsing.)

     Creates an actual Parens node (only used during parsing.)

     Definition Classes
       ParserCommon
     Annotations
       @inline()

135. #### def mixinQualifierOpt(): Global.TypeName

         MixinQualifier ::= `[' Id `]'

136. #### def modifiers(): Global.Modifiers

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

137. #### def multipleArgumentExprs(): List[List[Global.Tree]]

     A succession of argument lists.

138. #### final def ne(arg0: AnyRef): Boolean

     Definition Classes
       AnyRef

139. #### def newLineOpt(): Unit

140. #### def newLineOptWhenFollowedBy(token: Parsers.Offset): Unit

141. #### def newLineOptWhenFollowing(p: (Parsers.Token) ⇒ Boolean): Unit

142. #### def newLinesOpt(): Unit

143. #### object noSeq extends SeqContextSensitive

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

144. #### def nonLocalDefOrDcl: List[Global.Tree]

145. #### final def notify(): Unit

     Definition Classes
       AnyRef

146. #### final def notifyAll(): Unit

     Definition Classes
       AnyRef

147. #### def o2p(offset: Parsers.Offset): Global.Position

148. #### def objectDef(start: Parsers.Offset, mods: Global.Modifiers): Global.ModuleDef

         ObjectDef       ::= Id ClassTemplateOpt

149. #### var opstack: List[OpInfo]

150. #### object outPattern extends PatternContextSensitive

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

151. #### def packageObjectDef(start: Parsers.Offset): Global.PackageDef

     Create a tree representing a package object, converting

     Create a tree representing a package object, converting

         package object foo { ... }

     to

         package foo {
         object `package` { ... }
         }

152. #### def packageOrPackageObject(start: Parsers.Offset): Global.Tree

153. #### def param(owner: Global.Name, implicitmod: Int, caseParam: Boolean): Global.ValDef

154. #### def paramClauses(owner: Global.Name, contextBounds: List[Global.Tree], ofCaseClass: Boolean): List[List[Global.ValDef]]

         ParamClauses      ::= {ParamClause} [[nl] `(' implicit Params `)']
         ParamClause       ::= [nl] `(' [Params] `)'
         Params            ::= Param {`,' Param}
         Param             ::= {Annotation} Id [`:' ParamType] [`=' Expr]
         ClassParamClauses ::= {ClassParamClause} [[nl] `(' implicit ClassParams `)']
         ClassParamClause  ::= [nl] `(' [ClassParams] `)'
         ClassParams       ::= ClassParam {`,' ClassParam}
         ClassParam        ::= {Annotation}  [{Modifier} (`val' | `var')] Id [`:' ParamType] [`=' Expr]

155. #### def paramType(useStartAsPosition: Boolean): Global.Tree

156. #### def paramType(): Global.Tree

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

157. #### def parse(): Global.Tree

     This is the general parse entry point.

158. #### def parseRule[T](rule: (Parser.this.type) ⇒ T): T

159. #### def parseStats(): List[Global.Tree]

     These are alternative entry points for repl, script runner, toolbox and parsing in macros.

160. #### def parseStatsOrPackages(): List[Global.Tree]

161. #### def patDefOrDcl(pos: Int, mods: Global.Modifiers): List[Global.Tree]

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

162. #### def path(thisOK: Boolean, typeOK: Boolean): Global.Tree

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

163. #### def pattern(): Global.Tree

     Default entry points into some pattern contexts.

164. #### def peekingAhead(tree: ⇒ Global.Tree): Global.Tree

     Perform an operation while peeking ahead.

     Perform an operation while peeking ahead. Pushback if the operation yields an empty tree or blows to pieces.

     Annotations
       @inline()

165. #### var placeholderParams: List[Global.ValDef]

     The implicit parameters introduced by `_` in the current expression.

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

166. #### def placeholderTypeBoundary(op: ⇒ Global.Tree): Global.Tree

167. #### var placeholderTypes: List[Global.TypeDef]

     The placeholderTypes introduced by `_` in the current type.

     The placeholderTypes introduced by `_` in the current type. Parameters appear in reverse order.

168. #### def postfixExpr(): Global.Tree

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

169. #### def prefixExpr(): Global.Tree

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

170. #### def qualId(): Global.Tree

         QualId ::= Id {`.' Id}

171. #### def r2p(offset: Parsers.Offset): Global.Position

172. #### def r2p(start: Parsers.Offset, mid: Parsers.Offset): Global.Position

173. #### def r2p(start: Parsers.Offset, mid: Parsers.Offset, end: Parsers.Offset): Global.Position

174. #### def rawIdent(): Global.Name

175. #### def readAnnots(part: ⇒ Global.Tree): List[Global.Tree]

176. #### def reduceExprStack(base: List[OpInfo], top: Global.Tree): Global.Tree

177. #### def reducePatternStack(base: List[OpInfo], top: Global.Tree): Global.Tree

178. #### def reduceStack(isExpr: Boolean, base: List[OpInfo], top: Global.Tree, opPrecedence: Precedence, leftAssoc: Boolean): Global.Tree

179. #### def reduceStack(isExpr: Boolean, base: List[OpInfo], top: Global.Tree): Global.Tree

180. #### def refineStat(): List[Global.Tree]

181. #### def refineStatSeq(): List[Global.Tree]

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

182. #### def refinement(): List[Global.Tree]

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

183. #### def resetPackage(): Unit

184. #### def scriptBody(): Global.Tree

     This is the parse entry point for code which is not self-contained, e.g.

     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().

185. #### def selector(t: Global.Tree): Global.Tree

186. #### def selectors(t: Global.Tree, typeOK: Boolean, dotOffset: Parsers.Offset): Global.Tree

187. #### def selfInvocation(vparamss: List[List[Global.ValDef]]): Global.Tree

         SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

188. #### object seqOK extends SeqContextSensitive

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

189. #### def seqPatterns(): List[Global.Tree]

190. #### def setInPos[T <: Global.Tree](t: T): T

191. #### def simpleExpr(): Global.Tree

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

192. #### def simpleExprRest(t: Global.Tree, canApply: Boolean): Global.Tree

193. #### def skip(targetToken: Parsers.Token): Unit

     Attributes
       protected

194. #### def stableId(): Global.Tree

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

195. #### def startAnnotType(): Global.Tree

196. #### def startInfixType(): Global.Tree

197. #### def statSeq(stat: PartialFunction[Parsers.Token, List[Global.Tree]], errorMsg: String = "illegal start of definition"): List[Global.Tree]

198. #### def statement(location: Location): Global.Tree

199. #### final def synchronized[T0](arg0: ⇒ T0): T0

     Definition Classes
       AnyRef

200. #### def syntaxError(offset: Parsers.Offset, msg: String, skipIt: Boolean): Unit

201. #### def syntaxError(msg: String, skipIt: Boolean): Unit

202. #### def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean): Unit

203. #### def syntaxErrorOrIncompleteAnd[T](msg: String, skipIt: Boolean)(and: T): T

204. #### def template(): (List[Global.Tree], Global.ValDef, List[Global.Tree])

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

205. #### def templateBody(isPre: Boolean): (Global.ValDef, List[Global.Tree])

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

     isPre

       specifies whether in early initializer (true) or not (false)

206. #### def templateBodyOpt(parenMeansSyntaxError: Boolean): (Global.ValDef, List[Global.Tree])

207. #### def templateOpt(mods: Global.Modifiers, name: Global.Name, constrMods: Global.Modifiers, vparamss: List[List[Global.ValDef]], tstart: Parsers.Offset): Global.Template

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

208. #### def templateOrTopStatSeq(): List[Global.Tree]

209. #### def templateParents(): List[Global.Tree]

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

210. #### def templateStat: PartialFunction[Parsers.Token, List[Global.Tree]]

211. #### def templateStatSeq(isPre: Boolean): (Global.ValDef, List[Global.Tree])

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

     isPre

       specifies whether in early initializer (true) or not (false)

212. #### def templateStats(): List[Global.Tree]

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

213. #### def tmplDef(pos: Parsers.Offset, mods: Global.Modifiers): Global.Tree

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

214. #### def toString(): String

     Definition Classes
       AnyRef → Any

215. #### final def tokenSeparated[T](separator: Parsers.Token, sepFirst: Boolean, part: ⇒ T): List[T]

     ,or if sepFirst is true,

         part { `sep` part }

     ,or if sepFirst is true,

         { `sep` part }

     . { `sep` part } }}} part { `sep` part } }}}

216. #### def topLevelTmplDef: Global.Tree

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

217. #### def topStat: PartialFunction[Parsers.Token, List[Global.Tree]]

218. #### def topStatSeq(): List[Global.Tree]

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

219. #### val treeBuilder: ParserTreeBuilder

220. #### def typ(): Global.Tree

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

221. #### def typeBounds(): Global.TypeBoundsTree

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

222. #### def typeDefOrDcl(start: Parsers.Offset, mods: Global.Modifiers): Global.Tree

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

223. #### def typeOrInfixType(location: Location): Global.Tree

224. #### def typeParamClauseOpt(owner: Global.Name, contextBoundBuf: ListBuffer[Global.Tree]): List[Global.TypeDef]

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

225. #### def typedOpt(): Global.Tree

         TypedOpt ::= [`:' Type]

226. #### final def wait(): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

228. #### final def wait(arg0: Long): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

229. #### def warning(msg: String): Unit

230. #### def wildcardOrIdent(): Global.Name

231. #### def wildcardType(start: Parsers.Offset): Global.Ident

         WildcardType ::= `_' TypeBounds

232. #### object xmlSeqOK extends SeqContextSensitive

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

233. #### def xmlSeqPatterns(): List[Global.Tree]

234. #### def →[B](y: B): (Parser, B)

     Implicit information
       This member is added by an implicit conversion from Parser to ArrowAssoc[Parser] performed by method ArrowAssoc in scala.Predef.
     Definition Classes
       ArrowAssoc

### Deprecated Value Members

1. #### def precedence(operator: Global.Name): Int

   Annotations
     @deprecated
   Deprecated

     (Since version 2.11.0) Use `scala.reflect.internal.Precedence`

### Inherited from Parsers.ParserCommon

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from Parser to any2stringadd[Parser]

### Inherited by implicit conversion StringFormat from Parser to StringFormat[Parser]

### Inherited by implicit conversion Ensuring from Parser to Ensuring[Parser]

### Inherited by implicit conversion ArrowAssoc from Parser to ArrowAssoc[Parser]

### Ungrouped