ScalametaParser

Instance Constructors

new ScalametaParser(input: Input)(implicit dialect: Dialect)

Type Members

sealed abstract class InfixContext extends AnyRef
class InvalidModCombination[M1 <: Mod, M2 <: Mod] extends AnyRef
trait MacroQuotedIdent extends AnyRef
trait MacroSplicedIdent extends AnyRef
trait PatternContextSensitive extends AnyRef

Methods which implicitly propagate the context in which they were called: either in a pattern context or not.
Methods which implicitly propagate the context in which they were called: either in a pattern context or not. Formerly, this was threaded through numerous methods as boolean isPattern.
trait SeqContextSensitive extends PatternContextSensitive

Methods which implicitly propagate whether the initial call took place in a context where sequences are allowed.
Methods which implicitly propagate whether the initial call took place in a context where sequences are allowed. Formerly, this was threaded through methods as boolean seqOK.
sealed trait TemplateOwner extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
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
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()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object AutoPos extends Pos with Product with Serializable
object EndPosPreOutdent extends EndPos with Product with Serializable
implicit object InvalidCaseImplicit extends InvalidModCombination[Mod.Case, Implicit]
implicit object InvalidFinalAbstract extends InvalidModCombination[Final, Abstract]
implicit object InvalidFinalSealed extends InvalidModCombination[Final, Sealed]
implicit object InvalidOpenFinal extends InvalidModCombination[Open, Final]
implicit object InvalidOpenSealed extends InvalidModCombination[Open, Sealed]
implicit object InvalidOverrideAbstract extends InvalidModCombination[Override, Abstract]
implicit object InvalidPrivateProtected extends InvalidModCombination[Private, Protected]
implicit object InvalidProtectedPrivate extends InvalidModCombination[Protected, Private]
object MacroQuotedIdent
object MacroSplicedIdent
object OwnedByCaseClass extends TemplateOwner
object OwnedByClass extends TemplateOwner
object OwnedByEnum extends TemplateOwner
object OwnedByObject extends TemplateOwner
object OwnedByTrait extends TemplateOwner
object StartPosPrev extends StartPos with Product with Serializable
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.
def acceptOpt[T <: Token](implicit arg0: TokenInfo[T]): Boolean

If current token is T consume it.
def acceptStatSep(): Unit
def acceptStatSepOpt(): Unit
def accessModifier(): Mod
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()
def annots(skipNewLines: Boolean, allowArgss: Boolean = true): collection.immutable.List[Annot]
def argumentExpr(location: Location): Term
def argumentExprs(location: Location = NoStat): collection.immutable.List[Term]
def argumentExprsOrPrefixExpr(location: Location): collection.immutable.List[Term]
def argumentExprsWithUsing(location: Location = NoStat): (collection.immutable.List[Term], Boolean)
def argumentPattern(): Pat
def argumentPatterns(): collection.immutable.List[Pat]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def atCurPos[T <: Tree](body: ⇒ T): T
def atCurPosNext[T <: Tree](body: ⇒ T): T
def atPos[T <: Tree](pos: Int)(body: ⇒ T): T
def atPos[T <: Tree](start: Int, end: EndPos)(body: T): T

Annotations
@inline()
def atPos[T <: Tree](start: StartPos, end: EndPos)(body: ⇒ T): T
def atPos[T <: Tree](token: Token)(body: ⇒ T): T
def atPosTry[T <: Tree](start: StartPos, end: EndPos)(body: ⇒ Try[T]): Try[T]
def atPosWithBody[T <: Tree](startTokenPos: Int, body: T, endPos: Int): T
def auto: AutoPos.type
def autoEndPos[T <: Tree](start: StartPos)(body: ⇒ T): T

Annotations
@inline()
def autoEndPos[T <: Tree](start: Int)(body: ⇒ T): T

