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 DclIntro

    

12. object DefIntro

    

13. object ExprIntro

    

14. object Literal

    

15. object LocalModifier

    

16. object Modifier

    

17. object NonlocalModifier

    

18. object NumericLiteral

    

19. object OwnedByCaseClass extends TemplateOwner

    

20. object OwnedByClass extends TemplateOwner

    

21. object OwnedByObject extends TemplateOwner

    

22. object OwnedByTrait extends TemplateOwner

    

23. object StatSep

    

24. object StatSeqEnd

    

25. object TemplateIntro

    

26. object Trivia

    

27. object TypeIntro

    

28. object Whitespace

    

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

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

    

    If current token is T consume it.

31. def acceptStatSep(): Unit

    

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

32. def acceptStatSepOpt(): Unit

    

33. def accessModifier(): Mod

    

34. def accessModifierOpt(): Option[Mod]

    

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

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

36. def annotTypeRest(t: Type): Type

    

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

    

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

38. def argumentExpr(): Arg

    

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

    

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

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

    

41. def argumentPattern(): Arg

    

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

    

43. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

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

    

45. def auto: AutoPos.type

    

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

    

47. def batchSource(): Source

    

48. def block(): Term

    

    Block ::= BlockStatSeq

    Note

    Return tree does not carry position.

49. def blockExpr(): Term

    

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

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

    

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

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

    

52. def caseClause(): Case

    

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

    

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

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

    

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

    

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

56. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Annotations

    @inline()

58. def condExpr(): Term

    

59. def constrBlock(): Block

    

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

60. def constrExpr(): Term

    

    ConstrExpr      ::=  SelfInvocation
                      |  ConstrBlock

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

    

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

    

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

    

    Convert tree to formal parameter.

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

    

    Convert tree to formal parameter list.

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

    

66. implicit val currentDialect: Dialect

    

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

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

    

    Annotations

    @inline()

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

    

70. def ensureEarlyDef(tree: Stat): Stat

    

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

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

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

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

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

    

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

    

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

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

    

    Definition Classes

    AnyRef

78. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

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

    

80. def expr(location: Location): Term

    

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

82. def exprSimpleType(): Type

    

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

    

84. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

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

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

    

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

    

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

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

    

    Definition Classes

    AnyRef → Any

90. def guard(): Option[Term]

    

    Guard ::= if PostfixExpr

91. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

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

    

    Expr ::= implicit Id => Expr

93. def importStmt(): Import

    

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

94. def importWildcardOrName(): Importee

    

95. def importee(): Importee

    

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

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

    

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

97. def importer(): Importer

    

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

98. var in: TokenIterator

    

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

    

    Annotations

    @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

108. def inQuasiquote: Boolean

     

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

     

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

     

111. def interpolatePat(): Interpolate

     

112. def interpolateTerm(): Interpolate

     

113. def isBackquoted: Boolean

     

114. def isColonWildcardStar: Boolean

     

115. def isIdent: Boolean

     

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

     

117. def isIdentExcept(except: String): Boolean

     

118. def isIdentOf(name: String): Boolean

     

119. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

120. def isRawBar: Boolean

     

121. def isRawStar: Boolean

     

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

     

123. def isUnaryOp: Boolean

     

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

     

     SimpleExpr    ::= literal
                     | symbol
                     | null

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

     

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

     

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

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

     

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

     

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

     

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

     

131. def mixinQualifier(): Qualifier

     

     MixinQualifier ::= `[' Id `]'

132. def modifier(): Mod

     

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

     

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

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

     

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

     

     Definition Classes

     AnyRef

136. def newLineOpt(): Unit

     

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

     

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

     

139. def newLinesOpt(): Unit

     

140. def next(): Token

     

141. def nextOnce(): Token

     

142. def nextThrice(): Token

     

143. def nextTwice(): Token

     

144. object noSeq extends SeqContextSensitive

     

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

145. def nonLocalDefOrDcl(): Stat

     

146. final def notify(): Unit

     

     Definition Classes

     AnyRef

147. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

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

     

     ObjectDef       ::= Id ClassTemplateOpt

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

     

150. object outPattern extends PatternContextSensitive

     

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

151. def packageDef(): Pkg

     

