Packages

class QuasiquoteParser extends SourceFileParser

Self Type
QuasiquoteParser
Source
Parsers.scala
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. Protected

Instance Constructors

  1. new QuasiquoteParser(source0: SourceFile)

Type Members

  1. class ParserTreeBuilder extends TreeBuilder
    Definition Classes
    Parser
  2. sealed 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. final class 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
    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 QuasiquoteParser toany2stringadd[QuasiquoteParser] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (QuasiquoteParser, B)
    Implicit
    This member is added by an implicit conversion from QuasiquoteParser toArrowAssoc[QuasiquoteParser] 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: 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
    ParserParserCommon
  7. def acceptStatSep(): Unit

    semi = nl {nl} | `;`
    nl  = `\n` // where allowed
    Definition Classes
    Parser
  8. def acceptStatSepOpt(): Unit
    Definition Classes
    Parser
  9. def accessModifierOpt(): tools.nsc.Global.Modifiers

    AccessModifier ::= (private | protected) [AccessQualifier]
    Definition Classes
    Parser
  10. def accessQualifierOpt(mods: tools.nsc.Global.Modifiers): tools.nsc.Global.Modifiers

    AccessQualifier ::= `[` (Id | this) `]`
    Definition Classes
    Parser
  11. def annotTypeRest(t: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    Parser
  12. def annotationExpr(): tools.nsc.Global.Tree
    Definition Classes
    Parser
  13. def annotations(skipNewLines: Boolean): List[tools.nsc.Global.Tree]

    Annotations       ::= {`@` SimpleType {ArgumentExprs}}
    ConstrAnnotations ::= {`@` SimpleType ArgumentExprs}
    Definition Classes
    Parser
  14. def argumentExprs(): List[tools.nsc.Global.Tree]

    ArgumentExprs ::= `(` [Exprs] `)`
                    | `(` `using` Exprs `)`
                    | [nl] BlockExpr
    Definition Classes
    Parser
  15. def argumentPatterns(): List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  16. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  17. val assumedClosingParens: Map[Int, Int]
    Definition Classes
    Parser
  18. def atInPos[T <: tools.nsc.Global.Tree](t: T): T
    Definition Classes
    Parser
  19. def atPos[T <: tools.nsc.Global.Tree](pos: tools.nsc.Global.Position)(t: T): T
    Definition Classes
    Parser
  20. def atPos[T <: tools.nsc.Global.Tree](start: Parser.Offset, point: Parser.Offset, end: Parser.Offset)(t: T): T
    Definition Classes
    Parser
  21. def atPos[T <: tools.nsc.Global.Tree](start: Parser.Offset, point: Parser.Offset)(t: T): T
    Definition Classes
    Parser
  22. def atPos[T <: tools.nsc.Global.Tree](offset: Parser.Offset)(t: T): T
    Definition Classes
    Parser
  23. def block(): tools.nsc.Global.Tree

    Block ::= BlockStatSeq
    Definition Classes
    Parser
    Note

    Return tree does not carry position.

  24. def blockExpr(): tools.nsc.Global.Tree

    BlockExpr ::= `{` (CaseClauses | Block) `}`
    Definition Classes
    Parser
  25. def blockStatSeq(): List[tools.nsc.Global.Tree]

    BlockStatSeq ::= { BlockStat semi } [ResultExpr]
    BlockStat    ::= Import
                   | Annotations [implicit] [lazy] Def
                   | Annotations LocalModifiers TmplDef
                   | Expr1
                   |
    Definition Classes
    Parser
  26. def bound(tok: Parser.Token): tools.nsc.Global.Tree
    Definition Classes
    Parser
  27. def caseBlock(): tools.nsc.Global.Tree
    Definition Classes
    QuasiquoteParserParser
  28. def caseClause(): tools.nsc.Global.CaseDef
    Definition Classes
    QuasiquoteParserParser
  29. def caseClauses(): List[tools.nsc.Global.CaseDef]

    CaseClauses ::= CaseClause {CaseClause}
    CaseClause  ::= case Pattern [Guard] `=>` Block
    Definition Classes
    Parser
  30. final def caseSeparated[T](part: => T): List[T]
    Definition Classes
    Parser
    Annotations
    @inline()
  31. def checkAssoc(offset: Parser.Offset, op: tools.nsc.Global.Name, leftAssoc: Boolean): Unit
    Definition Classes
    Parser
  32. def checkHeadAssoc(leftAssoc: Boolean): Unit
    Definition Classes
    Parser
  33. def checkKeywordDefinition(): 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 checkQMarkDefinition(): Unit
    Definition Classes
    Parser
  37. def classDef(start: Parser.Offset, mods: tools.nsc.Global.Modifiers): tools.nsc.Global.ClassDef

    ClassDef ::= Id [TypeParamClause] ConstrAnnotations
                 [AccessModifier] ClassParamClauses RequiresTypeOpt ClassTemplateOpt
    TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt
    Definition Classes
    Parser
  38. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  39. final def commaSeparated[T](part: => T): List[T]

    , with the separator fixed to commas.

    tokenSeparated

    , with the separator fixed to commas.

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  40. def compilationUnit(): tools.nsc.Global.PackageDef

    CompilationUnit ::= {package QualId semi} TopStatSeq
    Definition Classes
    Parser
  41. def condExpr(): tools.nsc.Global.Tree
    Definition Classes
    Parser
  42. def constrBlock(vparamss: List[List[tools.nsc.Global.ValDef]]): tools.nsc.Global.Tree

    ConstrBlock    ::=  `{` SelfInvocation {semi BlockStat} `}`
    Definition Classes
    Parser
  43. def constrExpr(vparamss: List[List[tools.nsc.Global.ValDef]]): tools.nsc.Global.Tree

    ConstrExpr      ::=  SelfInvocation
                      |  ConstrBlock
    Definition Classes
    Parser
  44. def constructorAnnotations(): List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  45. def convertToParam(tree: tools.nsc.Global.Tree): tools.nsc.Global.ValDef

    Convert tree to formal parameter.

    Convert tree to formal parameter.

    Definition Classes
    QuasiquoteParserParser
  46. 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
  47. 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
  48. 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
  49. def deprecationWarning(offset: Parser.Offset, msg: String, since: String, actions: List[CodeAction]): Unit
    Definition Classes
    SourceFileParserParserCommon
  50. final def dropAnyBraces[T](body: => T): T
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  51. def ensureEarlyDef(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    QuasiquoteParserParser
  52. def ensuring(cond: (QuasiquoteParser) => Boolean, msg: => Any): QuasiquoteParser
    Implicit
    This member is added by an implicit conversion from QuasiquoteParser toEnsuring[QuasiquoteParser] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  53. def ensuring(cond: (QuasiquoteParser) => Boolean): QuasiquoteParser
    Implicit
    This member is added by an implicit conversion from QuasiquoteParser toEnsuring[QuasiquoteParser] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  54. def ensuring(cond: Boolean, msg: => Any): QuasiquoteParser
    Implicit
    This member is added by an implicit conversion from QuasiquoteParser toEnsuring[QuasiquoteParser] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  55. def ensuring(cond: Boolean): QuasiquoteParser
    Implicit
    This member is added by an implicit conversion from QuasiquoteParser toEnsuring[QuasiquoteParser] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  56. def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): List[tools.nsc.Global.Tree]
    Definition Classes
    QuasiquoteParserParser
  57. def enumerators(): List[tools.nsc.Global.Tree]

    Enumerators ::= Generator {semi Enumerator}
    Enumerator  ::=  Generator
                  |  Guard
                  |  Pattern1 `=` Expr
    Definition Classes
    Parser
  58. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  59. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  60. def errorPatternTree: tools.nsc.Global.Ident
    Definition Classes
    Parser
  61. def errorTermTree: tools.nsc.Global.Literal
    Definition Classes
    Parser
  62. def errorTypeTree: tools.nsc.Global.TypeTree
    Definition Classes
    Parser
  63. def expectedMsg(token: Int): String
    Definition Classes
    QuasiquoteParserParser
  64. def expectedMsgTemplate(exp: String, fnd: String): String
    Definition Classes
    Parser
  65. def expr(location: Parser.Location): tools.nsc.Global.Tree
    Definition Classes
    Parser
  66. 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
  67. def expr0(location: Parser.Location): tools.nsc.Global.Tree
    Definition Classes
    Parser
  68. def exprSimpleType(): tools.nsc.Global.Tree
    Definition Classes
    Parser
  69. def exprTypeArgs(): List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  70. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  71. def finishBinaryOp(isExpr: Boolean, opinfo: Parser.OpInfo, rhs: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    Parser
  72. def finishPostfixOp(start: Int, base: List[Parser.OpInfo], opinfo: Parser.OpInfo): tools.nsc.Global.Tree
    Definition Classes
    Parser
  73. def followingIsScala3Vararg(): Boolean

    Is current ident a *, and is it followed by a ) or , )?

    Is current ident a *, and is it followed by a ) or , )?

    Definition Classes
    Parser
  74. implicit lazy val fresh: FreshNameCreator
    Definition Classes
    QuasiquoteParserParser
  75. 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
  76. 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
  77. def generator(eqOK: Boolean, allowNestedIf: Boolean = true): List[tools.nsc.Global.Tree]

    Generator ::= [`case`] Pattern1 (`<-` | `=`) Expr [Guard]
    Definition Classes
    Parser
  78. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  79. def guard(): tools.nsc.Global.Tree

    Guard ::= if PostfixExpr
    Definition Classes
    Parser
  80. def hardMigrationWarning(offset: Parser.Offset, depr: => String, migr: => String, since: String): Unit
    Definition Classes
    Parser
  81. def hardMigrationWarning(offset: Parser.Offset, depr: => String, migr: => String, since: String, actions: (String) => List[CodeAction]): Unit
    Definition Classes
    Parser
  82. def hardMigrationWarning(offset: Parser.Offset, msg: String, since: String, actions: List[CodeAction] = Nil): Unit
    Definition Classes
    Parser
  83. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  84. def ident(): tools.nsc.Global.Name
    Definition Classes
    Parser
  85. def ident(skipIt: Boolean): tools.nsc.Global.Name

    Assumed (provisionally) to be TermNames.

    Assumed (provisionally) to be TermNames.

    Definition Classes
    Parser
  86. def identForType(skipIt: Boolean): tools.nsc.Global.TypeName
    Definition Classes
    Parser
  87. 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
  88. def identOrMacro(): tools.nsc.Global.Name
    Definition Classes
    Parser
  89. def implicitClosure(start: Parser.Offset, location: Parser.Location): tools.nsc.Global.Tree

    Expr ::= implicit Id `=>` Expr
    Definition Classes
    Parser
  90. def importClause(): List[tools.nsc.Global.Tree]

    Import  ::= import ImportExpr {`,` ImportExpr}
    Definition Classes
    Parser
  91. def importExpr(): tools.nsc.Global.Tree

    ImportExpr ::= StableId `.` (Id | `_` | ImportSelectors)
    Definition Classes
    Parser
  92. def importSelector(): tools.nsc.Global.ImportSelector

    ImportSelector ::= Id [`=>` Id | `=>` `_`]
    Definition Classes
    Parser
  93. def importSelectors(): List[tools.nsc.Global.ImportSelector]

    ImportSelectors ::= `{` {ImportSelector `,`} (ImportSelector | `_`) `}`
    Definition Classes
    Parser
  94. val in: Parser.Scanner
    Definition Classes
    SourceFileParserParserParserCommon
  95. final def inBraces[T](body: => T): T
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  96. final def inBracesOrError[T](body: => T, alt: T): T
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  97. final def inBracesOrNil[T](body: => List[T]): List[T]
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  98. final def inBracesOrUnit[T](body: => tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  99. final def inBrackets[T](body: => T): T
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  100. final def inGroupers[T](left: Parser.Token)(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.

    Skip trailing comma is pushed down to scanner because this abstract parser doesn't have token info.

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  101. final def inParens[T](body: => T): T
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  102. final def inParensOrError[T](body: => T, alt: T): T
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  103. final def inParensOrNil[T](body: => List[T]): List[T]
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  104. final def inParensOrUnit[T](body: => tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    ParserCommon
    Annotations
    @inline()
  105. def incompleteInputError(msg: String, actions: List[CodeAction]): Unit
    Definition Classes
    SourceFileParserParser
  106. def isAnnotation: Boolean
    Definition Classes
    QuasiquoteParserParser
  107. def isCaseDefEnd: Boolean
    Definition Classes
    Parser
  108. def isDclIntro: Boolean
    Definition Classes
    QuasiquoteParserParser
  109. def isDefIntro: Boolean
    Definition Classes
    QuasiquoteParserParser
  110. def isExprIntro: Boolean
    Definition Classes
    Parser
  111. def isExprIntroToken(token: Parser.Token): Boolean
    Definition Classes
    Parser
  112. def isHole(name: tools.nsc.Global.Name): Boolean
  113. def isHole: Boolean
  114. def isIdent: Boolean
    Definition Classes
    Parser
  115. def isIdentExcept(except: tools.nsc.Global.Name): Boolean
    Definition Classes
    Parser
  116. def isIdentOf(name: tools.nsc.Global.Name): Boolean
    Definition Classes
    Parser
  117. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  118. def isLiteral: Boolean
    Definition Classes
    Parser
  119. def isLiteralToken(token: Parser.Token): Boolean
    Definition Classes
    Parser
  120. def isLocalModifier: Boolean
    Definition Classes
    QuasiquoteParserParser
  121. def isMacro: Boolean
    Definition Classes
    Parser
  122. def isModifier: Boolean
    Definition Classes
    QuasiquoteParserParser
  123. def isNumericLit: Boolean
    Definition Classes
    Parser
  124. def isRawBar: Boolean
    Definition Classes
    Parser
  125. def isRawIdent: Boolean
    Definition Classes
    Parser
  126. def isRawStar: Boolean
    Definition Classes
    Parser
  127. def isScala3WildcardType: Boolean
    Definition Classes
    Parser
  128. def isSoftModifier: Boolean
    Definition Classes
    Parser
  129. def isStatSep(token: Int): Boolean
    Definition Classes
    QuasiquoteParserParser
  130. def isStatSep: Boolean
    Definition Classes
    Parser
  131. def isStatSeqEnd: Boolean
    Definition Classes
    Parser
  132. def isTemplateIntro: Boolean
    Definition Classes
    QuasiquoteParserParser
  133. def isTypeIntroToken(token: Parser.Token): Boolean
    Definition Classes
    Parser
  134. def isTypedParam(tree: tools.nsc.Global.Tree): Boolean
    Definition Classes
    QuasiquoteParserParser
  135. def isUnaryOp: Boolean
    Definition Classes
    Parser
  136. def isValidSoftModifier: Boolean

    Is the current token a soft modifier in a position where such a modifier is allowed?

    Is the current token a soft modifier in a position where such a modifier is allowed?

    Definition Classes
    Parser
  137. final def isWildcard(t: tools.nsc.Global.Tree): Boolean
    Definition Classes
    Parser
    Annotations
    @tailrec()
  138. def isWildcardType: Boolean
    Definition Classes
    Parser
  139. 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
  140. def literal(isNegated: Boolean = false, inPattern: Boolean = false, start: Parser.Offset = in.offset): tools.nsc.Global.Tree

    SimpleExpr    ::= literal
                    | symbol
                    | null
    Definition Classes
    Parser
  141. def localDef(implicitMod: Long): 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
  142. def localModifiers(): tools.nsc.Global.Modifiers

    LocalModifiers ::= {LocalModifier}
    LocalModifier  ::= abstract | final | sealed | implicit | lazy
    Definition Classes
    Parser
  143. 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()
  144. 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
  145. def makeEmptyPackage(start: Parser.Offset, stats: List[tools.nsc.Global.Tree]): tools.nsc.Global.PackageDef
    Definition Classes
    Parser
  146. def makeFilter(start: Parser.Offset, tree: tools.nsc.Global.Tree): tools.nsc.Global.Apply
    Definition Classes
    Parser
  147. 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
  148. 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()
  149. def makeSafeFunctionType(argtpes: List[tools.nsc.Global.Tree], restpe: tools.nsc.Global.Tree): tools.nsc.Global.Tree

    Create a function Tree.

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

    Definition Classes
    Parser
  150. def makeSafeTupleTerm(trees: List[tools.nsc.Global.Tree]): 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
    QuasiquoteParserParser
  151. def makeSafeTupleType(trees: List[tools.nsc.Global.Tree]): 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
    QuasiquoteParserParser
  152. def migrationWarning(offset: Parser.Offset, msg: String, since: String, actions: List[CodeAction] = Nil): Unit
    Definition Classes
    Parser
  153. def mixinQualifierOpt(): tools.nsc.Global.TypeName

    MixinQualifier ::= `[` Id `]`
    Definition Classes
    Parser
  154. def modifiers(): tools.nsc.Global.Modifiers

    Modifiers ::= {Modifier}
    Modifier  ::= LocalModifier
                |  AccessModifier
                |  override
    Definition Classes
    Parser
  155. def multipleArgumentExprs(): List[List[tools.nsc.Global.Tree]]

    A succession of argument lists.

    A succession of argument lists.

    Definition Classes
    Parser
  156. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  157. def newLineOpt(): Unit
    Definition Classes
    Parser
  158. def newLineOptWhenFollowedBy(token: Parser.Offset): Unit
    Definition Classes
    Parser
  159. def newLineOptWhenFollowing(p: (Parser.Token) => Boolean): Unit
    Definition Classes
    Parser
  160. def newLinesOpt(): Unit
    Definition Classes
    Parser
  161. def newScanner(): Parser.Scanner
    Definition Classes
    SourceFileParser
  162. final val noSeq: 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
  163. def nonLocalDefOrDcl: List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  164. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  165. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  166. def o2p(offset: Parser.Offset): tools.nsc.Global.Position
    Definition Classes
    Parser
  167. def objectDef(start: Parser.Offset, mods: tools.nsc.Global.Modifiers, isPackageObject: Boolean = false): tools.nsc.Global.ModuleDef

    ObjectDef       ::= Id ClassTemplateOpt
    Definition Classes
    Parser
  168. var opstack: List[Parser.OpInfo]
    Definition Classes
    Parser
  169. final val outPattern: 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
  170. 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
  171. def packageOrPackageObject(start: Parser.Offset): tools.nsc.Global.Tree
    Definition Classes
    Parser
  172. def param(owner: tools.nsc.Global.Name, implicitmod: Long, caseParam: Boolean): tools.nsc.Global.ValDef
    Definition Classes
    QuasiquoteParserParser
  173. 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
  174. def paramType(repeatedParameterOK: Boolean, useStartAsPosition: Boolean): tools.nsc.Global.Tree
    Definition Classes
    Parser
  175. def paramType(): tools.nsc.Global.Tree

    ParamType ::= Type | `=>` Type | Type `*`
    Definition Classes
    Parser
  176. def parse(): tools.nsc.Global.Tree

    This is the general parse entry point.

    This is the general parse entry point.

    Definition Classes
    Parser
  177. def parseRule[T](rule: (QuasiquoteParser.this.type) => T): T
    Definition Classes
    Parser
  178. 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
    SourceFileParserParser
  179. 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
  180. def parseStatsOrPackages(): List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  181. 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
  182. def path(thisOK: Boolean, typeOK: Boolean): tools.nsc.Global.Tree

    Path       ::= StableId
                |  [Ident `.`] this
    AnnotType ::= Path [`.` type]
    Definition Classes
    Parser
  183. def pattern(): tools.nsc.Global.Tree

    Default entry points into some pattern contexts.

    Default entry points into some pattern contexts.

    Definition Classes
    Parser
  184. var placeholderParams: List[tools.nsc.Global.ValDef]

    The parameters introduced by _ "placeholder syntax" in the current expression.

    The parameters introduced by _ "placeholder syntax" in the current expression. Parameters appear in reverse order.

    Definition Classes
    Parser
  185. def placeholderTypeBoundary(op: => tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    Parser
  186. 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
  187. def postfixExpr(): tools.nsc.Global.Tree

    PostfixExpr   ::= InfixExpr [Id [nl]]
    InfixExpr     ::= PrefixExpr
                    | InfixExpr Id [nl] InfixExpr
    Definition Classes
    Parser
  188. def prefixExpr(): tools.nsc.Global.Tree

    PrefixExpr   ::= [`-` | `+` | `~` | `!`] SimpleExpr
    Definition Classes
    Parser
  189. def qualId(): tools.nsc.Global.Tree

    QualId ::= Id {`.` Id}
    Definition Classes
    Parser
  190. def r2p(offset: Parser.Offset): tools.nsc.Global.Position
    Definition Classes
    Parser
  191. def r2p(start: Parser.Offset, mid: Parser.Offset): tools.nsc.Global.Position
    Definition Classes
    Parser
  192. def r2p(start: Parser.Offset, mid: Parser.Offset, end: Parser.Offset): tools.nsc.Global.Position
    Definition Classes
    Parser
  193. def rawIdent(): tools.nsc.Global.Name
    Definition Classes
    Parser
  194. def readAnnots(annot: => tools.nsc.Global.Tree): List[tools.nsc.Global.Tree]
    Definition Classes
    QuasiquoteParserParser
  195. def reduceExprStack(base: List[Parser.OpInfo], top: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    Parser
  196. def reducePatternStack(base: List[Parser.OpInfo], top: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    Parser
  197. def reduceStack(isExpr: Boolean, base: List[Parser.OpInfo], top: tools.nsc.Global.Tree, opPrecedence: Precedence, leftAssoc: Boolean): tools.nsc.Global.Tree
    Definition Classes
    Parser
  198. def reduceStack(isExpr: Boolean, base: List[Parser.OpInfo], top: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    Parser
  199. def refineStat(): List[tools.nsc.Global.Tree]
    Definition Classes
    QuasiquoteParserParser
  200. def refineStatSeq(): List[tools.nsc.Global.Tree]

    RefineStatSeq    ::= RefineStat {semi RefineStat}
    RefineStat       ::= Dcl
                       | type TypeDef
                       |
    Definition Classes
    Parser
  201. def refinement(): List[tools.nsc.Global.Tree]

    Refinement ::= [nl] `{` RefineStat {semi RefineStat} `}`
    Definition Classes
    Parser
  202. def resetPackage(): Unit
    Definition Classes
    Parser
  203. 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
  204. def selector(start: Parser.Offset, t0: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
    Parser
  205. final def selectors(start: Parser.Offset, t: tools.nsc.Global.Tree, typeOK: Boolean, dotOffset: Parser.Offset): tools.nsc.Global.Tree
    Definition Classes
    Parser
    Annotations
    @tailrec()
  206. def selfInvocation(vparamss: List[List[tools.nsc.Global.ValDef]]): tools.nsc.Global.Tree

    SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}
    Definition Classes
    Parser
  207. final def separatedToken[T](separator: Parser.Token, part: => T): List[T]

    .

    { `sep` part }

    .

    Definition Classes
    ParserParserCommon
  208. final val seqOK: 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
  209. def seqPatterns(): List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  210. def setInPos[T <: tools.nsc.Global.Tree](t: T): T
    Definition Classes
    Parser
  211. 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
  212. final def simpleExprRest(start: Parser.Offset, t: tools.nsc.Global.Tree, canApply: Boolean): tools.nsc.Global.Tree
    Definition Classes
    Parser
    Annotations
    @tailrec()
  213. def skip(targetToken: Parser.Token): Unit
    Attributes
    protected
    Definition Classes
    Parser
  214. val source: SourceFile
    Definition Classes
    SourceFileParserParser
  215. def stableId(): tools.nsc.Global.Tree

    StableId ::= Id
              |  Path `.` Id
              |  [id `.`] super [`[` id `]`]`.` id
    Definition Classes
    Parser
  216. def startAnnotType(): tools.nsc.Global.Tree
    Definition Classes
    Parser
  217. def startInfixType(): tools.nsc.Global.Tree
    Definition Classes
    Parser
  218. 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
  219. def statement(location: Parser.Location): tools.nsc.Global.Tree
    Definition Classes
    Parser
  220. def stripParens(t: tools.nsc.Global.Tree): tools.nsc.Global.Tree

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

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

    Definition Classes
    Parser
  221. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  222. def syntaxError(offset: Parser.Offset, msg: String, actions: List[CodeAction]): Unit
    Definition Classes
    SourceFileParserParser
  223. def syntaxError(offset: Parser.Offset, msg: String, skipIt: Boolean, actions: List[CodeAction]): Unit
    Definition Classes
    Parser
  224. def syntaxError(offset: Parser.Offset, msg: String, skipIt: Boolean): Unit
    Definition Classes
    Parser
  225. def syntaxError(msg: String, skipIt: Boolean, actions: List[CodeAction]): Unit
    Definition Classes
    Parser
  226. def syntaxError(msg: String, skipIt: Boolean): Unit
    Definition Classes
    Parser
  227. def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean, actions: List[CodeAction] = Nil): Unit
    Definition Classes
    Parser
  228. def syntaxErrorOrIncompleteAnd[T](msg: String, skipIt: Boolean, actions: List[CodeAction] = Nil)(and: T): T
    Definition Classes
    Parser
  229. 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
  230. 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
  231. def templateBodyOpt(parenMeansSyntaxError: Boolean): (tools.nsc.Global.ValDef, List[tools.nsc.Global.Tree])
    Definition Classes
    Parser
  232. 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 | [[TraitExtends] TemplateBody]
    TraitExtends     ::= `extends` | `<:` (deprecated)
    Definition Classes
    Parser
  233. def templateOrTopStatSeq(): List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  234. def templateParents(): List[tools.nsc.Global.Tree]

    ClassParents       ::= AnnotType {`(` [Exprs] `)`} {with AnnotType}
    TraitParents       ::= AnnotType {with AnnotType}
    Definition Classes
    Parser
  235. def templateStat: PartialFunction[Parser.Token, List[tools.nsc.Global.Tree]]
    Definition Classes
    Parser
  236. 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
  237. 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
  238. 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
  239. def toString(): String
    Definition Classes
    AnyRef → Any
  240. final def tokenSeparated[T](separator: Parser.Token, part: => T): List[T]

    .

    part { `sep` part }

    .

    Definition Classes
    ParserParserCommon
  241. 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
  242. def topStat: PartialFunction[Parser.Token, List[tools.nsc.Global.Tree]]
    Definition Classes
    QuasiquoteParserParser
  243. def topStatSeq(): List[tools.nsc.Global.Tree]

    TopStatSeq ::= TopStat {semi TopStat}
    TopStat ::= Annotations Modifiers TmplDef
              | Packaging
              | package object ObjectDef
              | Import
              |
    Definition Classes
    Parser
  244. val treeBuilder: ParserTreeBuilder
    Definition Classes
    QuasiquoteParserParser
  245. 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
  246. def typeBounds(): tools.nsc.Global.TypeBoundsTree

    TypeBounds ::= [`>:` Type] [`<:` Type]
    Definition Classes
    Parser
  247. 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
  248. def typeOrInfixType(location: Parser.Location): tools.nsc.Global.Tree
    Definition Classes
    Parser
  249. def typeParamClauseOpt(owner: tools.nsc.Global.Name, contextBoundBuf: ListBuffer[tools.nsc.Global.Tree], ownerKind: Parser.ParamOwner): 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
  250. def typedOpt(): tools.nsc.Global.Tree

    TypedOpt ::= [`:` Type]
    Definition Classes
    Parser
  251. def unit: tools.nsc.Global.CompilationUnit
    Definition Classes
    SourceFileParserParser
  252. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  253. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  254. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  255. def warning(offset: Parser.Offset, msg: String, category: WarningCategory, actions: List[CodeAction]): Unit
    Definition Classes
    SourceFileParserParser
  256. def warning(msg: String, category: WarningCategory, actions: List[CodeAction]): Unit
    Definition Classes
    Parser
  257. def warning(msg: String, category: WarningCategory): Unit
    Definition Classes
    Parser
  258. def wildImportSelector(): tools.nsc.Global.ImportSelector
    Definition Classes
    Parser
  259. def wildcardOrIdent(): tools.nsc.Global.Name
    Definition Classes
    Parser
  260. def wildcardType(start: Parser.Offset, qmark: Boolean): tools.nsc.Global.Ident

    WildcardType ::= `_` TypeBounds
    Definition Classes
    Parser
  261. def xmlLiteral(): tools.nsc.Global.Tree
    Definition Classes
    SourceFileParserParser
  262. def xmlLiteralPattern(): tools.nsc.Global.Tree
    Definition Classes
    SourceFileParserParser
  263. final val xmlSeqOK: 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
  264. def xmlSeqPatterns(): List[tools.nsc.Global.Tree]
    Definition Classes
    Parser
  265. object InfixMode extends Enumeration

    Modes for infix types.

    Modes for infix types.

    Definition Classes
    Parser
  266. object symbXMLBuilder extends SymbolicXMLBuilder
    Definition Classes
    SourceFileParser

Deprecated Value Members

  1. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from QuasiquoteParser toStringFormat[QuasiquoteParser] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @deprecated @inline()
    Deprecated

    (Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.

  2. def precedence(operator: tools.nsc.Global.Name): Int
    Definition Classes
    Parser
    Annotations
    @deprecated
    Deprecated

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

  3. def [B](y: B): (QuasiquoteParser, B)
    Implicit
    This member is added by an implicit conversion from QuasiquoteParser toArrowAssoc[QuasiquoteParser] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

Inherited from Parser.Parser

Inherited from Parser.ParserCommon

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromQuasiquoteParser to any2stringadd[QuasiquoteParser]

Inherited by implicit conversion StringFormat fromQuasiquoteParser to StringFormat[QuasiquoteParser]

Inherited by implicit conversion Ensuring fromQuasiquoteParser to Ensuring[QuasiquoteParser]

Inherited by implicit conversion ArrowAssoc fromQuasiquoteParser to ArrowAssoc[QuasiquoteParser]

Ungrouped