Scala Compiler2.12.2-20170504-135222-21d12e9 < Back
 

# Packages

-  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package tools
  Definition Classes
    scala
-  package nsc
  Definition Classes
    tools
-  package ast
  Definition Classes
    nsc
-  package parser
  Definition Classes
    ast
-  trait Parsers extends Scanners with MarkupParsers with ParsersCommon

  Performs the following context-free rewritings:

  Performs the following context-free rewritings:

  - Places all pattern variables in Bind nodes. In a pattern, for identifiers `x`:

                      x  => x @ _
                    x:T  => x @ (_ : T)

  - Removes pattern definitions (PatDef's) as follows: If pattern is a simple (typed) identifier:

               val x = e     ==>  val x = e
               val x: T = e  ==>  val x: T = e

  if there are no variables in pattern

             val p = e  ==>  e match (case p => ())

  if there is exactly one variable in pattern

             val x_1 = e match (case p => (x_1))

  if there is more than one variable in pattern

             val p = e  ==>  private synthetic val t$ = e match (case p => (x_1, ..., x_N))
                             val x_1 = t$._1
                             ...
                             val x_N = t$._N

  - Removes function types as follows:

             (argtpes) => restpe   ==>   scala.Function_n[argtpes, restpe]

  - Wraps naked case definitions in a match as follows:

             { cases }   ==>   (x => x.match {cases}), except when already argument to match

  Definition Classes
    parser
- CommonTokenData
- ConfusedAboutBracesControl
- DocScanner
- MalformedInput
- MarkupParser
- MissingEndTagControl
- OpInfo
- OutlineParser
- ParensAnalyzer
- Parser
- ParserCommon
- Scanner
- ScannerCommon
- ScannerData
- SourceFileParser
- SourceFileScanner
- TokenData
- TruncatedXMLControl
- UnitParser
- UnitScanner

c

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
QuasiquoteParser, OutlineParser, SourceFileParser, UnitParser, ScaladocUnitParser
Type Hierarchy
 
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

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, since: 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
     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
     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.  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
7.  def acceptStatSep(): Unit

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

8.  def acceptStatSepOpt(): Unit
9.  def accessModifierOpt(): Global.Modifiers

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

10.  def accessQualifierOpt(mods: Global.Modifiers): Global.Modifiers

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

11.  def annotTypeRest(t: Global.Tree): Global.Tree
12.  def annotationExpr(): Global.Tree
13.  def annotations(skipNewLines: Boolean): List[Global.Tree]

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

14.  def argumentExprs(): List[Global.Tree]

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

15.  def argumentPatterns(): List[Global.Tree]
16.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
17.  val assumedClosingParens: Map[Int, Int]
18.  def atInPos[T <: Global.Tree](t: T): T
19.  def atPos[T <: Global.Tree](pos: Global.Position)(t: T): T
20.  def atPos[T <: Global.Tree](start: Parsers.Offset, point: Parsers.Offset, end: Parsers.Offset)(t: T): T
21.  def atPos[T <: Global.Tree](start: Parsers.Offset, point: Parsers.Offset)(t: T): T
22.  def atPos[T <: Global.Tree](offset: Parsers.Offset)(t: T): T
23.  def block(): Global.Tree

        Block ::= BlockStatSeq

    Note

      Return tree does not carry position.

24.  def blockExpr(): Global.Tree

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

25.  def blockStatSeq(): List[Global.Tree]

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

26.  def bound(tok: Parsers.Token): Global.Tree
27.  def caseBlock(): Global.Tree
28.  def caseClause(): Global.CaseDef
29.  def caseClauses(): List[Global.CaseDef]

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

30.  final def caseSeparated[T](part: ⇒ T): List[T]
    Annotations
      @inline()
31.  def checkAssoc(offset: Parsers.Offset, op: Global.Name, leftAssoc: Boolean): Unit
32.  def checkHeadAssoc(leftAssoc: Boolean): Unit
33.  def checkNoEscapingPlaceholders[T](op: ⇒ T): T
34.  def checkNotByNameOrVarargs(tpt: Global.Tree): Unit

    Check that type parameter is not by name or repeated.

35.  def classDef(start: Parsers.Offset, mods: Global.Modifiers): Global.ClassDef

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

36.  def clone(): AnyRef
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
37.  final def commaSeparated[T](part: ⇒ T): List[T]
    Annotations
      @inline()
38.  def compilationUnit(): Global.PackageDef

        CompilationUnit ::= {package QualId semi} TopStatSeq

39.  def condExpr(): Global.Tree
40.  def constrBlock(vparamss: List[List[Global.ValDef]]): Global.Tree

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

41.  def constrExpr(vparamss: List[List[Global.ValDef]]): Global.Tree

        ConstrExpr      ::=  SelfInvocation
                          |  ConstrBlock

42.  def constructorAnnotations(): List[Global.Tree]
43.  def convertToParam(tree: Global.Tree): Global.ValDef

    Convert tree to formal parameter.

44.  def convertToParams(tree: Global.Tree): List[Global.ValDef]

    Convert tree to formal parameter list.

45.  def convertToTypeId(tree: Global.Tree): Global.Tree

    Convert (qual)ident to type identifier.

46.  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

47.  final def dropAnyBraces[T](body: ⇒ T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
48.  def ensureEarlyDef(tree: Global.Tree): Global.Tree
49.  def ensuring(cond: (Parser) ⇒ Boolean, msg: ⇒ Any): Parser
    Implicit
      This member is added by an implicit conversion from Parser to Ensuring[Parser] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
50.  def ensuring(cond: (Parser) ⇒ Boolean): Parser
    Implicit
      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: Boolean, msg: ⇒ Any): Parser
    Implicit
      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): Parser
    Implicit
      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 enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): List[Global.Tree]
