scala.reflect.quasiquotes.Parsers.Parser

# QuasiquoteParser

###
Related Doc: package Parser

#### class QuasiquoteParser extends SourceFileParser

Self Type
  QuasiquoteParser
Source
  Parsers.scala

Linear Supertypes
Parser.SourceFileParser, Parser.Parser, Parser.ParserCommon, AnyRef, Any
Type Hierarchy
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. QuasiquoteParser
2. SourceFileParser
3. Parser
4. ParserCommon
5. AnyRef
6. 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 QuasiquoteParser(source0: SourceFile)

### Type Members

1. #### class ParserTreeBuilder extends TreeBuilder

   Definition Classes
     Parser

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.

   Definition Classes
     Parser

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.

   Definition Classes
     Parser

### 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 QuasiquoteParser to any2stringadd[QuasiquoteParser] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd

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

   Implicit information
     This member is added by an implicit conversion from QuasiquoteParser to ArrowAssoc[QuasiquoteParser] 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.

   Modes for infix types.

   Definition Classes
     Parser

7. #### def accept(token: Parser.Token): Parser.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

   Definition Classes
     Parser

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

   Definition Classes
     Parser

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

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

    Definition Classes
      Parser

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

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

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

    Definition Classes
      Parser

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

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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]

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

        Block ::= BlockStatSeq

    Definition Classes
      Parser
    Note

      Return tree does not carry position.

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

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

    Definition Classes
      Parser

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

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

    Definition Classes
      Parser

27. #### def bound(tok: Parser.Token): tools.nsc.Global.Tree

    Definition Classes
      Parser

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

    Definition Classes
      QuasiquoteParser → Parser

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

    Definition Classes
      QuasiquoteParser → Parser

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

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser
    Annotations
      @inline()

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Check that type parameter is not by name or repeated.

    Check that type parameter is not by name or repeated.

    Definition Classes
      Parser

36. #### def classDef(start: Parser.Offset, mods: tools.nsc.Global.Modifiers): tools.nsc.Global.ClassDef

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

    Definition Classes
      Parser

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
      @throws( ... )
    Note

      not specified by SLS as a member of AnyRef

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

    Definition Classes
      Parser
    Annotations
      @inline()

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

        CompilationUnit ::= {package QualId semi} TopStatSeq

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

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

    Definition Classes
      Parser

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

        ConstrExpr      ::=  SelfInvocation
                          |  ConstrBlock

    Definition Classes
      Parser

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

    Definition Classes
      Parser

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

    Convert tree to formal parameter.

    Convert tree to formal parameter.

    Definition Classes
      QuasiquoteParser → Parser

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

    Convert tree to formal parameter list.

    Convert tree to formal parameter list.

    Definition Classes
      Parser

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

    Convert (qual)ident to type identifier.

    Convert (qual)ident to type identifier.

    Definition Classes
      Parser

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

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

    Definition Classes
      Parser

48. #### def deprecationWarning(offset: Parser.Offset, msg: String): Unit

    Definition Classes
      SourceFileParser → ParserCommon

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

50. #### def ensureEarlyDef(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

    Definition Classes
      QuasiquoteParser → Parser

51. #### def ensuring(cond: (QuasiquoteParser) ⇒ Boolean, msg: ⇒ Any): QuasiquoteParser

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

52. #### def ensuring(cond: (QuasiquoteParser) ⇒ Boolean): QuasiquoteParser

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

53. #### def ensuring(cond: Boolean, msg: ⇒ Any): QuasiquoteParser

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

54. #### def ensuring(cond: Boolean): QuasiquoteParser

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

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

    Definition Classes
      QuasiquoteParser → Parser

56. #### def enumerators(): List[tools.nsc.Global.Tree]

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

    Definition Classes
      Parser

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

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

59. #### def errorPatternTree: tools.nsc.Global.Ident

    Definition Classes
      Parser

60. #### def errorTermTree: tools.nsc.Global.Literal

    Definition Classes
      Parser

61. #### def errorTypeTree: tools.nsc.Global.TypeTree

    Definition Classes
      Parser

62. #### def expectedMsg(token: Int): String

    Definition Classes
      QuasiquoteParser → Parser

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

    Definition Classes
      Parser

