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 ScalametaParser to any2stringadd[ScalametaParser] performed by method any2stringadd in scala.Predef.

   Definition Classes

   any2stringadd

4.  def ->[B](y: B): (ScalametaParser, B)

   Implicit

   This member is added by an implicit conversion from ScalametaParser to ArrowAssoc[ScalametaParser] 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[T <: Token](implicit arg0: TokenInfo[T]): Unit

   Consume one token of the specified type, or signal an error if it is not there.

7.  def acceptOpt[T <: Token](implicit arg0: TokenInfo[T]): Unit

   If current token is T consume it.

8.  def acceptStatSep(): Unit

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

9.  def acceptStatSepOpt(): Unit
10.  def accessModifier(): Mod
11.  def accessModifierOpt(): Option[Mod]

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

12.  final def ahead[T](body: ⇒ T): T

    Scoping operator used to temporarily look into the future.

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

    Annotations

    @inline()

13.  def annots(skipNewLines: Boolean, allowArgss: Boolean = true): collection.immutable.List[Annot]

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

14.  def argumentExpr(): Arg
15.  def argumentExprs(): collection.immutable.List[Arg]

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

16.  def argumentExprsOrPrefixExpr(): collection.immutable.List[Arg]
17.  def argumentPattern(): Arg
18.  def argumentPatterns(): collection.immutable.List[Arg]
19.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

20.  def atPos[T <: Tree](start: Pos, end: Pos)(body: ⇒ T): T
21.  def auto: AutoPos.type
22.  def autoPos[T <: Tree](body: ⇒ T): T
23.  def batchSource(): Source
24.  def block(): Term

    Block ::= BlockStatSeq

    Note

    Return tree does not carry position.

25.  def blockExpr(): Term

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

26.  def blockStatSeq(): collection.immutable.List[Stat]

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

27.  def bound[T <: Token](implicit arg0: TokenInfo[T]): Option[Type]
28.  def caseClause(): Case
29.  def caseClauses(): collection.immutable.List[Case]

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

30.  def checkAssoc(op: Term.Name, leftAssoc: Boolean): Unit
31.  def classDef(mods: collection.immutable.List[Mod]): Class

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

32.  def clone(): AnyRef

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

33.  final def commaSeparated[T <: Tree](part: ⇒ T)(implicit arg0: AstInfo[T]): collection.immutable.List[T]

    Annotations

    @inline()

34.  def condExpr(): Term
35.  def constrBlock(): Block

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

36.  def constrExpr(): Term

    ConstrExpr      ::=  SelfInvocation
                      |  ConstrBlock

37.  def constructorAnnots(): collection.immutable.List[Annot]
38.  def constructorCall(tpe: Type, allowArgss: Boolean = true): Call
39.  def convertToParam(tree: Term): Option[Param]

    Convert tree to formal parameter.

40.  def convertToParams(tree: Term): collection.immutable.List[Param]

    Convert tree to formal parameter list.

41.  def convertToTypeId(ref: Term.Ref): Option[Type]
42.  implicit val currentDialect: Dialect
43.  def defOrDclOrSecondaryCtor(mods: collection.immutable.List[Mod]): Stat

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

44.  final def dropAnyBraces[T](body: ⇒ T): T

    Annotations

    @inline()

45.  def ellipsis[T <: Tree](rank: Int, astInfo: AstInfo[T], extraSkip: ⇒ Unit = {})(implicit arg0: AstInfo[T]): T
46.  def ensureEarlyDef(tree: Stat): Stat
47.  def ensuring(cond: (ScalametaParser) ⇒ Boolean, msg: ⇒ Any): ScalametaParser

    Implicit

    This member is added by an implicit conversion from ScalametaParser to Ensuring[ScalametaParser] performed by method Ensuring in scala.Predef.

    Definition Classes

    Ensuring

48.  def ensuring(cond: (ScalametaParser) ⇒ Boolean): ScalametaParser

    Implicit

    This member is added by an implicit conversion from ScalametaParser to Ensuring[ScalametaParser] performed by method Ensuring in scala.Predef.

    Definition Classes

    Ensuring