Annotations
@inline()
def autoPos[T <: Tree](body: ⇒ T): T
def autoPosTry[T <: Tree](body: ⇒ Try[T]): Try[T]
def batchSource(statpf: PartialFunction[Token, Stat] = topStat): Source
def block(isBlockOptional: Boolean = false): Term
def blockExpr(isBlockOptional: Boolean = false): Term
def blockStatSeq(): collection.immutable.List[Stat]
def bound[T <: Token](implicit arg0: TokenInfo[T]): Option[Type]
def caseClause(forceSingleExpr: Boolean = false): Case
def caseClauses(): collection.immutable.List[Case]
def caseClausesIfAny(): Option[collection.immutable.List[Case]]
def checkAssoc(op: Term.Name, leftAssoc: Boolean): Unit
def classDef(mods: collection.immutable.List[Mod]): Class
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def commaSeparated[T <: Tree](part: ⇒ T)(implicit arg0: AstInfo[T]): collection.immutable.List[T]

Annotations
@inline()
def condExpr(): Term
def condExprInParens[T <: Token](implicit arg0: TokenInfo[T]): Term
def constrInternal(): (Init, collection.immutable.List[Stat])
def constructorAnnots(): collection.immutable.List[Annot]
def ctorModifiers(): Option[Mod]
def defOrDclOrSecondaryCtor(mods: collection.immutable.List[Mod], enumCaseAllowed: Boolean = false, secondaryConstructorAllowed: Boolean = false): Stat
def derivesClasses(): collection.immutable.List[Type]
final def dropAnyBraces[T](body: ⇒ T): T

Annotations
@inline()
def ellipsis[T <: Tree](rank: Int, astInfo: AstInfo[T], extraSkip: ⇒ Unit = {})(implicit arg0: AstInfo[T]): T
def endMarker(): Stat
def ensureEarlyDef(tree: Stat): Stat
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
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
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
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
def entryPointAmmonite(): MultiSource
def entrypointCase(): Case
def entrypointCtor(): Ctor
def entrypointEnumerator(): Enumerator
def entrypointExpr(): Term
def entrypointImportee(): Importee
def entrypointImporter(): Importer
def entrypointInit(): Init
def entrypointModifier(): Mod
def entrypointPattern(): Pat
def entrypointSelf(): Self
def entrypointSource(): Source
def entrypointStat(): Stat
def entrypointTemplate(): Template
def entrypointTermParam(): Param
def entrypointType(): Type
def entrypointTypeParam(): Param
def enumCaseDef(mods: collection.immutable.List[Mod]): Stat
def enumDef(mods: collection.immutable.List[Mod]): Enum
def enumRepeatedCaseDef(mods: collection.immutable.List[Mod]): RepeatedEnumCase
def enumSingleCaseDef(mods: collection.immutable.List[Mod]): EnumCase
def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[Enumerator]
def enumerators(): collection.immutable.List[Enumerator]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def existentialStats(): collection.immutable.List[Stat]
def exportStmt(): Stat
def expr(location: Location, allowRepeated: Boolean): Term
def expr(): Term
def exprSimpleType(): Type
def exprTypeArgs(): collection.immutable.List[Type]
def extensionGroupDecl(mods: collection.immutable.List[Mod]): ExtensionGroup
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def followedByToken[T <: Token](implicit arg0: TokenInfo[T]): Boolean
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()
def funDefOrDclOrExtensionOrSecondaryCtor(mods: collection.immutable.List[Mod]): Stat
def funDefRest(mods: collection.immutable.List[Mod]): Stat
def generator(eqOK: Boolean, allowNestedIf: Boolean = true): collection.immutable.List[Enumerator]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def guard(): Option[Term]
def hashCode(): Int

Definition Classes
AnyRef → Any
def ifClause(mods: collection.immutable.List[Mod] = Nil): If
def implicitClosure(location: Location): Term.Function
def importStmt(): Import
def importWildcardOrName(): Importee
def importee(): Importee
def importeeRename(from: Name): Importee
def importees(): collection.immutable.List[Importee]
def importer(): Importer
var in: TokenIterator
final def inBraces[T](body: ⇒ T): T

Annotations
@inline()
final def inBracesOr[T](body: ⇒ T, alt: ⇒ T): T

