ScalametaParser

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 information

   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 information

   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. object AutoPos extends Pos with Product with Serializable

   

7. object CanEndStat

   

8. object CantStartStat

   

9. object CaseDefEnd

   

10. object CaseIntro

    

11. object CloseDelim

    

12. object DclIntro

    

13. object DefIntro

    

14. object ExprIntro

    

15. implicit object InvalidFinalAbstract extends InvalidModCombination[Final, Abstract]

    

16. implicit object InvalidFinalSealed extends InvalidModCombination[Final, Sealed]

    

17. implicit object InvalidOverrideAbstract extends InvalidModCombination[Override, Abstract]

    

18. object LineEnd

    

19. object Literal

    

20. object LocalModifier

    

21. object Modifier

    

22. object NonlocalModifier

    

23. object NumericLiteral

    

24. object OwnedByCaseClass extends TemplateOwner

    

25. object OwnedByClass extends TemplateOwner

    

26. object OwnedByObject extends TemplateOwner

    

27. object OwnedByTrait extends TemplateOwner

    

28. object StatSep

    

29. object StatSeqEnd

    

30. object TemplateIntro

    

31. object Trivia

    

32. object TypeIntro

    

33. object Whitespace

    

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

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

    

    If current token is T consume it.

36. def acceptStatSep(): Unit

    

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

37. def acceptStatSepOpt(): Unit

    

38. def accessModifier(): Mod

    

39. def accessModifierOpt(): Option[Mod]

    

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

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

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

    

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

42. def argumentExpr(): Arg

    

43. def argumentExprs(): collection.immutable.List[Arg]

    

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

44. def argumentExprsOrPrefixExpr(): collection.immutable.List[Arg]

    

45. def argumentPattern(): Arg

    

46. def argumentPatterns(): collection.immutable.List[Arg]

    

47. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

48. def atPos[T <: Tree](start: Pos, end: Pos)(body: ⇒ T): T

    

49. def auto: AutoPos.type

    

50. def autoPos[T <: Tree](body: ⇒ T): T

    

51. def batchSource(): Source

    

52. def block(): Term

    

    Block ::= BlockStatSeq

    Note

    Return tree does not carry position.

53. def blockExpr(): Term

    

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

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

    

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

55. def bound[T <: Token](implicit arg0: TokenInfo[T]): Option[Type]

    

56. def caseClause(): Case

    

57. def caseClauses(): collection.immutable.List[Case]

    

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

58. def checkAssoc(op: Term.Name, leftAssoc: Boolean): Unit

    

59. def classDef(mods: collection.immutable.List[Mod]): Class

    

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

60. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Annotations

    @inline()

62. def condExpr(): Term

    

63. def constrBlock(): Block

    

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

64. def constrExpr(): Term

    

    ConstrExpr      ::=  SelfInvocation
                      |  ConstrBlock

65. def constructorAnnots(): collection.immutable.List[Annot]

    

66. def constructorCall(tpe: Type, allowArgss: Boolean = true): Call

    

67. def convertToParam(tree: Term): Option[Param]

    

    Convert tree to formal parameter.

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

    

    Convert tree to formal parameter list.

69. def convertToTypeId(ref: Term.Ref): Option[Type]

    

70. implicit val currentDialect: Dialect

    

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

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

    

    Annotations

    @inline()

73. def ellipsis[T <: Tree](rank: Int, astInfo: AstInfo[T], extraSkip: ⇒ Unit = {})(implicit arg0: AstInfo[T]): T

    

74. def ensureEarlyDef(tree: Stat): Stat

    

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

    

    Implicit information

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

    Definition Classes

    Ensuring

76. def ensuring(cond: (ScalametaParser) ⇒ Boolean): ScalametaParser

    

    Implicit information

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

    Definition Classes

    Ensuring

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

    

    Implicit information

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

    Definition Classes

    Ensuring

78. def ensuring(cond: Boolean): ScalametaParser

    

    Implicit information

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

    Definition Classes

    Ensuring

79. def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[Enumerator]

    

80. def enumerators(): collection.immutable.List[Enumerator]

    

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

81. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

82. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

83. def existentialStats(): collection.immutable.List[Stat]

    

84. def expr(location: Location): Term

    

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

86. def exprSimpleType(): Type

    

87. def exprTypeArgs(): collection.immutable.List[Type]

    

88. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

89. def formatted(fmtstr: String): String

    

    Implicit information

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

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

91. def funDefRest(mods: collection.immutable.List[Mod]): Stat

    