49.  def ensuring(cond: Boolean, msg: ⇒ Any): ScalametaParser

    Implicit

    This member is added by an implicit conversion from ScalametaParser to Ensuring[ScalametaParser] performed by method Ensuring in scala.Predef.

    Definition Classes

    Ensuring

50.  def ensuring(cond: Boolean): ScalametaParser

    Implicit

    This member is added by an implicit conversion from ScalametaParser to Ensuring[ScalametaParser] performed by method Ensuring in scala.Predef.

    Definition Classes

    Ensuring

51.  def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[Enumerator]
52.  def enumerators(): collection.immutable.List[Enumerator]

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

53.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

54.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

55.  def existentialStats(): collection.immutable.List[Stat]
56.  def expr(location: Location): Term
57.  def expr(): Term

    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}
                 | `:' `_' `*'

58.  def exprSimpleType(): Type
59.  def exprTypeArgs(): collection.immutable.List[Type]
60.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

61.  def formatted(fmtstr: String): String

    Implicit

    This member is added by an implicit conversion from ScalametaParser to StringFormat[ScalametaParser] performed by method StringFormat in scala.Predef.

    Definition Classes

    StringFormat

    Annotations

    @inline()

62.  def funDefOrDclOrSecondaryCtor(mods: collection.immutable.List[Mod]): Stat

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

63.  def funDefRest(mods: collection.immutable.List[Mod]): Stat
64.  def generator(eqOK: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[Enumerator]

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

65.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

66.  def guard(): Option[Term]

    Guard ::= if PostfixExpr

67.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

68.  def implicitClosure(location: Location): Term.Function

    Expr ::= implicit Id => Expr

69.  def importStmt(): Import

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

70.  def importWildcardOrName(): Importee
71.  def importee(): Importee

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

72.  def importees(): collection.immutable.List[Importee]

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

73.  def importer(): Importer

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

74.  var in: TokenIterator
75.  final def inBraces[T](body: ⇒ T): T

    Annotations

    @inline()

76.  final def inBracesOrError[T](body: ⇒ T, alt: T): T

    Annotations

    @inline()

77.  final def inBracesOrNil[T](body: ⇒ collection.immutable.List[T]): collection.immutable.List[T]

    Annotations

    @inline()

78.  final def inBracesOrUnit[T](body: ⇒ Term): Term

    Annotations

    @inline()

79.  final def inBrackets[T](body: ⇒ T): T

    Annotations

    @inline()

80.  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. token.LeftParen) will be returned instead of the contents of the groupers. However in all cases accept[LeftParen] will be called, so a parse error will still result. If the grouping is optional, token should be tested before calling these methods.

    Annotations

    @inline()

81.  final def inParensOrError[T](body: ⇒ T, alt: T): T

    Annotations

    @inline()

82.  final def inParensOrNil[T](body: ⇒ collection.immutable.List[T]): collection.immutable.List[T]

    Annotations

    @inline()

83.  final def inParensOrUnit[T, Ret >: Lit](body: ⇒ Ret): Ret

    Annotations

    @inline()

84.  implicit def intToIndexPos(index: Int): IndexPos
85.  def interpolate[Ctx <: Tree, Ret <: Tree](arg: () ⇒ Ctx, result: (Term.Name, collection.immutable.List[Lit], collection.immutable.List[Ctx]) ⇒ Ret): Ret
86.  def interpolatePat(): Interpolate
87.  def interpolateTerm(): Interpolate
88.  def isBackquoted: Boolean
89.  def isColonWildcardStar: Boolean
90.  def isIdent: Boolean
91.  def isIdentAnd(pred: (String) ⇒ Boolean): Boolean
92.  def isIdentExcept(except: String): Boolean
93.  def isIdentOf(name: String): Boolean
94.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