54.  def enumerators(): List[Global.Tree]

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

55.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
56.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
57.  def errorPatternTree: Global.Ident
58.  def errorTermTree: Global.Literal
59.  def errorTypeTree: Global.TypeTree
60.  def expectedMsg(token: Parsers.Token): String
61.  def expectedMsgTemplate(exp: String, fnd: String): String
62.  def expr(location: Location): Global.Tree
63.  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}
                     | `:' `_' `*'

64.  def expr0(location: Location): Global.Tree
65.  def exprSimpleType(): Global.Tree
66.  def exprTypeArgs(): List[Global.Tree]
67.  def finalize(): Unit
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
68.  def finishBinaryOp(isExpr: Boolean, opinfo: OpInfo, rhs: Global.Tree): Global.Tree
69.  def finishPostfixOp(start: Int, base: List[OpInfo], opinfo: OpInfo): Global.Tree
70.  def formatted(fmtstr: String): String
    Implicit
      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()
71.  implicit def fresh: FreshNameCreator
72.  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

73.  def funDefRest(start: Parsers.Offset, nameOffset: Parsers.Offset, mods: Global.Modifiers, name: Global.Name): Global.Tree
74.  def generator(eqOK: Boolean, allowNestedIf: Boolean = true): List[Global.Tree]

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

75.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
76.  def guard(): Global.Tree

        Guard ::= if PostfixExpr

77.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
78.  def ident(): Global.Name
79.  def ident(skipIt: Boolean): Global.Name

    Assumed (provisionally) to be TermNames.

80.  def identForType(skipIt: Boolean): Global.TypeName
81.  def identForType(): Global.TypeName

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

82.  def identOrMacro(): Global.Name
83.  def implicitClosure(start: Parsers.Offset, location: Location): Global.Tree

        Expr ::= implicit Id => Expr

84.  def importClause(): List[Global.Tree]

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

85.  def importExpr(): Global.Tree

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

86.  def importSelector(): Global.ImportSelector

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

87.  def importSelectors(): List[Global.ImportSelector]

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