64. #### def expr(location: Parser.Location): tools.nsc.Global.Tree

    Definition Classes
      Parser

65. #### def expr(): tools.nsc.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}
                     | `:' `_' `*'

    Definition Classes
      Parser

66. #### def expr0(location: Parser.Location): tools.nsc.Global.Tree

    Definition Classes
      Parser

67. #### def exprSimpleType(): tools.nsc.Global.Tree

    Definition Classes
      Parser

68. #### def exprTypeArgs(): List[tools.nsc.Global.Tree]

    Definition Classes
      Parser

69. #### 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
      @throws( classOf[java.lang.Throwable] )
    Note

      not specified by SLS as a member of AnyRef

70. #### def finishBinaryOp(isExpr: Boolean, opinfo: Parser.OpInfo, rhs: tools.nsc.Global.Tree): tools.nsc.Global.Tree

    Definition Classes
      Parser

71. #### def finishPostfixOp(start: Int, base: List[Parser.OpInfo], opinfo: Parser.OpInfo): tools.nsc.Global.Tree

    Definition Classes
      Parser

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

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

73. #### implicit lazy val fresh: FreshNameCreator

    Definition Classes
      QuasiquoteParser → Parser

74. #### def funDefOrDcl(start: Int, mods: tools.nsc.Global.Modifiers): tools.nsc.Global.Tree

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

    Definition Classes
      Parser

75. #### def funDefRest(start: Parser.Offset, nameOffset: Parser.Offset, mods: tools.nsc.Global.Modifiers, name: tools.nsc.Global.Name): tools.nsc.Global.Tree

    Definition Classes
      Parser

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

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

    Definition Classes
      Parser

77. #### 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
    Note

      not specified by SLS as a member of AnyRef

78. #### def guard(): tools.nsc.Global.Tree

        Guard ::= if PostfixExpr

    Definition Classes
      Parser

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

80. #### def ident(): tools.nsc.Global.Name

    Definition Classes
      Parser

81. #### def ident(skipIt: Boolean): tools.nsc.Global.Name

    Assumed (provisionally) to be TermNames.

    Assumed (provisionally) to be TermNames.

    Definition Classes
      Parser

82. #### def identForType(skipIt: Boolean): tools.nsc.Global.TypeName

    Definition Classes
      Parser

83. #### def identForType(): tools.nsc.Global.TypeName

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

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

    Definition Classes
      Parser

84. #### def identOrMacro(): tools.nsc.Global.Name

    Definition Classes
      Parser

85. #### def implicitClosure(start: Parser.Offset, location: Parser.Location): tools.nsc.Global.Tree

        Expr ::= implicit Id => Expr

    Definition Classes
      Parser

86. #### def importClause(): List[tools.nsc.Global.Tree]

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

    Definition Classes
      Parser

87. #### def importExpr(): tools.nsc.Global.Tree

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

    Definition Classes
      Parser

88. #### def importSelector(): tools.nsc.Global.ImportSelector

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

    Definition Classes
      Parser

89. #### def importSelectors(): List[tools.nsc.Global.ImportSelector]

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

    Definition Classes
      Parser

90. #### val in: Parser.Scanner

    Definition Classes
      SourceFileParser → Parser → ParserCommon

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

94. #### final def inBracesOrUnit[T](body: ⇒ tools.nsc.Global.Tree): tools.nsc.Global.Tree

    Definition Classes
      ParserCommon
    Annotations
      @inline()

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

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

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

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

    Definition Classes
      ParserCommon
    Annotations
      @inline()

99. #### final def inParensOrUnit[T](body: ⇒ tools.nsc.Global.Tree): tools.nsc.Global.Tree

    Definition Classes
      ParserCommon
    Annotations
      @inline()

100. #### def incompleteInputError(msg: String): Unit

     Definition Classes
       SourceFileParser → Parser

101. #### def isAnnotation: Boolean

     Definition Classes
       QuasiquoteParser → Parser

102. #### def isCaseDefEnd: Boolean

     Definition Classes
       Parser

103. #### def isDclIntro: Boolean

     Definition Classes
       QuasiquoteParser → Parser

104. #### def isDefIntro: Boolean

     Definition Classes
       QuasiquoteParser → Parser

105. #### def isExprIntro: Boolean

     Definition Classes
       Parser