152. def packageObjectDef(): Object

     

153. def packageOrPackageObjectDef(): Stat

     

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

     

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

156. def paramType(): Arg

     

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

157. def parseCase(): Case

     

158. def parseCtorCall(): Call

     

159. def parseEnumerator(): Enumerator

     

160. def parseImportee(): Importee

     

161. def parseImporter(): Importer

     

162. def parseMod(): Mod

     

163. def parsePat(): Pat

     

164. def parsePatArg(): Arg

     

165. def parsePatType(): Pat.Type

     

166. def parseQuasiquoteCtor(): Ctor

     

167. def parseQuasiquoteMod(): Mod

     

168. def parseQuasiquotePat(): Pat

     

169. def parseQuasiquotePatArg(): Arg

     

170. def parseQuasiquotePatType(): Pat.Type

     

171. def parseQuasiquoteStat(): Stat

     

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

     

173. def parseSource(): Source

     

174. def parseStat(): Stat

     

175. def parseTemplate(): Template

     

176. def parseTerm(): Term

     

177. def parseTermArg(): Arg

     

178. def parseTermParam(): Param

     

179. def parseType(): Type

     

180. def parseTypeArg(): Arg

     

181. def parseTypeParam(): Param

     

182. def parseUnquotePat(): Pat

     

183. def parseUnquoteTerm(): Term

     

184. lazy val parserTokenPositions: Array[Int]

     

185. lazy val parserTokens: Tokens

     

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

     

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

187. implicit object patInfixContext extends InfixContext

     

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

     

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

189. def pattern(): Arg

     

     Default entry points into some pattern contexts.

190. def patternTyp(): Pat.Type

     

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

     

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

193. def postfixExpr(): Term

     

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

194. def prefixExpr(): Term

     

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

195. def primaryCtor(owner: TemplateOwner): Primary

     

196. def qualId(): Term.Ref

     

     QualId ::= Id {`.' Id}

197. def quasiquoteCtor(): Ctor

     

198. def quasiquotePattern(): Arg

     

199. def quasiquotePatternArg(): Arg

     

200. def quasiquotePatternTyp(): Pat.Type

     

201. def refineStat(): Option[Stat]

     

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

     

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

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

     

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

204. lazy val reporter: Reporter

     

205. lazy val scannerTokens: Tokens

     

206. def scriptSource(): Source

     

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

     

208. def selector(t: Term): Select

     

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

     

210. def selfInvocation(): Term

     

     SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

211. object seqOK extends SeqContextSensitive

     

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

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

     

213. def simpleExpr(): Term

     

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

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

     

215. def source(): Source

     

     CompilationUnit ::= {package QualId semi} TopStatSeq

216. def stableId(): Term.Ref

     

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

217. def startInfixType(): Type

     

218. def startModType(): Type

     

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

     

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

     

     Definition Classes

     AnyRef

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

     

222. def template(): Template

     

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

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

     

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

     isPre

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

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

     

225. def templateOpt(owner: TemplateOwner): Template

     

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

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

     

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

227. def templateStat: PartialFunction[Token, Stat]

     

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

     

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

     isPre

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

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

     

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

230. object termInfixContext extends InfixContext

     

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

     

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

     

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

233. def toString(): String

     

     Definition Classes

     AnyRef → Any

234. def token: Token

     

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

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

     

237. def topLevelTmplDef: Member with Stat

     

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

238. def topStat: PartialFunction[Token, Stat]

     

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

     

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

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

     

     TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

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

     

242. def typ(): Type

     

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

243. def typeBounds(): Bounds

     

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

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

     

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

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

     

246. def typeOrInfixType(location: Location): Type

     

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

     

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

249. def typedOpt(): Option[Type]

     

     TypedOpt ::= [`:' Type]

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

     

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

     

252. def unquoteExpr(): Term

     

253. def unquotePattern(): Pat

     

254. def unquoteXmlExpr(): Term

     

255. def unquoteXmlPattern(): Pat

     

256. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

259. def xmlLiteralPattern(): Pat

     

260. def xmlPat(): Xml

     

261. object xmlSeqOK extends SeqContextSensitive

     

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

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

     

263. def xmlTerm(): Xml

     

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