88.  final def inBraces[T](body: ⇒ T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
89.  final def inBracesOrError[T](body: ⇒ T, alt: T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
90.  final def inBracesOrNil[T](body: ⇒ List[T]): List[T]
    Definition Classes
      ParserCommon
    Annotations
      @inline()
91.  final def inBracesOrUnit[T](body: ⇒ Global.Tree): Global.Tree
    Definition Classes
      ParserCommon
    Annotations
      @inline()
92.  final def inBrackets[T](body: ⇒ T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
93.  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()
94.  final def inParensOrError[T](body: ⇒ T, alt: T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
95.  final def inParensOrNil[T](body: ⇒ List[T]): List[T]
    Definition Classes
      ParserCommon
    Annotations
      @inline()
96.  final def inParensOrUnit[T](body: ⇒ Global.Tree): Global.Tree
    Definition Classes
      ParserCommon
    Annotations
      @inline()
97.  def isAnnotation: Boolean
98.  def isCaseDefEnd: Boolean
99.  def isDclIntro: Boolean
100.  def isDefIntro: Boolean
101.  def isExprIntro: Boolean
102.  def isExprIntroToken(token: Parsers.Token): Boolean
103.  def isIdent: Boolean
104.  def isIdentExcept(except: Global.Name): Boolean
105.  def isIdentOf(name: Global.Name): Boolean
106.  final def isInstanceOf[T0]: Boolean
     Definition Classes
       Any
107.  def isLiteral: Boolean
108.  def isLiteralToken(token: Parsers.Token): Boolean
109.  def isLocalModifier: Boolean
110.  def isMacro: Boolean
111.  def isModifier: Boolean
112.  def isNumericLit: Boolean
113.  def isRawBar: Boolean
114.  def isRawIdent: Boolean
115.  def isRawStar: Boolean
116.  def isSimpleExprIntro: Boolean
117.  def isSimpleExprIntroToken(token: Parsers.Token): Boolean
118.  def isStatSep: Boolean
119.  def isStatSep(token: Parsers.Token): Boolean
120.  def isStatSeqEnd: Boolean
121.  def isTemplateIntro: Boolean
122.  def isTypeIntroToken(token: Parsers.Token): Boolean
123.  def isTypedParam(t: Global.Tree): Boolean
124.  def isUnaryOp: Boolean
125.  def isWildcard(t: Global.Tree): Boolean
126.  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.

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

         SimpleExpr    ::= literal
                         | symbol
                         | null

128.  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) }

129.  def localModifiers(): Global.Modifiers

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

130.  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()
131.  def makeBinop(isExpr: Boolean, left: Global.Tree, op: Global.TermName, right: Global.Tree, opPos: Global.Position, targs: List[Global.Tree] = Nil): Global.Tree

     Create tree representing (unencoded) binary operation expression or pattern.

132.  def makeEmptyPackage(start: Parsers.Offset, stats: List[Global.Tree]): Global.PackageDef
133.  def makeFilter(start: Parsers.Offset, tree: Global.Tree): Global.Apply
134.  def makePackageObject(start: Parsers.Offset, objDef: Global.ModuleDef): Global.PackageDef
135.  def makePackaging(start: Parsers.Offset, pkg: Global.Tree, stats: List[Global.Tree]): Global.PackageDef

     Create a tree representing a packaging.

136.  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()
137.  def makeSafeTupleTerm(elems: List[Global.Tree], offset: Parsers.Offset): Global.Tree

     Create a tuple term Tree.

     Create a tuple term Tree. If the arity is not supported, a syntax error is emitted.

138.  def makeSafeTupleType(elems: List[Global.Tree], offset: Parsers.Offset): Global.Tree

     Create a tuple type Tree.

     Create a tuple type Tree. If the arity is not supported, a syntax error is emitted.

139.  def mixinQualifierOpt(): Global.TypeName

         MixinQualifier ::= `[' Id `]'

140.  def modifiers(): Global.Modifiers

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

141.  def multipleArgumentExprs(): List[List[Global.Tree]]

     A succession of argument lists.

142.  final def ne(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
143.  def newLineOpt(): Unit
144.  def newLineOptWhenFollowedBy(token: Parsers.Offset): Unit
145.  def newLineOptWhenFollowing(p: (Parsers.Token) ⇒ Boolean): Unit
146.  def newLinesOpt(): Unit
147.  def nonLocalDefOrDcl: List[Global.Tree]
148.  final def notify(): Unit
     Definition Classes
       AnyRef
149.  final def notifyAll(): Unit
     Definition Classes
       AnyRef
150.  def o2p(offset: Parsers.Offset): Global.Position
151.  def objectDef(start: Parsers.Offset, mods: Global.Modifiers): Global.ModuleDef

         ObjectDef       ::= Id ClassTemplateOpt

152.  var opstack: List[OpInfo]
153.  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` { ... }
         }

154.  def packageOrPackageObject(start: Parsers.Offset): Global.Tree
155.  def param(owner: Global.Name, implicitmod: Int, caseParam: Boolean): Global.ValDef
156.  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]

157.  def paramType(useStartAsPosition: Boolean): Global.Tree
158.  def paramType(): Global.Tree

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

159.  def parse(): Global.Tree

     This is the general parse entry point.

160.  def parseRule[T](rule: (Parser.this.type) ⇒ T): T
161.  def parseStats(): List[Global.Tree]

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

162.  def parseStatsOrPackages(): List[Global.Tree]
163.  def patDefOrDcl(pos: Int, mods: Global.Modifiers): List[Global.Tree]

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

164.  def path(thisOK: Boolean, typeOK: Boolean): Global.Tree

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

165.  def pattern(): Global.Tree

     Default entry points into some pattern contexts.

166.  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()
167.  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.

168.  def placeholderTypeBoundary(op: ⇒ Global.Tree): Global.Tree
169.  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.

170.  def postfixExpr(): Global.Tree

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

171.  def prefixExpr(): Global.Tree

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

172.  def qualId(): Global.Tree

         QualId ::= Id {`.' Id}

173.  def r2p(offset: Parsers.Offset): Global.Position
174.  def r2p(start: Parsers.Offset, mid: Parsers.Offset): Global.Position
175.  def r2p(start: Parsers.Offset, mid: Parsers.Offset, end: Parsers.Offset): Global.Position
176.  def rawIdent(): Global.Name
177.  def readAnnots(part: ⇒ Global.Tree): List[Global.Tree]
178.  def reduceExprStack(base: List[OpInfo], top: Global.Tree): Global.Tree
179.  def reducePatternStack(base: List[OpInfo], top: Global.Tree): Global.Tree
180.  def reduceStack(isExpr: Boolean, base: List[OpInfo], top: Global.Tree, opPrecedence: Precedence, leftAssoc: Boolean): Global.Tree
181.  def reduceStack(isExpr: Boolean, base: List[OpInfo], top: Global.Tree): Global.Tree
182.  def refineStat(): List[Global.Tree]
183.  def refineStatSeq(): List[Global.Tree]

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

184.  def refinement(): List[Global.Tree]

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

185.  def resetPackage(): Unit
186.  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().

187.  def selector(t: Global.Tree): Global.Tree
188.  def selectors(t: Global.Tree, typeOK: Boolean, dotOffset: Parsers.Offset): Global.Tree
189.  def selfInvocation(vparamss: List[List[Global.ValDef]]): Global.Tree

         SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

190.  def seqPatterns(): List[Global.Tree]
191.  def setInPos[T <: Global.Tree](t: T): T
192.  def simpleExpr(): Global.Tree

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

193.  def simpleExprRest(t: Global.Tree, canApply: Boolean): Global.Tree
194.  def skip(targetToken: Parsers.Token): Unit
     Attributes
       protected
195.  def stableId(): Global.Tree

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

196.  def startAnnotType(): Global.Tree
197.  def startInfixType(): Global.Tree
198.  def statSeq(stat: PartialFunction[Parsers.Token, List[Global.Tree]], errorMsg: String = "illegal start of definition"): List[Global.Tree]
199.  def statement(location: Location): Global.Tree
200.  def stripParens(t: Global.Tree): Global.Tree

     Strip the artificial `Parens` node to create a tuple term Tree.

201.  final def synchronized[T0](arg0: ⇒ T0): T0
     Definition Classes
       AnyRef
202.  def syntaxError(offset: Parsers.Offset, msg: String, skipIt: Boolean): Unit
203.  def syntaxError(msg: String, skipIt: Boolean): Unit
204.  def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean): Unit
205.  def syntaxErrorOrIncompleteAnd[T](msg: String, skipIt: Boolean)(and: T): T
206.  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

207.  def templateBody(isPre: Boolean): (Global.ValDef, List[Global.Tree])

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

     isPre

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

208.  def templateBodyOpt(parenMeansSyntaxError: Boolean): (Global.ValDef, List[Global.Tree])
209.  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' | `<:'

210.  def templateOrTopStatSeq(): List[Global.Tree]
211.  def templateParents(): List[Global.Tree]

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

212.  def templateStat: PartialFunction[Parsers.Token, List[Global.Tree]]
213.  def templateStatSeq(isPre: Boolean): (Global.ValDef, List[Global.Tree])

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

     isPre

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

214.  def templateStats(): List[Global.Tree]

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

215.  def tmplDef(pos: Parsers.Offset, mods: Global.Modifiers): Global.Tree

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

216.  def toString(): String
     Definition Classes
       AnyRef → Any
217.  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 } }}}