106. #### def isExprIntroToken(token: Parser.Token): Boolean

     Definition Classes
       Parser

107. #### def isHole(name: tools.nsc.Global.Name): Boolean

108. #### def isHole: Boolean

109. #### def isIdent: Boolean

     Definition Classes
       Parser

110. #### def isIdentExcept(except: tools.nsc.Global.Name): Boolean

     Definition Classes
       Parser

111. #### def isIdentOf(name: tools.nsc.Global.Name): Boolean

     Definition Classes
       Parser

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

113. #### def isLiteral: Boolean

     Definition Classes
       Parser

114. #### def isLiteralToken(token: Parser.Token): Boolean

     Definition Classes
       Parser

115. #### def isLocalModifier: Boolean

     Definition Classes
       QuasiquoteParser → Parser

116. #### def isMacro: Boolean

     Definition Classes
       Parser

117. #### def isModifier: Boolean

     Definition Classes
       QuasiquoteParser → Parser

118. #### def isNumericLit: Boolean

     Definition Classes
       Parser

119. #### def isRawBar: Boolean

     Definition Classes
       Parser

120. #### def isRawIdent: Boolean

     Definition Classes
       Parser

121. #### def isRawStar: Boolean

     Definition Classes
       Parser

122. #### def isStatSep(token: Int): Boolean

     Definition Classes
       QuasiquoteParser → Parser

123. #### def isStatSep: Boolean

     Definition Classes
       Parser

124. #### def isStatSeqEnd: Boolean

     Definition Classes
       Parser

125. #### def isTemplateIntro: Boolean

     Definition Classes
       QuasiquoteParser → Parser

126. #### def isTypeIntroToken(token: Parser.Token): Boolean

     Definition Classes
       Parser

127. #### def isTypedParam(tree: tools.nsc.Global.Tree): Boolean

     Definition Classes
       QuasiquoteParser → Parser

128. #### def isUnaryOp: Boolean

     Definition Classes
       Parser

129. #### def isWildcard(t: tools.nsc.Global.Tree): Boolean

     Definition Classes
       Parser

130. #### def joinComment(trees: ⇒ List[tools.nsc.Global.Tree]): List[tools.nsc.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.

     Definition Classes
       Parser

131. #### def literal(isNegated: Boolean = false, inPattern: Boolean = false, start: Parser.Offset = in.offset): tools.nsc.Global.Tree

         SimpleExpr    ::= literal
                         | symbol
                         | null

     Definition Classes
       Parser

132. #### def localDef(implicitMod: Int): List[tools.nsc.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) }

     Definition Classes
       Parser

133. #### def localModifiers(): tools.nsc.Global.Modifiers

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

     Definition Classes
       Parser

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

     Definition Classes
       Parser
     Annotations
       @inline()

135. #### def makeBinop(isExpr: Boolean, left: tools.nsc.Global.Tree, op: tools.nsc.Global.TermName, right: tools.nsc.Global.Tree, opPos: tools.nsc.Global.Position, targs: List[tools.nsc.Global.Tree] = Nil): tools.nsc.Global.Tree

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

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

     Definition Classes
       Parser

136. #### def makeEmptyPackage(start: Parser.Offset, stats: List[tools.nsc.Global.Tree]): tools.nsc.Global.PackageDef

     Definition Classes
       Parser

137. #### def makeFilter(start: Parser.Offset, tree: tools.nsc.Global.Tree): tools.nsc.Global.Apply

     Definition Classes
       Parser

138. #### def makePackageObject(start: Parser.Offset, objDef: tools.nsc.Global.ModuleDef): tools.nsc.Global.PackageDef

     Definition Classes
       Parser

139. #### def makePackaging(start: Parser.Offset, pkg: tools.nsc.Global.Tree, stats: List[tools.nsc.Global.Tree]): tools.nsc.Global.PackageDef

     Create a tree representing a packaging.

     Create a tree representing a packaging.

     Definition Classes
       Parser

140. #### final def makeParens(body: ⇒ List[tools.nsc.Global.Tree]): tools.nsc.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()

141. #### def makeSafeTupleTerm(trees: List[tools.nsc.Global.Tree], offset: Parser.Offset): tools.nsc.Global.Tree

     Create a tuple term Tree.

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

     Definition Classes
       QuasiquoteParser → Parser

