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 dropTrivialBlock(term: Term): Term

    

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

    

75. def ensureEarlyDef(tree: Stat): Stat

    

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

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

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

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

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

    

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

    

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

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

    

    Definition Classes

    AnyRef

83. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

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

    

85. def expr(location: Location): Term

    

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

87. def exprSimpleType(): Type

    

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

    

89. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

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

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

    

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

    

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

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

    

    Definition Classes

    AnyRef → Any

95. def guard(): Option[Term]

    

    Guard ::= if PostfixExpr

96. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

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

    

    Expr ::= implicit Id => Expr

98. def importStmt(): Import

    

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

99. def importWildcardOrName(): Importee

    

100. def importee(): Importee

     

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

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

     

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

102. def importer(): Importer

     

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

103. var in: TokenIterator

     

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

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

     

115. def interpolatePat(): Interpolate

     

116. def interpolateTerm(): Interpolate

     

117. def isBackquoted: Boolean

     

118. def isColonWildcardStar: Boolean

     

119. def isIdent: Boolean

     

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

     

121. def isIdentExcept(except: String): Boolean

     

122. def isIdentOf(name: String): Boolean

     

123. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

124. def isRawAmpersand: Boolean

     

125. def isRawBar: Boolean

     

126. def isRawStar: Boolean

     

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

     

128. def isUnaryOp: Boolean

     

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

     

     SimpleExpr    ::= literal
                     | symbol
                     | null

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

     

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

     

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

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

     

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

     

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

     

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

     

136. def mixinQualifier(): Qualifier

     

     MixinQualifier ::= `[' Id `]'

137. def modifier(): Mod

     

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

     

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

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

     

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

     

     Definition Classes

     AnyRef

141. def newLineOpt(): Unit

     

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

     

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

     

144. def newLinesOpt(): Unit

     

145. def next(): Token

     

146. def nextOnce(): Token

     

147. def nextThrice(): Token

     

148. def nextTwice(): Token

     

149. object noSeq extends SeqContextSensitive

     

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

150. def nonLocalDefOrDcl(): Stat

     

151. final def notify(): Unit

     

     Definition Classes

     AnyRef

152. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

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

     

     ObjectDef       ::= Id ClassTemplateOpt

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

     

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

     

156. object outPattern extends PatternContextSensitive

     

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

157. def packageDef(): Pkg

     

158. def packageObjectDef(): Object

     

159. def packageOrPackageObjectDef(): Stat

     

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

     

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

162. def paramType(): Arg

     

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

163. def parseCase(): Case

     

164. def parseCtorCall(): Call

     

165. def parseEnumerator(): Enumerator

     

166. def parseImportee(): Importee

     

167. def parseImporter(): Importer

     

168. def parseMod(): Mod

     

169. def parsePat(): Pat

     

170. def parsePatArg(): Arg

     

171. def parsePatType(): Pat.Type

     

172. def parseQuasiquoteCtor(): Ctor

     

173. def parseQuasiquoteMod(): Mod

     

174. def parseQuasiquotePat(): Pat

     

175. def parseQuasiquotePatArg(): Arg

     

176. def parseQuasiquotePatType(): Pat.Type

     

177. def parseQuasiquoteStat(): Stat

     

178. def parseQuasiquoteTemplate(): Template

     

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

     

180. def parseSource(): Source

     

181. def parseStat(): Stat

     

182. def parseTemplate(): Template

     

183. def parseTerm(): Term

     

184. def parseTermArg(): Arg

     

185. def parseTermParam(): Param

     

186. def parseType(): Type

     

187. def parseTypeArg(): Arg

     

188. def parseTypeParam(): Param

     

189. def parseUnquotePat(): Pat

     

190. def parseUnquoteTerm(): Term

     

191. lazy val parserTokenPositions: Array[Int]

     

192. lazy val parserTokens: Tokens

     

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

     

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

194. implicit object patInfixContext extends InfixContext

     

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

     

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

196. def pattern(): Arg

     

     Default entry points into some pattern contexts.

197. def patternTyp(): Pat.Type

     

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

     

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

200. def postfixExpr(): Term

     

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

201. def prefixExpr(): Term

     

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

202. def primaryCtor(owner: TemplateOwner): Primary

     

203. def qualId(): Term.Ref

     

     QualId ::= Id {`.' Id}

204. def quasiquoteCtor(): Ctor

     

205. def quasiquotePattern(): Arg

     

206. def quasiquotePatternArg(): Arg

     

207. def quasiquotePatternTyp(): Pat.Type

     

208. def quasiquoteTemplate(): Template

     

209. def refineStat(): Option[Stat]

     

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

     

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

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

     

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

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

     

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

     

214. lazy val reporter: Reporter

     

215. lazy val scannerTokens: Tokens

     

216. def scriptSource(): Source

     

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

     

218. def selector(t: Term): Select

     

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

     

220. def selfInvocation(): Term

     

     SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

221. object seqOK extends SeqContextSensitive

     

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

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

     

223. def simpleExpr(): Term

     

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

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

     

225. def source(): Source

     

     CompilationUnit ::= {package QualId semi} TopStatSeq

226. def stableId(): Term.Ref

     

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

227. def startInfixType(): Type

     

228. def startModType(): Type

     

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

     

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

     

     Definition Classes

     AnyRef

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

     

232. def template(): Template

     

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

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

     

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

     isPre

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

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

     

235. def templateOpt(owner: TemplateOwner): Template

     

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

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

     

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

237. def templateStat: PartialFunction[Token, Stat]

     

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

     

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

     isPre

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

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

     

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

240. object termInfixContext extends InfixContext

     

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

     

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

     

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

243. def toString(): String

     

     Definition Classes

     AnyRef → Any

244. def token: Token

     

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

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

     

247. def topLevelTmplDef: Member with Stat

     

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

248. def topStat: PartialFunction[Token, Stat]

     

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

     

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

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

     

     TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

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

     

252. def typ(): Type

     

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

253. def typeBounds(): Bounds

     

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

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

     

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

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

     

256. def typeOrInfixType(location: Location): Type

     

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

     

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

259. def typedOpt(): Option[Type]

     

     TypedOpt ::= [`:' Type]

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

     

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

     

262. def unquoteExpr(): Term

     

263. def unquotePattern(): Pat

     

264. def unquoteXmlExpr(): Term

     

265. def unquoteXmlPattern(): Pat

     

266. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

269. def xmlLiteralPattern(): Pat

     

270. def xmlPat(): Xml

     

271. object xmlSeqOK extends SeqContextSensitive

     

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

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

     

273. def xmlTerm(): Xml

     

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