218.  def topLevelTmplDef: Global.Tree

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

219.  def topStat: PartialFunction[Parsers.Token, List[Global.Tree]]
220.  def topStatSeq(): List[Global.Tree]

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

221.  val treeBuilder: ParserTreeBuilder
222.  def typ(): Global.Tree

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

223.  def typeBounds(): Global.TypeBoundsTree

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

224.  def typeDefOrDcl(start: Parsers.Offset, mods: Global.Modifiers): Global.Tree

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

225.  def typeOrInfixType(location: Location): Global.Tree
226.  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}

227.  def typedOpt(): Global.Tree

         TypedOpt ::= [`:' Type]

228.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
229.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
230.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
231.  def warning(msg: String): Unit
232.  def wildcardOrIdent(): Global.Name
233.  def wildcardType(start: Parsers.Offset): Global.Ident

         WildcardType ::= `_' TypeBounds

234.  def xmlSeqPatterns(): List[Global.Tree]
235.  def →[B](y: B): (Parser, B)
     Implicit
       This member is added by an implicit conversion from Parser to ArrowAssoc[Parser] performed by method ArrowAssoc in scala.Predef.
     Definition Classes
       ArrowAssoc
236.  object InfixMode extends Enumeration

     Modes for infix types.

237.  object noSeq extends SeqContextSensitive

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

238.  object outPattern extends PatternContextSensitive

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

239.  object seqOK extends SeqContextSensitive

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

240.  object xmlSeqOK extends SeqContextSensitive

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

### 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