142. #### def makeSafeTupleType(trees: List[tools.nsc.Global.Tree], offset: Parser.Offset): tools.nsc.Global.Tree

     Create a tuple type Tree.

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

     Definition Classes
       QuasiquoteParser → Parser

143. #### def mixinQualifierOpt(): tools.nsc.Global.TypeName

         MixinQualifier ::= `[' Id `]'

     Definition Classes
       Parser

144. #### def modifiers(): tools.nsc.Global.Modifiers

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

     Definition Classes
       Parser

145. #### def multipleArgumentExprs(): List[List[tools.nsc.Global.Tree]]

     A succession of argument lists.

     A succession of argument lists.

     Definition Classes
       Parser

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

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

     Definition Classes
       Parser

148. #### def newLineOptWhenFollowedBy(token: Parser.Offset): Unit

     Definition Classes
       Parser

149. #### def newLineOptWhenFollowing(p: (Parser.Token) ⇒ Boolean): Unit

     Definition Classes
       Parser

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

     Definition Classes
       Parser

151. #### def newScanner(): Parser.Scanner

     Definition Classes
       SourceFileParser

152. #### object noSeq extends SeqContextSensitive

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

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

     Definition Classes
       Parser

153. #### def nonLocalDefOrDcl: List[tools.nsc.Global.Tree]

     Definition Classes
       Parser

154. #### 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
     Note

       not specified by SLS as a member of AnyRef

155. #### 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
     Note

       not specified by SLS as a member of AnyRef

156. #### def o2p(offset: Parser.Offset): tools.nsc.Global.Position

     Definition Classes
       Parser

157. #### def objectDef(start: Parser.Offset, mods: tools.nsc.Global.Modifiers): tools.nsc.Global.ModuleDef

         ObjectDef       ::= Id ClassTemplateOpt

     Definition Classes
       Parser

158. #### var opstack: List[Parser.OpInfo]

     Definition Classes
       Parser

159. #### object outPattern extends PatternContextSensitive

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

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

     Definition Classes
       Parser

160. #### def packageObjectDef(start: Parser.Offset): tools.nsc.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` { ... }
         }

     Definition Classes
       Parser

161. #### def packageOrPackageObject(start: Parser.Offset): tools.nsc.Global.Tree

     Definition Classes
       Parser

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

     Definition Classes
       QuasiquoteParser → Parser

163. #### def paramClauses(owner: tools.nsc.Global.Name, contextBounds: List[tools.nsc.Global.Tree], ofCaseClass: Boolean): List[List[tools.nsc.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]

     Definition Classes
       Parser

164. #### def paramType(useStartAsPosition: Boolean): tools.nsc.Global.Tree

     Definition Classes
       Parser

165. #### def paramType(): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

166. #### def parse(): tools.nsc.Global.Tree

     This is the general parse entry point.

     This is the general parse entry point.

     Definition Classes
       Parser

167. #### def parseRule[T](rule: (QuasiquoteParser.this.type) ⇒ T): T

     Definition Classes
       Parser

168. #### def parseStartRule: () ⇒ tools.nsc.Global.Tree

     The parse starting point depends on whether the source file is self-contained: if not, the AST will be supplemented.

     The parse starting point depends on whether the source file is self-contained: if not, the AST will be supplemented.

     Definition Classes
       SourceFileParser → Parser

169. #### def parseStats(): List[tools.nsc.Global.Tree]

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

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

     Definition Classes
       Parser

170. #### def parseStatsOrPackages(): List[tools.nsc.Global.Tree]

     Definition Classes
       Parser

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

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

     Definition Classes
       Parser

172. #### def path(thisOK: Boolean, typeOK: Boolean): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

173. #### def pattern(): tools.nsc.Global.Tree

     Default entry points into some pattern contexts.

     Default entry points into some pattern contexts.

     Definition Classes
       Parser

174. #### def peekingAhead(tree: ⇒ tools.nsc.Global.Tree): tools.nsc.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.

     Definition Classes
       Parser
     Annotations
       @inline()

175. #### var placeholderParams: List[tools.nsc.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.

     Definition Classes
       Parser

176. #### def placeholderTypeBoundary(op: ⇒ tools.nsc.Global.Tree): tools.nsc.Global.Tree

     Definition Classes
       Parser

