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 allowInline: Boolean

    

37. def annotTypeRest(t: Type): Type

    

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

    

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

39. def argumentExpr(): Arg

    

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

    

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

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

    

42. def argumentPattern(): Arg

    

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

    

44. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

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

    

46. def auto: AutoPos.type

    

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

    

48. def batchSource(): Source

    

49. def block(): Term

    

    Block ::= BlockStatSeq

    Note

    Return tree does not carry position.

50. def blockExpr(): Term

    

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

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

    

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

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

    

53. def caseClause(): Case

    

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

    

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

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

    

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

    

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

57. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Annotations

    @inline()

59. def condExpr(): Term

    

60. def constrBlock(): Block

    

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

61. def constrExpr(): Term

    

    ConstrExpr      ::=  SelfInvocation
                      |  ConstrBlock

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

    

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

    

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

    

    Convert tree to formal parameter.

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

    

    Convert tree to formal parameter list.

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

    

67. implicit val currentDialect: Dialect

    

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

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

    

    Annotations

    @inline()

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

    

71. def ensureEarlyDef(tree: Stat): Stat

    

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

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

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

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

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

    

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

    

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

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

    

    Definition Classes

    AnyRef

79. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

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

    

81. def expr(location: Location): Term

    

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

83. def exprSimpleType(): Type

    

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

    

85. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

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

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

    

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

    

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

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

    

    Definition Classes

    AnyRef → Any

91. def guard(): Option[Term]

    

    Guard ::= if PostfixExpr

92. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

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

    

    Expr ::= implicit Id => Expr

94. def importStmt(): Import

    

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

95. def importWildcardOrName(): Importee

    

96. def importee(): Importee

    

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

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

    

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

98. def importer(): Importer

    

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

99. var in: TokenIterator

    

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

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

     

     Annotations

     @inline()

109. def inQuasiquote: Boolean

     

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

     

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

     

112. def interpolatePat(): Interpolate

     

113. def interpolateTerm(): Interpolate

     

114. def isBackquoted: Boolean

     

115. def isColonWildcardStar: Boolean

     

116. def isIdent: Boolean

     

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

     

118. def isIdentExcept(except: String): Boolean

     

119. def isIdentOf(name: String): Boolean

     

120. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

121. def isRawBar: Boolean

     

122. def isRawStar: Boolean

     

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

     

124. def isUnaryOp: Boolean

     

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

     

     SimpleExpr    ::= literal
                     | symbol
                     | null

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

     

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

     

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

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

     

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

     

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

     

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

     

132. def mixinQualifier(): Qualifier

     

     MixinQualifier ::= `[' Id `]'

133. def modifier(): Mod

     

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

     

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

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

     

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

     

     Definition Classes

     AnyRef

137. def newLineOpt(): Unit

     

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

     

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

     

140. def newLinesOpt(): Unit

     

141. def next(): Token

     

142. def nextOnce(): Token

     

143. def nextThrice(): Token

     

144. def nextTwice(): Token

     

145. object noSeq extends SeqContextSensitive

     

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

146. def nonLocalDefOrDcl(): Stat

     

147. final def notify(): Unit

     

     Definition Classes

     AnyRef

148. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

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

     

     ObjectDef       ::= Id ClassTemplateOpt

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

     

151. object outPattern extends PatternContextSensitive

     

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

152. def packageDef(): Pkg

     

153. def packageObjectDef(): Object

     

154. def packageOrPackageObjectDef(): Stat

     

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

     

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

157. def paramType(): Arg

     

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

158. def parseCase(): Case

     

159. def parseCtorCall(): Call

     

160. def parseEnumerator(): Enumerator

     

161. def parseImportee(): Importee

     

162. def parseImporter(): Importer

     

163. def parseMod(): Mod

     

164. def parsePat(): Pat

     

165. def parsePatArg(): Arg

     

166. def parsePatType(): Pat.Type

     

167. def parseQuasiquoteCtor(): Ctor

     

168. def parseQuasiquoteMod(): Mod

     

169. def parseQuasiquotePat(): Pat

     

170. def parseQuasiquotePatArg(): Arg

     

171. def parseQuasiquotePatType(): Pat.Type

     

172. def parseQuasiquoteStat(): Stat

     

173. def parseQuasiquoteTemplate(): Template

     

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

     

175. def parseSource(): Source

     

176. def parseStat(): Stat

     

177. def parseTemplate(): Template

     

178. def parseTerm(): Term

     

179. def parseTermArg(): Arg

     

180. def parseTermParam(): Param

     

181. def parseType(): Type

     

182. def parseTypeArg(): Arg

     

183. def parseTypeParam(): Param

     

184. def parseUnquotePat(): Pat

     

185. def parseUnquoteTerm(): Term

     

186. lazy val parserTokenPositions: Array[Int]

     

187. lazy val parserTokens: Tokens

     

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

     

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

189. implicit object patInfixContext extends InfixContext

     

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

     

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

191. def pattern(): Arg

     

     Default entry points into some pattern contexts.

192. def patternTyp(): Pat.Type

     

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

     

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

195. def postfixExpr(): Term

     

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

196. def prefixExpr(): Term

     

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

197. def primaryCtor(owner: TemplateOwner): Primary

     

198. def qualId(): Term.Ref

     

     QualId ::= Id {`.' Id}

199. def quasiquoteCtor(): Ctor

     

200. def quasiquotePattern(): Arg

     

201. def quasiquotePatternArg(): Arg

     

202. def quasiquotePatternTyp(): Pat.Type

     

203. def quasiquoteTemplate(): Template

     

204. def refineStat(): Option[Stat]

     

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

     

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

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

     

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

207. lazy val reporter: Reporter

     

208. lazy val scannerTokens: Tokens

     

209. def scriptSource(): Source

     

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

     

211. def selector(t: Term): Select

     

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

     

213. def selfInvocation(): Term

     

     SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

214. object seqOK extends SeqContextSensitive

     

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

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

     

216. def simpleExpr(): Term

     

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

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

     

218. def source(): Source

     

     CompilationUnit ::= {package QualId semi} TopStatSeq

219. def stableId(): Term.Ref

     

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

220. def startInfixType(): Type

     

221. def startModType(): Type

     

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

     

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

     

     Definition Classes

     AnyRef

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

     

225. def template(): Template

     

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

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

     

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

     isPre

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

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

     

228. def templateOpt(owner: TemplateOwner): Template

     

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

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

     

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

230. def templateStat: PartialFunction[Token, Stat]

     

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

     

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

     isPre

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

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

     

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

233. object termInfixContext extends InfixContext

     

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

     

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

     

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

236. def toString(): String

     

     Definition Classes

     AnyRef → Any

237. def token: Token

     

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

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

     

240. def topLevelTmplDef: Member with Stat

     

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

241. def topStat: PartialFunction[Token, Stat]

     

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

     

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

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

     

     TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

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

     

245. def typ(): Type

     

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

246. def typeBounds(): Bounds

     

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

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

     

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

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

     

249. def typeOrInfixType(location: Location): Type

     

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

     

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

252. def typedOpt(): Option[Type]

     

     TypedOpt ::= [`:' Type]

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

     

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

     

255. def unquoteExpr(): Term

     

256. def unquotePattern(): Pat

     

257. def unquoteXmlExpr(): Term

     

258. def unquoteXmlPattern(): Pat

     

259. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

262. def xmlLiteralPattern(): Pat

     

263. def xmlPat(): Xml

     

264. object xmlSeqOK extends SeqContextSensitive

     

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

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

     

266. def xmlTerm(): Xml

     

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