Annotations
@inline()
final def inBracesOrNil[T](body: ⇒ collection.immutable.List[T]): collection.immutable.List[T]

Annotations
@inline()
final def inBrackets[T](body: ⇒ T): T

Annotations
@inline()
final def inParens[T](body: ⇒ T): T

Annotations
@inline()
def inParensOrTupleOrUnitExpr(allowRepeated: Boolean): Term
final def indented[T](body: ⇒ T): T

Annotations
@inline()
def init(): Init
def initInsideAnnotation(allowArgss: Boolean): Init
def initInsideConstructor(): Init
def initInsideTemplate(): Init
def initRest(typeParser: ⇒ Type, allowArgss: Boolean, allowBraces: Boolean): Init
def inlineMatchClause(inlineMods: collection.immutable.List[Mod]): Match

Deals with Scala 3 concept of
Deals with Scala 3 concept of
```
inline x match { ...
```
. Since matches can also be chained in Scala 3 we need to create the Match first and only then add the the inline modifier.
inline x match { ... }}} Scala 3 we need to create the Match first and only then add the the inline modifier.
implicit def intToIndexPos(index: Int): Pos
def interpolate[Ctx <: Tree, Ret <: Tree](arg: () ⇒ Ctx, result: (Term.Name, collection.immutable.List[Lit], collection.immutable.List[Ctx]) ⇒ Ret): Ret
def interpolatePat(): Interpolate
def interpolateTerm(): Interpolate
def isAfterOptNewLine[T](implicit classifier: Classifier[Token, T]): Boolean
def isAmpersand: Boolean
def isBackquoted: Boolean
def isBar: Boolean
def isColonEol(token: Token): Boolean
def isColonWildcardStar: Boolean
def isIdent: Boolean
def isIdentAnd(pred: (String) ⇒ Boolean): Boolean
def isIdentExcept(except: String): Boolean
def isIdentOf(name: String): Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isSpliceFollowedBy(check: ⇒ Boolean): Boolean
def isStar: Boolean
def isStarWildcard(token: Token): Boolean
def isStarWildcard: Boolean
def isUnaryOp: Boolean
def isVarargStarParam(allowRepeated: Boolean): Boolean
def literal(isNegated: Boolean = false): Lit
def localDef(implicitMod: Option[Implicit]): Stat
def localModifiers(): collection.immutable.List[Mod]
def macroQuote(): Term
def macroQuotedIdent(): Term
def macroSplice(): Term
def macroSplicedIdent(): Term
def makeTuple[T <: Tree](body: collection.immutable.List[T], zero: () ⇒ T, tuple: (collection.immutable.List[T]) ⇒ T): T
def makeTupleTerm(body: collection.immutable.List[Term]): Term
def makeTupleType(body: collection.immutable.List[Type]): Type
def matchClause(t: Term): Match
def mixinQualifier(): Name
def modifier(): Mod
def modifiers(isLocal: Boolean = false, isParams: Boolean = false): collection.immutable.List[Mod]
implicit def modsToPos(mods: collection.immutable.List[Mod]): Pos
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newLineOpt(): Unit

Annotations
@inline()
def newLineOptWhenFollowedBy[T](implicit classifier: Classifier[Token, T]): Unit
def newLineOptWhenFollowedBySignificantIndentationAnd(cond: (Token) ⇒ Boolean): Unit
def newLinesOpt(): Unit

Annotations
@inline()
def next(): Unit
def nextOnce(): Unit
def nextThrice(): Unit
def nextTwice(): Unit
object noSeq extends SeqContextSensitive

The implementation for parsing inside of patterns at points where sequences are disallowed.
def nonLocalDefOrDcl(enumCaseAllowed: Boolean = false, secondaryConstructorAllowed: Boolean = false): Stat
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def objectDef(mods: collection.immutable.List[Mod]): Object
def onlyAcceptMod[M <: Mod, T <: Token](mods: collection.immutable.List[Mod], errorMsg: String)(implicit arg0: ClassTag[M], arg1: TokenInfo[T], classifier: Classifier[Mod, M]): Unit
def onlyAllowedMods(mods: collection.immutable.List[Mod], matchers: collection.immutable.List[(Mod) ⇒ Boolean], culprit: String): Unit
def onlyAllowedMods[M1 <: Mod, M2 <: Mod](mods: collection.immutable.List[Mod], culprit: String)(implicit classifier1: Classifier[Mod, M1], classifier2: Classifier[Mod, M2]): Unit
implicit def optionTreeToPos(tree: Option[Tree]): Pos
object outPattern extends PatternContextSensitive

