scala.tools.nsc.ast.parser.Parsers

# Parser

###
Related Doc: package Parsers

#### abstract class Parser extends ParserCommon

Self Type
  Parser
Source
  Parsers.scala

Linear Supertypes
Parsers.ParserCommon, AnyRef, Any
Known Subclasses
OutlineParser, QuasiquoteParser, SourceFileParser, UnitParser
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): 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

   Test two objects for inequality.

   Test two objects for inequality.

   returns

     `true` if !(this == that), false otherwise.

   Definition Classes
     AnyRef → Any

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

   Equivalent to `x.hashCode` except for boxed numeric types and `null`.

   Equivalent to `x.hashCode` except for boxed numeric types and `null`. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For `null` returns a hashcode where `null.hashCode` throws a `NullPointerException`.

   returns

     a hash value consistent with ==

   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

   The expression `x == that` is equivalent to `if (x eq null) that eq null else x.equals(that)`.

   The expression `x == that` is equivalent to `if (x eq null) that eq null else x.equals(that)`.

   returns

     `true` if the receiver object is equivalent to the argument; `false` otherwise.

   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

    Cast the receiver object to be of type `T0`.

    Cast the receiver object to be of type `T0`.

    Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression `1.asInstanceOf[String]` will throw a `ClassCastException` at runtime, while the expression `List(1).asInstanceOf[List[String]]` will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.

    returns

      the receiver object.

    Definition Classes
      Any
    Exceptions thrown

      `ClassCastException` if the receiver object is not an instance of the erasure of type `T0`.

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

    Create a copy of the receiver object.

    Create a copy of the receiver object.

    The default implementation of the `clone` method is platform dependent.

    returns

      a copy of the receiver object.

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

      not specified by SLS as a member of AnyRef

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

    Tests whether the argument (`that`) is a reference to the receiver object (`this`).

    Tests whether the argument (`that`) is a reference to the receiver object (`this`).

    The `eq` method implements an equivalence relation on non-null instances of `AnyRef`, and has three additional properties:

    - It is consistent: for any non-null instances `x` and `y` of type `AnyRef`, multiple invocations of `x.eq(y)` consistently returns `true` or consistently returns `false`.
    - For any non-null instance `x` of type `AnyRef`, `x.eq(null)` and `null.eq(x)` returns `false`.
    - `null.eq(null)` returns `true`.

    When overriding the `equals` or `hashCode` methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (`o1 eq o2`), they should be equal to each other (`o1 == o2`) and they should hash to the same value (`o1.hashCode == o2.hashCode`).

    returns

      `true` if the argument is a reference to the receiver object; `false` otherwise.

    Definition Classes
      AnyRef

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

    The equality method for reference types.

    The equality method for reference types. Default implementation delegates to `eq`.

    See also `equals` in scala.Any.

    returns

      `true` if the receiver object is equivalent to the argument; `false` otherwise.

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

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[_]

    A representation that corresponds to the dynamic class of the receiver object.

    A representation that corresponds to the dynamic class of the receiver object.

    The nature of the representation is platform dependent.

    returns

      a representation that corresponds to the dynamic class of the receiver object.

    Definition Classes
      AnyRef → Any
    Annotations
      @IntrinsicCandidate()
    Note

      not specified by SLS as a member of AnyRef

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

        Guard ::= if PostfixExpr

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

    The hashCode method for reference types.

    The hashCode method for reference types. See hashCode in scala.Any.

    returns

      the hash code value for this object.

    Definition Classes
      AnyRef → Any
    Annotations
      @IntrinsicCandidate()

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

     Test whether the dynamic type of the receiver object is `T0`.

     Test whether the dynamic type of the receiver object is `T0`.

     Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression `1.isInstanceOf[String]` will return `false`, while the expression `List(1).isInstanceOf[List[String]]` will return `true`. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.

     returns

       `true` if the receiver object is an instance of erasure of type `T0`; `false` otherwise.

     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 isStatSep: Boolean

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

118. #### def isStatSeqEnd: Boolean

119. #### def isTemplateIntro: Boolean

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

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

122. #### def isUnaryOp: Boolean

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

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

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

         SimpleExpr    ::= literal
                         | symbol
                         | null

126. #### 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) }

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

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

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

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

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

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

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

         MixinQualifier ::= `[' Id `]'

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

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

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

     A succession of argument lists.

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

     Equivalent to `!(this eq that)`.

     Equivalent to `!(this eq that)`.

     returns

       `true` if the argument is not a reference to the receiver object; `false` otherwise.

     Definition Classes
       AnyRef

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

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

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

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

145. #### object noSeq extends SeqContextSensitive

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

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

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

     Wakes up a single thread that is waiting on the receiver object's monitor.

     Wakes up a single thread that is waiting on the receiver object's monitor.

     Definition Classes
       AnyRef
     Annotations
       @IntrinsicCandidate()
     Note

       not specified by SLS as a member of AnyRef

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

     Wakes up all threads that are waiting on the receiver object's monitor.

     Wakes up all threads that are waiting on the receiver object's monitor.

     Definition Classes
       AnyRef
     Annotations
       @IntrinsicCandidate()
     Note

       not specified by SLS as a member of AnyRef

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

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

         ObjectDef       ::= Id ClassTemplateOpt

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

152. #### object outPattern extends PatternContextSensitive

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

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. #### object seqOK extends SeqContextSensitive

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

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

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

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

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

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

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

     Attributes
       protected

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

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

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

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

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

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

201. #### def stripParens(t: Global.Tree): Global.Tree

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

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

     Definition Classes
       AnyRef

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

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

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

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

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

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

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

     isPre

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

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

210. #### 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' | `<:'

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

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

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

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

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

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

     isPre

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

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

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

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

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

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

     Creates a String representation of this object.

     Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.

     returns

       a String representation of the object.

     Definition Classes
       AnyRef → Any

218. #### 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 } }}}

219. #### def topLevelTmplDef: Global.Tree

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

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

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

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

222. #### val treeBuilder: ParserTreeBuilder

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

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

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

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

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

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

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

227. #### 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}

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

         TypedOpt ::= [`:' Type]

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. #### final def wait(): Unit

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

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

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

         WildcardType ::= `_' TypeBounds

235. #### object xmlSeqOK extends SeqContextSensitive

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

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

237. #### 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 finalize(): Unit

   Called by the garbage collector on the receiver object when there are no more references to the object.

   Called by the garbage collector on the receiver object when there are no more references to the object.

   The details of when and if the `finalize` method is invoked, as well as the interaction between `finalize` and non-local returns and exceptions, are all platform dependent.

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

     (Since version ) see corresponding Javadoc for more information.

   Note

     not specified by SLS as a member of AnyRef

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