95.  def isRawAmpersand: Boolean
96.  def isRawBar: Boolean
97.  def isRawStar: Boolean
98.  def isSpliceFollowedBy(check: ⇒ Boolean): Boolean
99.  def isUnaryOp: Boolean
100.  def literal(isNegated: Boolean = false): Lit

     SimpleExpr    ::= literal
                     | symbol
                     | null

101.  def localDef(implicitMod: Option[Implicit]): Stat
102.  def localModifiers(): collection.immutable.List[Mod]

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

103.  def makeTuple[T <: Tree](body: collection.immutable.List[T], zero: () ⇒ T, tuple: (collection.immutable.List[T]) ⇒ T): T
104.  def makeTupleTerm(body: collection.immutable.List[Term]): Term
105.  def makeTupleTermParens(bodyf: ⇒ collection.immutable.List[Term]): Term
106.  def makeTupleType(body: collection.immutable.List[Type]): Type
107.  def mixinQualifier(): Qualifier

     MixinQualifier ::= `[' Id `]'

108.  def modifier(): Mod
109.  def modifiers(isLocal: Boolean = false): collection.immutable.List[Mod]

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

110.  implicit def modsToPos(mods: collection.immutable.List[Mod]): Pos
111.  final def ne(arg0: AnyRef): Boolean

     Definition Classes

     AnyRef

112.  def newLineOpt(): Unit
113.  def newLineOptWhenFollowedBy[T <: Token](implicit arg0: TokenInfo[T]): Unit
114.  def newLineOptWhenFollowing(p: (Token) ⇒ Boolean): Unit
115.  def newLinesOpt(): Unit
116.  def next(): Token
117.  def nextOnce(): Token
118.  def nextThrice(): Token
119.  def nextTwice(): Token
120.  def nonLocalDefOrDcl(): Stat
121.  final def notify(): Unit

     Definition Classes

     AnyRef

122.  final def notifyAll(): Unit

     Definition Classes

     AnyRef

123.  def objectDef(mods: collection.immutable.List[Mod]): Object

     ObjectDef       ::= Id ClassTemplateOpt

124.  def onlyAcceptMod[M <: Mod, T <: Token](mods: collection.immutable.List[Mod], errorMsg: String)(implicit classifier: Classifier[Mod, M], tag: ClassTag[M], tokenInfo: TokenInfo[T]): Unit
125.  implicit def optionTreeToPos(tree: Option[Tree]): Pos
126.  def packageDef(): Pkg
127.  def packageObjectDef(): Object
128.  def packageOrPackageObjectDef(): Stat
129.  def param(ownerIsCase: Boolean, ownerIsType: Boolean, isImplicit: Boolean): Param
130.  def paramClauses(ownerIsType: Boolean, ownerIsCase: Boolean = false): collection.immutable.List[collection.immutable.List[Param]]

     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]

131.  def paramType(): Arg

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

132.  def parseCase(): Case
133.  def parseCtorCall(): Call
134.  def parseEnumerator(): Enumerator
135.  def parseImportee(): Importee
136.  def parseImporter(): Importer
137.  def parseMod(): Mod
138.  def parsePat(): Pat
139.  def parsePatArg(): Arg
140.  def parsePatType(): Pat.Type
141.  def parseQuasiquoteCtor(): Ctor
142.  def parseQuasiquoteMod(): Mod
143.  def parseQuasiquotePat(): Pat
144.  def parseQuasiquotePatArg(): Arg
145.  def parseQuasiquotePatType(): Pat.Type
146.  def parseQuasiquoteStat(): Stat
147.  def parseQuasiquoteTemplate(): Template
148.  def parseRule[T <: Tree](rule: (ScalametaParser.this.type) ⇒ T): T
149.  def parseSource(): Source
150.  def parseStat(): Stat
151.  def parseTemplate(): Template
152.  def parseTerm(): Term
153.  def parseTermArg(): Arg
154.  def parseTermParam(): Param
155.  def parseType(): Type
156.  def parseTypeArg(): Arg
157.  def parseTypeParam(): Param
158.  def parseUnquotePat(): Pat
159.  def parseUnquoteTerm(): Term
160.  lazy val parserTokenPositions: Array[Int]
161.  lazy val parserTokens: Tokens
162.  def patDefOrDcl(mods: collection.immutable.List[Mod]): Stat

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