The implementation of the context sensitive methods for parsing outside of patterns.
def packageDef(statpf: PartialFunction[Token, Stat]): Pkg
def packageObjectDef(): Object
def packageOrPackageObjectDef(statpf: PartialFunction[Token, Stat]): Stat
def param(ownerIsCase: Boolean, ownerIsType: Boolean, isImplicit: Boolean, isUsing: Boolean): Param
def paramClauses(ownerIsType: Boolean, ownerIsCase: Boolean = false): collection.immutable.List[collection.immutable.List[Param]]
def paramType(): Type
def parseAmmonite(): MultiSource
def parseCase(): Case
def parseCtor(): Ctor
def parseEnumerator(): Enumerator
def parseImportee(): Importee
def parseImporter(): Importer
def parseInit(): Init
def parseMod(): Mod
def parsePat(): Pat
def parseRule[T <: Tree](rule: ⇒ T): T
def parseRule[T <: Tree](rule: (ScalametaParser.this.type) ⇒ T): T
def parseSelf(): Self
def parseSource(): Source
def parseStat(): Stat
def parseTemplate(): Template
def parseTerm(): Term
def parseTermParam(): Param
def parseType(): Type
def parseTypeParam(): Param
def parseUnquotePat(): Pat
def parseUnquoteTerm(): Term
def patDefOrDcl(mods: collection.immutable.List[Mod]): Stat
implicit object patInfixContext extends InfixContext
def path(thisOK: Boolean = true): Term.Ref
def pattern(): Pat

Default entry points into some pattern contexts.
def patternTyp(): Type
def patternTypeArgs(): collection.immutable.List[Type]
def polyFunction(): PolyFunction
def postfixExpr(allowRepeated: Boolean, location: Location = NoStat): Term
def prefixExpr(allowRepeated: Boolean): Term
def primaryCtor(owner: TemplateOwner): Primary
def qualId(): Term.Ref
def quasiquoteCase(): Case
def quasiquoteCtor(): Ctor
def quasiquoteEnumerator(): Enumerator
def quasiquoteExpr(): Term
def quasiquoteImportee(): Importee
def quasiquoteImporter(): Importer
def quasiquoteInit(): Init
def quasiquoteModifier(): Mod
def quasiquotePattern(): Pat
def quasiquoteSelf(): Self
def quasiquoteSource(): Source
def quasiquoteStat(): Stat
def quasiquoteTemplate(): Template
def quasiquoteTermParam(): Param
def quasiquoteType(): Type
def quasiquoteTypeParam(): Param
def refineStat(): Option[Stat]
def refineStatSeq(): collection.immutable.List[Stat]
def rejectMod[M <: Mod](mods: collection.immutable.List[Mod], errorMsg: String)(implicit classifier: Classifier[Mod, M], tag: ClassTag[M]): Unit
def rejectModCombination[M1 <: Mod, M2 <: Mod](mods: collection.immutable.List[Mod], culpritOpt: Option[String] = None)(implicit invalidMod: InvalidModCombination[M1, M2], classifier1: Classifier[Mod, M1], tag1: ClassTag[M1], classifier2: Classifier[Mod, M2], tag2: ClassTag[M2]): Unit
lazy val reporter: Reporter
def secondaryCtor(mods: collection.immutable.List[Mod]): Secondary
def secondaryCtorRest(mods: collection.immutable.List[Mod], name: Name, paramss: collection.immutable.List[collection.immutable.List[Param]]): Secondary
def selector(t: Term): Select
def selectors(t: Term): Term.Ref
def self(): Self
object seqOK extends SeqContextSensitive