177. #### var placeholderTypes: List[tools.nsc.Global.TypeDef]

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

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

     Definition Classes
       Parser

178. #### def postfixExpr(): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

179. #### def prefixExpr(): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

180. #### def qualId(): tools.nsc.Global.Tree

         QualId ::= Id {`.' Id}

     Definition Classes
       Parser

181. #### def r2p(offset: Parser.Offset): tools.nsc.Global.Position

     Definition Classes
       Parser

182. #### def r2p(start: Parser.Offset, mid: Parser.Offset): tools.nsc.Global.Position

     Definition Classes
       Parser

183. #### def r2p(start: Parser.Offset, mid: Parser.Offset, end: Parser.Offset): tools.nsc.Global.Position

     Definition Classes
       Parser

184. #### def rawIdent(): tools.nsc.Global.Name

     Definition Classes
       Parser

185. #### def readAnnots(annot: ⇒ tools.nsc.Global.Tree): List[tools.nsc.Global.Tree]

     Definition Classes
       QuasiquoteParser → Parser

186. #### def reduceExprStack(base: List[Parser.OpInfo], top: tools.nsc.Global.Tree): tools.nsc.Global.Tree

     Definition Classes
       Parser

187. #### def reducePatternStack(base: List[Parser.OpInfo], top: tools.nsc.Global.Tree): tools.nsc.Global.Tree

     Definition Classes
       Parser

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

     Definition Classes
       Parser

189. #### def reduceStack(isExpr: Boolean, base: List[Parser.OpInfo], top: tools.nsc.Global.Tree): tools.nsc.Global.Tree

     Definition Classes
       Parser

190. #### def refineStat(): List[tools.nsc.Global.Tree]

     Definition Classes
       QuasiquoteParser → Parser

191. #### def refineStatSeq(): List[tools.nsc.Global.Tree]

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

     Definition Classes
       Parser

192. #### def refinement(): List[tools.nsc.Global.Tree]

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

     Definition Classes
       Parser

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

     Definition Classes
       Parser

194. #### def scriptBody(): tools.nsc.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().

     Definition Classes
       Parser

195. #### def selector(t: tools.nsc.Global.Tree): tools.nsc.Global.Tree

     Definition Classes
       Parser

196. #### def selectors(t: tools.nsc.Global.Tree, typeOK: Boolean, dotOffset: Parser.Offset): tools.nsc.Global.Tree

     Definition Classes
       Parser

197. #### def selfInvocation(vparamss: List[List[tools.nsc.Global.ValDef]]): tools.nsc.Global.Tree

         SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

     Definition Classes
       Parser

198. #### object seqOK extends SeqContextSensitive

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

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

     Definition Classes
       Parser

199. #### def seqPatterns(): List[tools.nsc.Global.Tree]

     Definition Classes
       Parser

200. #### def setInPos[T <: tools.nsc.Global.Tree](t: T): T

     Definition Classes
       Parser

201. #### def simpleExpr(): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

202. #### def simpleExprRest(t: tools.nsc.Global.Tree, canApply: Boolean): tools.nsc.Global.Tree

     Definition Classes
       Parser

203. #### def skip(targetToken: Parser.Token): Unit

     Attributes
       protected
     Definition Classes
       Parser

204. #### val source: SourceFile

     Definition Classes
       SourceFileParser → Parser

205. #### def stableId(): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

206. #### def startAnnotType(): tools.nsc.Global.Tree

     Definition Classes
       Parser

207. #### def startInfixType(): tools.nsc.Global.Tree

     Definition Classes
       Parser

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

     Definition Classes
       Parser

209. #### def statement(location: Parser.Location): tools.nsc.Global.Tree

     Definition Classes
       Parser

210. #### def stripParens(t: tools.nsc.Global.Tree): tools.nsc.Global.Tree

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

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

     Definition Classes
       Parser

211. #### object symbXMLBuilder extends SymbolicXMLBuilder

     Definition Classes
       SourceFileParser

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

     Definition Classes
       AnyRef

213. #### def syntaxError(offset: Parser.Offset, msg: String): Unit

     Definition Classes
       SourceFileParser → Parser

214. #### def syntaxError(offset: Parser.Offset, msg: String, skipIt: Boolean): Unit

     Definition Classes
       Parser

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

     Definition Classes
       Parser

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

     Definition Classes
       Parser

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

     Definition Classes
       Parser

218. #### def template(): (List[tools.nsc.Global.Tree], tools.nsc.Global.ValDef, List[tools.nsc.Global.Tree])

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

     Definition Classes
       Parser

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

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

     isPre

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

     Definition Classes
       Parser

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

     Definition Classes
       Parser

221. #### def templateOpt(mods: tools.nsc.Global.Modifiers, name: tools.nsc.Global.Name, constrMods: tools.nsc.Global.Modifiers, vparamss: List[List[tools.nsc.Global.ValDef]], tstart: Parser.Offset): tools.nsc.Global.Template

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

     Definition Classes
       Parser

222. #### def templateOrTopStatSeq(): List[tools.nsc.Global.Tree]

     Definition Classes
       Parser

223. #### def templateParents(): List[tools.nsc.Global.Tree]

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

     Definition Classes
       Parser

224. #### def templateStat: PartialFunction[Parser.Token, List[tools.nsc.Global.Tree]]

     Definition Classes
       Parser

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

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

     isPre

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

     Definition Classes
       Parser

226. #### def templateStats(): List[tools.nsc.Global.Tree]

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

     Definition Classes
       Parser

227. #### def tmplDef(pos: Parser.Offset, mods: tools.nsc.Global.Modifiers): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

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

229. #### final def tokenSeparated[T](separator: Parser.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 } }}}

     Definition Classes
       Parser

230. #### def topLevelTmplDef: tools.nsc.Global.Tree

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

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

     Definition Classes
       Parser

231. #### def topStat: PartialFunction[Parser.Token, List[tools.nsc.Global.Tree]]

     Definition Classes
       QuasiquoteParser → Parser

232. #### def topStatSeq(): List[tools.nsc.Global.Tree]

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

     Definition Classes
       Parser

233. #### val treeBuilder: ParserTreeBuilder

     Definition Classes
       QuasiquoteParser → Parser

234. #### def typ(): tools.nsc.Global.Tree

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

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

     Definition Classes
       Parser

235. #### def typeBounds(): tools.nsc.Global.TypeBoundsTree

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

     Definition Classes
       Parser

236. #### def typeDefOrDcl(start: Parser.Offset, mods: tools.nsc.Global.Modifiers): tools.nsc.Global.Tree

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

     Definition Classes
       Parser

237. #### def typeOrInfixType(location: Parser.Location): tools.nsc.Global.Tree

     Definition Classes
       Parser

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

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

     Definition Classes
       Parser

239. #### def typedOpt(): tools.nsc.Global.Tree

         TypedOpt ::= [`:' Type]

     Definition Classes
       Parser

240. #### def unit: tools.nsc.Global.CompilationUnit

     Definition Classes
       SourceFileParser → Parser

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

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

     Definition Classes
       AnyRef
     Annotations
       @throws( ... )

244. #### def warning(offset: Parser.Offset, msg: String): Unit

     Definition Classes
       SourceFileParser → Parser

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

     Definition Classes
       Parser

246. #### def wildcardOrIdent(): tools.nsc.Global.Name

     Definition Classes
       Parser

247. #### def wildcardType(start: Parser.Offset): tools.nsc.Global.Ident

         WildcardType ::= `_' TypeBounds

     Definition Classes
       Parser

248. #### def xmlLiteral(): tools.nsc.Global.Tree

     Definition Classes
       SourceFileParser → Parser

249. #### def xmlLiteralPattern(): tools.nsc.Global.Tree

     Definition Classes
       SourceFileParser → Parser

250. #### object xmlSeqOK extends SeqContextSensitive

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

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

     Definition Classes
       Parser

251. #### def xmlSeqPatterns(): List[tools.nsc.Global.Tree]

     Definition Classes
       Parser

252. #### def →[B](y: B): (QuasiquoteParser, B)

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

### Deprecated Value Members

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

   Definition Classes
     Parser
   Annotations
     @deprecated
   Deprecated

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

### Inherited from Parser.SourceFileParser

### Inherited from Parser.Parser

### Inherited from Parser.ParserCommon

### Inherited from AnyRef

### Inherited from Any

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

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

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

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

### Ungrouped