163.  def path(thisOK: Boolean = true): Term.Ref

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

164.  def pattern(): Arg

     Default entry points into some pattern contexts.

165.  def patternTyp(): Pat.Type
166.  def patternTypeArgs(): collection.immutable.List[Pat.Type]
167.  def peekingAhead[T](tree: ⇒ T): T

     Perform an operation while peeking ahead.

     Perform an operation while peeking ahead. Recover to inputal state in case of exception.

     Annotations

     @inline()

168.  def postfixExpr(): Term

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

169.  def prefixExpr(): Term

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

170.  def primaryCtor(owner: TemplateOwner): Primary
171.  def qualId(): Term.Ref

     QualId ::= Id {`.' Id}

172.  def quasiquoteCtor(): Ctor
173.  def quasiquotePattern(): Arg
174.  def quasiquotePatternArg(): Arg
175.  def quasiquotePatternTyp(): Pat.Type
176.  def quasiquoteTemplate(): Template
177.  def refineStat(): Option[Stat]
178.  def refineStatSeq(): collection.immutable.List[Stat]

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

179.  def refinement(): collection.immutable.List[Stat]

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

180.  def rejectMod[M <: Mod](mods: collection.immutable.List[Mod], errorMsg: String)(implicit classifier: Classifier[Mod, M], tag: ClassTag[M]): Unit
181.  def rejectModCombination[M1 <: Mod, M2 <: Mod](mods: collection.immutable.List[Mod], culprit: String)(implicit invalidMod: InvalidModCombination[M1, M2], classifier1: Classifier[Mod, M1], tag1: ClassTag[M1], classifier2: Classifier[Mod, M2], tag2: ClassTag[M2]): Unit
182.  lazy val reporter: Reporter
183.  lazy val scannerTokens: Tokens
184.  def scriptSource(): Source
185.  def secondaryCtor(mods: collection.immutable.List[Mod]): Secondary
186.  def selector(t: Term): Select
187.  def selectors(t: Term): Term.Ref
188.  def selfInvocation(): Term

     SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

189.  def seqPatterns(): collection.immutable.List[Arg]
190.  def simpleExpr(): Term

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

191.  def simpleExprRest(t: Term, canApply: Boolean): Term
192.  def source(): Source

     CompilationUnit ::= {package QualId semi} TopStatSeq

193.  def stableId(): Term.Ref

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

194.  def startInfixType(): Type
195.  def startModType(): Type
196.  def statSeq[T <: Tree](statpf: PartialFunction[Token, T], errorMsg: String = "illegal start of definition")(implicit arg0: AstInfo[T]): collection.immutable.List[T]
197.  final def synchronized[T0](arg0: ⇒ T0): T0

     Definition Classes

     AnyRef

198.  def syntaxErrorExpected[T <: Token](implicit arg0: TokenInfo[T]): Nothing
199.  def template(): Template

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

200.  def templateBody(isPre: Boolean): (Param, collection.immutable.List[Stat])

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

     isPre

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

201.  def templateBodyOpt(parenMeansSyntaxError: Boolean): (Param, Option[collection.immutable.List[Stat]])
202.  def templateOpt(owner: TemplateOwner): Template

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

203.  def templateParents(): collection.immutable.List[Call]

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

204.  def templateStat: PartialFunction[Token, Stat]
205.  def templateStatSeq(isPre: Boolean): (Param, collection.immutable.List[Stat])

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

     isPre

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

206.  def templateStats(): collection.immutable.List[Stat]

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

207.  def termName(advance: Boolean = true): Term.Name
208.  def tmplDef(mods: collection.immutable.List[Mod]): Member with Stat

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

209.  def toString(): String

     Definition Classes

     AnyRef → Any

210.  def token: Token
211.  final def tokenSeparated[Sep <: Token, T <: Tree](sepFirst: Boolean, part: ⇒ T)(implicit arg0: TokenInfo[Sep], arg1: AstInfo[T]): collection.immutable.List[T]

     , or if sepFirst is true,

     part { `sep` part }

     , or if sepFirst is true,

     { `sep` part }

     . if useUnquoteForEllipsis = true, uses direct unquote instead of part

     { sep part } }}} if useUnquoteForEllipsis = true, uses direct unquote instead of part

     part { sep part } }}} if useUnquoteForEllipsis = true, uses direct unquote instead of part

212.  implicit def tokenToTokenPos(token: Token): TokenPos
213.  def topLevelTmplDef: Member with Stat

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

214.  def topStat: PartialFunction[Token, Stat]
215.  def topStatSeq(): collection.immutable.List[Stat]

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

216.  def traitDef(mods: collection.immutable.List[Mod]): Trait

     TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

217.  implicit def treeToTreePos(tree: Tree): TreePos
218.  def typ(): Type

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

219.  def typeBounds(): Bounds

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

220.  def typeDefOrDcl(mods: collection.immutable.List[Mod]): Member.Type with Stat

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

221.  def typeName(advance: Boolean = true): Type.Name
222.  def typeOrInfixType(location: Location): Type
223.  def typeParam(ownerIsType: Boolean, ctxBoundsAllowed: Boolean): Param
224.  def typeParamClauseOpt(ownerIsType: Boolean, ctxBoundsAllowed: Boolean): collection.immutable.List[Param]

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

225.  def typedOpt(): Option[Type]

     TypedOpt ::= [`:' Type]

226.  def unquote[T <: Tree](implicit arg0: AstInfo[T]): T
227.  def unquote[T <: Tree](advance: Boolean = true)(implicit arg0: AstInfo[T]): T
228.  def unquoteExpr(): Term
229.  def unquotePattern(): Pat
230.  def unquoteXmlExpr(): Term
231.  def unquoteXmlPattern(): Pat
232.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

233.  final def wait(arg0: Long, arg1: Int): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

234.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

235.  def xmlLiteralPattern(): Pat
236.  def xmlPat(): Xml
237.  def xmlSeqPatterns(): collection.immutable.List[Arg]
238.  def xmlTerm(): Xml
239.  def →[B](y: B): (ScalametaParser, B)

     Implicit

     This member is added by an implicit conversion from ScalametaParser to ArrowAssoc[ScalametaParser] performed by method ArrowAssoc in scala.Predef.

     Definition Classes

     ArrowAssoc

240.  object AutoPos extends Pos with Product with Serializable
241.  object CanEndStat
242.  object CantStartStat
243.  object CaseDefEnd
244.  object CaseIntro
245.  object CloseDelim
246.  object DclIntro
247.  object DefIntro
248.  object ExprIntro
249.  implicit object InvalidFinalAbstract extends InvalidModCombination[Final, Abstract]
250.  implicit object InvalidFinalSealed extends InvalidModCombination[Final, Sealed]
251.  implicit object InvalidOverrideAbstract extends InvalidModCombination[Override, Abstract]
252.  object LineEnd
253.  object Literal
254.  object LocalModifier
255.  object Modifier
256.  object NonlocalModifier
257.  object NumericLiteral
258.  object OwnedByCaseClass extends TemplateOwner
259.  object OwnedByClass extends TemplateOwner
260.  object OwnedByObject extends TemplateOwner
261.  object OwnedByTrait extends TemplateOwner
262.  object StatSep
263.  object StatSeqEnd
264.  object TemplateIntro
265.  object Trivia
266.  object TypeIntro
267.  object Whitespace
268.  object noSeq extends SeqContextSensitive

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

269.  object outPattern extends PatternContextSensitive

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

270.  implicit object patInfixContext extends InfixContext
271.  object seqOK extends SeqContextSensitive

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

272.  object termInfixContext extends InfixContext
273.  object xmlSeqOK extends SeqContextSensitive

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