The implementation for parsing inside of patterns at points where sequences are allowed.
def seqPatterns(): collection.immutable.List[Pat]
def simpleExpr(allowRepeated: Boolean): Term
def source(): Source
def stableId(): Term.Ref
def startInfixType(): Type
def startModType(): Type
def stat(body: ⇒ Stat): Stat
def statSeq[T <: Tree](statpf: PartialFunction[Token, T], errorMsg: String = "illegal start of definition")(implicit arg0: AstInfo[T]): collection.immutable.List[T]
def summonClassifierFunc[A, B](implicit v: Classifier[A, B]): (A) ⇒ Boolean
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def syntaxErrorExpected[T <: Token](implicit arg0: TokenInfo[T]): Nothing
def template(afterExtend: Boolean = false, enumCaseAllowed: Boolean, secondaryConstructorAllowed: Boolean): Template
def template(edefs: collection.immutable.List[Stat], parents: collection.immutable.List[Init], enumCaseAllowed: Boolean, secondaryConstructorAllowed: Boolean): Template
def templateBody(enumCaseAllowed: Boolean = false, secondaryConstructorAllowed: Boolean = false): (Self, collection.immutable.List[Stat])
def templateBodyOpt(parenMeansSyntaxError: Boolean, enumCaseAllowed: Boolean = false, secondaryConstructorAllowed: Boolean = false): (Self, collection.immutable.List[Stat])
def templateOpt(owner: TemplateOwner): Template
def templateParents(afterExtend: Boolean = false): collection.immutable.List[Init]
def templateStatSeq(enumCaseAllowed: Boolean = false, secondaryConstructorAllowed: Boolean = false): (Self, collection.immutable.List[Stat])
def templateStats(enumCaseAllowed: Boolean = false, secondaryConstructorAllowed: Boolean = false): collection.immutable.List[Stat]
object termInfixContext extends InfixContext
def termName(advance: Boolean = true): Term.Name
def tmplDef(mods: collection.immutable.List[Mod]): Stat
def toString(): String

Definition Classes
AnyRef → Any
def token: Token
final def tokenSeparated[Sep <: Token, T <: Tree](sepFirst: Boolean, part: ⇒ T)(implicit arg0: TokenInfo[Sep], arg1: AstInfo[T]): collection.immutable.List[T]
implicit def tokenToTokenPos(token: Token): Pos
def topLevelTmplDef: Stat

Hook for IDE, for top-level classes/objects.
def topStat: PartialFunction[Token, Stat]
def tparamModifiers(): Option[Mod]
def traitDef(mods: collection.immutable.List[Mod]): Trait
implicit def treeToTreePos(tree: Tree): Pos
def typ(): Type

These are default entry points into the pattern context sensitive methods: they are all initiated from non-pattern context.
def typeBounds(): Bounds
def typeDefOrDcl(mods: collection.immutable.List[Mod]): Member.Type with Stat
def typeIndentedOpt(): Type
def typeName(advance: Boolean = true): Type.Name
def typeOrInfixType(location: Location): Type
def typeParam(ownerIsType: Boolean, ctxBoundsAllowed: Boolean, allowUnderscore: Boolean = true): Param
def typeParamClauseOpt(ownerIsType: Boolean, ctxBoundsAllowed: Boolean, allowUnderscore: Boolean = true): collection.immutable.List[Param]
def typedOpt(): Option[Type]
def unquote[T <: Tree](implicit arg0: AstInfo[T]): T
def unquote[T <: Tree](advance: Boolean = true)(implicit arg0: AstInfo[T]): T
def unquoteExpr(): Term
def unquotePattern(): Pat
def unquoteXmlExpr(): Term
def unquoteXmlPattern(): Pat
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def xmlLiteralPattern(): Pat
def xmlPat(): Xml
object xmlSeqOK extends SeqContextSensitive

For use from xml pattern, where sequence is allowed and encouraged.
def xmlSeqPatterns(): collection.immutable.List[Pat]
def xmlTerm(): Xml
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