92. def generator(eqOK: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[Enumerator]

    

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

93. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

94. def guard(): Option[Term]

    

    Guard ::= if PostfixExpr

95. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

96. def implicitClosure(location: Location): Term.Function

    

    Expr ::= implicit Id => Expr

97. def importStmt(): Import

    

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

98. def importWildcardOrName(): Importee

    

99. def importee(): Importee

    

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

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

     

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

101. def importer(): Importer

     

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

102. var in: TokenIterator

     

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

112. implicit def intToIndexPos(index: Int): IndexPos

     

113. def interpolate[Ctx <: Tree, Ret <: Tree](arg: () ⇒ Ctx, result: (Term.Name, collection.immutable.List[Lit], collection.immutable.List[Ctx]) ⇒ Ret): Ret

     

114. def interpolatePat(): Interpolate

     

115. def interpolateTerm(): Interpolate

     

116. def isBackquoted: Boolean

     

117. def isColonWildcardStar: Boolean

     

118. def isIdent: Boolean

     

119. def isIdentAnd(pred: (String) ⇒ Boolean): Boolean

     

120. def isIdentExcept(except: String): Boolean

     

121. def isIdentOf(name: String): Boolean

     

122. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

123. def isRawAmpersand: Boolean

     

124. def isRawBar: Boolean

     

125. def isRawStar: Boolean

     

126. def isSpliceFollowedBy(check: ⇒ Boolean): Boolean

     

127. def isUnaryOp: Boolean

     

128. def literal(isNegated: Boolean = false): Lit

     

     SimpleExpr    ::= literal
                     | symbol
                     | null

129. def localDef(implicitMod: Option[Implicit]): Stat

     

130. def localModifiers(): collection.immutable.List[Mod]

     

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

131. def makeTuple[T <: Tree](body: collection.immutable.List[T], zero: () ⇒ T, tuple: (collection.immutable.List[T]) ⇒ T): T

     

132. def makeTupleTerm(body: collection.immutable.List[Term]): Term

     

133. def makeTupleTermParens(bodyf: ⇒ collection.immutable.List[Term]): Term

     

134. def makeTupleType(body: collection.immutable.List[Type]): Type

     

135. def mixinQualifier(): Qualifier

     

     MixinQualifier ::= `[' Id `]'

136. def modifier(): Mod

     

137. def modifiers(isLocal: Boolean = false): collection.immutable.List[Mod]

     

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

138. implicit def modsToPos(mods: collection.immutable.List[Mod]): Pos

     

139. final def ne(arg0: AnyRef): Boolean

     

     Definition Classes

     AnyRef

140. def newLineOpt(): Unit

     

141. def newLineOptWhenFollowedBy[T <: Token](implicit arg0: TokenInfo[T]): Unit

     

142. def newLineOptWhenFollowing(p: (Token) ⇒ Boolean): Unit

     

143. def newLinesOpt(): Unit

     

144. def next(): Token

     

145. def nextOnce(): Token

     

146. def nextThrice(): Token

     

147. def nextTwice(): Token

     

148. object noSeq extends SeqContextSensitive

     

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

149. def nonLocalDefOrDcl(): Stat

     

150. final def notify(): Unit

     

     Definition Classes

     AnyRef

151. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

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

     

     ObjectDef       ::= Id ClassTemplateOpt

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

     

154. implicit def optionTreeToPos(tree: Option[Tree]): Pos

     

155. object outPattern extends PatternContextSensitive

     

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

156. def packageDef(): Pkg

     

157. def packageObjectDef(): Object

     

158. def packageOrPackageObjectDef(): Stat

     

159. def param(ownerIsCase: Boolean, ownerIsType: Boolean, isImplicit: Boolean): Param

     

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

161. def paramType(): Arg

     

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

162. def parseCase(): Case

     

163. def parseCtorCall(): Call

     

164. def parseEnumerator(): Enumerator

     

165. def parseImportee(): Importee

     

166. def parseImporter(): Importer

     

167. def parseMod(): Mod

     

168. def parsePat(): Pat

     

169. def parsePatArg(): Arg

     

170. def parsePatType(): Pat.Type

     

171. def parseQuasiquoteCtor(): Ctor

     

172. def parseQuasiquoteMod(): Mod

     

173. def parseQuasiquotePat(): Pat

     

174. def parseQuasiquotePatArg(): Arg

     

175. def parseQuasiquotePatType(): Pat.Type

     

176. def parseQuasiquoteStat(): Stat

     

177. def parseQuasiquoteTemplate(): Template

     

178. def parseRule[T <: Tree](rule: (ScalametaParser.this.type) ⇒ T): T

     

179. def parseSource(): Source

     

180. def parseStat(): Stat

     

181. def parseTemplate(): Template

     

182. def parseTerm(): Term

     

183. def parseTermArg(): Arg

     

184. def parseTermParam(): Param

     

185. def parseType(): Type

     

186. def parseTypeArg(): Arg

     

187. def parseTypeParam(): Param

     

188. def parseUnquotePat(): Pat

     

189. def parseUnquoteTerm(): Term

     

190. lazy val parserTokenPositions: Array[Int]

     

191. lazy val parserTokens: Tokens

     