Related Docs: object ScalametaParser | package parsers

class ScalametaParser extends AnyRef

Instance Constructors

new ScalametaParser(input: Input)(implicit dialect: Dialect)

Type Members

sealed abstract class InfixContext extends AnyRef

class InvalidModCombination[M1 <: Mod, M2 <: Mod] extends AnyRef

trait MacroQuotedIdent extends AnyRef

trait MacroSplicedIdent extends AnyRef

trait PatternContextSensitive extends AnyRef

trait SeqContextSensitive extends PatternContextSensitive

sealed trait TemplateOwner extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

object AutoPos extends Pos with Product with Serializable

object EndPosPreOutdent extends EndPos with Product with Serializable

implicit object InvalidCaseImplicit extends InvalidModCombination[Mod.Case, Implicit]

implicit object InvalidFinalAbstract extends InvalidModCombination[Final, Abstract]

implicit object InvalidFinalSealed extends InvalidModCombination[Final, Sealed]

implicit object InvalidOpenFinal extends InvalidModCombination[Open, Final]

implicit object InvalidOpenSealed extends InvalidModCombination[Open, Sealed]

implicit object InvalidOverrideAbstract extends InvalidModCombination[Override, Abstract]

implicit object InvalidPrivateProtected extends InvalidModCombination[Private, Protected]

implicit object InvalidProtectedPrivate extends InvalidModCombination[Protected, Private]

object MacroQuotedIdent

object MacroSplicedIdent

object OwnedByCaseClass extends TemplateOwner

object OwnedByClass extends TemplateOwner

object OwnedByEnum extends TemplateOwner

object OwnedByObject extends TemplateOwner

object OwnedByTrait extends TemplateOwner

object StartPosPrev extends StartPos with Product with Serializable

def accept[T <: Token](implicit arg0: TokenInfo[T]): Unit

def acceptOpt[T <: Token](implicit arg0: TokenInfo[T]): Boolean

def acceptStatSep(): Unit

def acceptStatSepOpt(): Unit

def accessModifier(): Mod

final def ahead[T](body: ⇒ T): T

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

def argumentExpr(location: Location): Term

def argumentExprs(location: Location = NoStat): collection.immutable.List[Term]

def argumentExprsOrPrefixExpr(location: Location): collection.immutable.List[Term]

def argumentExprsWithUsing(location: Location = NoStat): (collection.immutable.List[Term], Boolean)

def argumentPattern(): Pat

def argumentPatterns(): collection.immutable.List[Pat]

final def asInstanceOf[T0]: T0

def atCurPos[T <: Tree](body: ⇒ T): T

def atCurPosNext[T <: Tree](body: ⇒ T): T

def atPos[T <: Tree](pos: Int)(body: ⇒ T): T

def atPos[T <: Tree](start: Int, end: EndPos)(body: T): T

def atPos[T <: Tree](start: StartPos, end: EndPos)(body: ⇒ T): T

def atPos[T <: Tree](token: Token)(body: ⇒ T): T

def atPosTry[T <: Tree](start: StartPos, end: EndPos)(body: ⇒ Try[T]): Try[T]

def atPosWithBody[T <: Tree](startTokenPos: Int, body: T, endPos: Int): T

def auto: AutoPos.type

def autoEndPos[T <: Tree](start: StartPos)(body: ⇒ T): T

def autoEndPos[T <: Tree](start: Int)(body: ⇒ T): T

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

def autoPosTry[T <: Tree](body: ⇒ Try[T]): Try[T]

def batchSource(statpf: PartialFunction[Token, Stat] = topStat): Source

def block(isBlockOptional: Boolean = false): Term

def blockExpr(isBlockOptional: Boolean = false): Term

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

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

def caseClause(forceSingleExpr: Boolean = false): Case

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

def caseClausesIfAny(): Option[collection.immutable.List[Case]]

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

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

def clone(): AnyRef

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

def condExpr(): Term

def condExprInParens[T <: Token](implicit arg0: TokenInfo[T]): Term

def constrInternal(): (Init, collection.immutable.List[Stat])

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