192. def patDefOrDcl(mods: collection.immutable.List[Mod]): Stat

     

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

193. implicit object patInfixContext extends InfixContext

     

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

     

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

195. def pattern(): Arg

     

     Default entry points into some pattern contexts.

196. def patternTyp(): Pat.Type

     

197. def patternTypeArgs(): collection.immutable.List[Pat.Type]

     

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

199. def postfixExpr(): Term

     

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

200. def prefixExpr(): Term

     

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

201. def primaryCtor(owner: TemplateOwner): Primary

     

202. def qualId(): Term.Ref

     

     QualId ::= Id {`.' Id}

203. def quasiquoteCtor(): Ctor

     

204. def quasiquotePattern(): Arg

     

205. def quasiquotePatternArg(): Arg

     

206. def quasiquotePatternTyp(): Pat.Type

     

207. def quasiquoteTemplate(): Template

     

208. def refineStat(): Option[Stat]

     

209. def refineStatSeq(): collection.immutable.List[Stat]

     

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

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

     

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

211. def rejectMod[M <: Mod](mods: collection.immutable.List[Mod], errorMsg: String)(implicit classifier: Classifier[Mod, M], tag: ClassTag[M]): Unit

     

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

     

213. lazy val reporter: Reporter

     

214. lazy val scannerTokens: Tokens

     

215. def scriptSource(): Source

     

216. def secondaryCtor(mods: collection.immutable.List[Mod]): Secondary

     

217. def selector(t: Term): Select

     

218. def selectors(t: Term): Term.Ref

     

219. def selfInvocation(): Term

     

     SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

220. object seqOK extends SeqContextSensitive

     

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

221. def seqPatterns(): collection.immutable.List[Arg]

     

222. def simpleExpr(): Term

     

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

223. def simpleExprRest(t: Term, canApply: Boolean): Term

     

224. def source(): Source

     

     CompilationUnit ::= {package QualId semi} TopStatSeq

225. def stableId(): Term.Ref

     

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

226. def startInfixType(): Type

     

227. def startModType(): Type

     

228. def statSeq[T <: Tree](statpf: PartialFunction[Token, T], errorMsg: String = "illegal start of definition")(implicit arg0: AstInfo[T]): collection.immutable.List[T]

     

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

     

     Definition Classes

     AnyRef

230. def syntaxErrorExpected[T <: Token](implicit arg0: TokenInfo[T]): Nothing

     

231. def template(): Template

     

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

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

     

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

     isPre

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

233. def templateBodyOpt(parenMeansSyntaxError: Boolean): (Param, Option[collection.immutable.List[Stat]])

     

234. def templateOpt(owner: TemplateOwner): Template

     

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

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

     

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

236. def templateStat: PartialFunction[Token, Stat]

     

237. def templateStatSeq(isPre: Boolean): (Param, collection.immutable.List[Stat])

     

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

     isPre

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

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

     

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

239. object termInfixContext extends InfixContext

     

240. def termName(advance: Boolean = true): Term.Name

     

241. def tmplDef(mods: collection.immutable.List[Mod]): Member with Stat

     

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

242. def toString(): String

     

     Definition Classes

     AnyRef → Any

243. def token: Token

     

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

245. implicit def tokenToTokenPos(token: Token): TokenPos

     

246. def topLevelTmplDef: Member with Stat

     

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

247. def topStat: PartialFunction[Token, Stat]

     

248. def topStatSeq(): collection.immutable.List[Stat]

     

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

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

     

     TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

250. implicit def treeToTreePos(tree: Tree): TreePos

     

251. def typ(): Type

     

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

252. def typeBounds(): Bounds

     

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

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

     

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

254. def typeName(advance: Boolean = true): Type.Name

     

255. def typeOrInfixType(location: Location): Type

     

256. def typeParam(ownerIsType: Boolean, ctxBoundsAllowed: Boolean): Param

     

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

258. def typedOpt(): Option[Type]

     

     TypedOpt ::= [`:' Type]

259. def unquote[T <: Tree](implicit arg0: AstInfo[T]): T

     

260. def unquote[T <: Tree](advance: Boolean = true)(implicit arg0: AstInfo[T]): T

     

261. def unquoteExpr(): Term

     

262. def unquotePattern(): Pat

     

263. def unquoteXmlExpr(): Term

     

264. def unquoteXmlPattern(): Pat

     

265. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

267. final def wait(arg0: Long): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

268. def xmlLiteralPattern(): Pat

     

269. def xmlPat(): Xml

     

270. object xmlSeqOK extends SeqContextSensitive

     

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

271. def xmlSeqPatterns(): collection.immutable.List[Arg]

     

272. def xmlTerm(): Xml

     

273. def →[B](y: B): (ScalametaParser, B)

     

     Implicit information

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

     Definition Classes

     ArrowAssoc