abstract class Parser extends ParserCommon
- Alphabetic
- By Inheritance
- Parser
- ParserCommon
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new Parser()
Type Members
- class ParserTreeBuilder extends TreeBuilder
-
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.
Abstract Value Members
-
abstract
def
deprecationWarning(off: Parsers.Offset, msg: String, since: String): Unit
- Definition Classes
- ParserCommon
-
abstract
val
in: Parsers.Scanner
- Definition Classes
- Parser → ParserCommon
- abstract def incompleteInputError(msg: String): Unit
- abstract def parseStartRule: () ⇒ Global.Tree
- abstract def source: SourceFile
- abstract def syntaxError(offset: Parsers.Offset, msg: String): Unit
- abstract def unit: Global.CompilationUnit
- abstract def warning(offset: Parsers.Offset, msg: String): Unit
- abstract def xmlLiteral(): Global.Tree
- abstract def xmlLiteralPattern(): Global.Tree
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
Test two objects for inequality.
Test two objects for inequality.
- returns
true
if !(this == that), false otherwise.
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
Equivalent to
x.hashCode
except for boxed numeric types andnull
.Equivalent to
x.hashCode
except for boxed numeric types andnull
. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. Fornull
returns a hashcode wherenull.hashCode
throws aNullPointerException
.- returns
a hash value consistent with ==
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (Parser, B)
-
final
def
==(arg0: Any): Boolean
The expression
x == that
is equivalent toif (x eq null) that eq null else x.equals(that)
.The expression
x == that
is equivalent toif (x eq null) that eq null else x.equals(that)
.- returns
true
if the receiver object is equivalent to the argument;false
otherwise.
- Definition Classes
- AnyRef → Any
-
def
accept(token: Parsers.Token): Parsers.Offset
Consume one token of the specified type, or signal an error if it is not there.
Consume one token of the specified type, or signal an error if it is not there.
- Definition Classes
- Parser → ParserCommon
-
def
acceptStatSep(): Unit
semi = nl {nl} | `;` nl = `\n' // where allowed
- def acceptStatSepOpt(): Unit
-
def
accessModifierOpt(): Global.Modifiers
AccessModifier ::= (private | protected) [AccessQualifier]
-
def
accessQualifierOpt(mods: Global.Modifiers): Global.Modifiers
AccessQualifier ::= `[' (Id | this) `]'
- def annotTypeRest(t: Global.Tree): Global.Tree
- def annotationExpr(): Global.Tree
-
def
annotations(skipNewLines: Boolean): List[Global.Tree]
Annotations ::= {`@' SimpleType {ArgumentExprs}} ConsrAnnotations ::= {`@' SimpleType ArgumentExprs}
-
def
argumentExprs(): List[Global.Tree]
ArgumentExprs ::= `(' [Exprs] `)' | [nl] BlockExpr
- def argumentPatterns(): List[Global.Tree]
-
final
def
asInstanceOf[T0]: T0
Cast the receiver object to be of type
T0
.Cast the receiver object to be of type
T0
.Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression
1.asInstanceOf[String]
will throw aClassCastException
at runtime, while the expressionList(1).asInstanceOf[List[String]]
will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.- returns
the receiver object.
- Definition Classes
- Any
- Exceptions thrown
ClassCastException
if the receiver object is not an instance of the erasure of typeT0
.
- val assumedClosingParens: Map[Int, Int]
- def atInPos[T <: Global.Tree](t: T): T
- def atPos[T <: Global.Tree](pos: Global.Position)(t: T): T
- def atPos[T <: Global.Tree](start: Parsers.Offset, point: Parsers.Offset, end: Parsers.Offset)(t: T): T
- def atPos[T <: Global.Tree](start: Parsers.Offset, point: Parsers.Offset)(t: T): T
- def atPos[T <: Global.Tree](offset: Parsers.Offset)(t: T): T
-
def
block(): Global.Tree
Block ::= BlockStatSeq
- Note
Return tree does not carry position.
-
def
blockExpr(): Global.Tree
BlockExpr ::= `{' (CaseClauses | Block) `}'
-
def
blockStatSeq(): List[Global.Tree]
BlockStatSeq ::= { BlockStat semi } [ResultExpr] BlockStat ::= Import | Annotations [implicit] [lazy] Def | Annotations LocalModifiers TmplDef | Expr1 |
- def bound(tok: Parsers.Token): Global.Tree
- def caseBlock(): Global.Tree
- def caseClause(): Global.CaseDef
-
def
caseClauses(): List[Global.CaseDef]
CaseClauses ::= CaseClause {CaseClause} CaseClause ::= case Pattern [Guard] `=>' Block
-
final
def
caseSeparated[T](part: ⇒ T): List[T]
- Annotations
- @inline()
- def checkAssoc(offset: Parsers.Offset, op: Global.Name, leftAssoc: Boolean): Unit
- def checkHeadAssoc(leftAssoc: Boolean): Unit
- def checkNoEscapingPlaceholders[T](op: ⇒ T): T
-
def
checkNotByNameOrVarargs(tpt: Global.Tree): Unit
Check that type parameter is not by name or repeated.
-
def
classDef(start: Parsers.Offset, mods: Global.Modifiers): Global.ClassDef
ClassDef ::= Id [TypeParamClause] {Annotation} [AccessModifier] ClassParamClauses RequiresTypeOpt ClassTemplateOpt TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt
-
def
clone(): AnyRef
Create a copy of the receiver object.
Create a copy of the receiver object.
The default implementation of the
clone
method is platform dependent.- returns
a copy of the receiver object.
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- Note
not specified by SLS as a member of AnyRef
-
final
def
commaSeparated[T](part: ⇒ T): List[T]
- Annotations
- @inline()
-
def
compilationUnit(): Global.PackageDef
CompilationUnit ::= {package QualId semi} TopStatSeq
- def condExpr(): Global.Tree
-
def
constrBlock(vparamss: List[List[Global.ValDef]]): Global.Tree
ConstrBlock ::= `{' SelfInvocation {semi BlockStat} `}'
-
def
constrExpr(vparamss: List[List[Global.ValDef]]): Global.Tree
ConstrExpr ::= SelfInvocation | ConstrBlock
- def constructorAnnotations(): List[Global.Tree]
-
def
convertToParam(tree: Global.Tree): Global.ValDef
Convert tree to formal parameter.
-
def
convertToParams(tree: Global.Tree): List[Global.ValDef]
Convert tree to formal parameter list.
-
def
convertToTypeId(tree: Global.Tree): Global.Tree
Convert (qual)ident to type identifier.
-
def
defOrDcl(pos: Parsers.Offset, mods: Global.Modifiers): List[Global.Tree]
Def ::= val PatDef | var PatDef | def FunDef | type [nl] TypeDef | TmplDef Dcl ::= val PatDcl | var PatDcl | def FunDcl | type [nl] TypeDcl
-
final
def
dropAnyBraces[T](body: ⇒ T): T
- Definition Classes
- ParserCommon
- Annotations
- @inline()
- def ensureEarlyDef(tree: Global.Tree): Global.Tree
- def ensuring(cond: (Parser) ⇒ Boolean, msg: ⇒ Any): Parser
- def ensuring(cond: (Parser) ⇒ Boolean): Parser
- def ensuring(cond: Boolean, msg: ⇒ Any): Parser
- def ensuring(cond: Boolean): Parser
- def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): List[Global.Tree]
-
def
enumerators(): List[Global.Tree]
Enumerators ::= Generator {semi Enumerator} Enumerator ::= Generator | Guard | val Pattern1 `=' Expr
-
final
def
eq(arg0: AnyRef): Boolean
Tests whether the argument (
that
) is a reference to the receiver object (this
).Tests whether the argument (
that
) is a reference to the receiver object (this
).The
eq
method implements an equivalence relation on non-null instances ofAnyRef
, and has three additional properties:- It is consistent: for any non-null instances
x
andy
of typeAnyRef
, multiple invocations ofx.eq(y)
consistently returnstrue
or consistently returnsfalse
. - For any non-null instance
x
of typeAnyRef
,x.eq(null)
andnull.eq(x)
returnsfalse
. null.eq(null)
returnstrue
.
When overriding the
equals
orhashCode
methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2
), they should be equal to each other (o1 == o2
) and they should hash to the same value (o1.hashCode == o2.hashCode
).- returns
true
if the argument is a reference to the receiver object;false
otherwise.
- Definition Classes
- AnyRef
- It is consistent: for any non-null instances
-
def
equals(arg0: Any): Boolean
The equality method for reference types.
- def errorPatternTree: Global.Ident
- def errorTermTree: Global.Literal
- def errorTypeTree: Global.TypeTree
- def expectedMsg(token: Parsers.Token): String
- def expectedMsgTemplate(exp: String, fnd: String): String
- def expr(location: Location): Global.Tree
-
def
expr(): Global.Tree
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} | `:' `_' `*'
- def expr0(location: Location): Global.Tree
- def exprSimpleType(): Global.Tree
- def exprTypeArgs(): List[Global.Tree]
-
def
finalize(): Unit
Called by the garbage collector on the receiver object when there are no more references to the object.
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the
finalize
method is invoked, as well as the interaction betweenfinalize
and non-local returns and exceptions, are all platform dependent.- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- Note
not specified by SLS as a member of AnyRef
- def finishBinaryOp(isExpr: Boolean, opinfo: OpInfo, rhs: Global.Tree): Global.Tree
- def finishPostfixOp(start: Int, base: List[OpInfo], opinfo: OpInfo): Global.Tree
- def formatted(fmtstr: String): String
- implicit def fresh: FreshNameCreator
-
def
funDefOrDcl(start: Int, mods: Global.Modifiers): Global.Tree
FunDef ::= FunSig [`:' Type] `=' [`macro'] Expr | FunSig [nl] `{' Block `}' | `this' ParamClause ParamClauses (`=' ConstrExpr | [nl] ConstrBlock) FunDcl ::= FunSig [`:' Type] FunSig ::= id [FunTypeParamClause] ParamClauses
- def funDefRest(start: Parsers.Offset, nameOffset: Parsers.Offset, mods: Global.Modifiers, name: Global.Name): Global.Tree
-
def
generator(eqOK: Boolean, allowNestedIf: Boolean = true): List[Global.Tree]
Generator ::= Pattern1 (`<-' | `=') Expr [Guard]
-
final
def
getClass(): Class[_]
Returns the runtime class representation of the object.
Returns the runtime class representation of the object.
- returns
a class object corresponding to the runtime type of the receiver.
- Definition Classes
- AnyRef → Any
-
def
guard(): Global.Tree
Guard ::= if PostfixExpr
-
def
hashCode(): Int
The hashCode method for reference types.
- def ident(): Global.Name
-
def
ident(skipIt: Boolean): Global.Name
Assumed (provisionally) to be TermNames.
- def identForType(skipIt: Boolean): Global.TypeName
-
def
identForType(): Global.TypeName
For when it's known already to be a type name.
- def identOrMacro(): Global.Name
-
def
implicitClosure(start: Parsers.Offset, location: Location): Global.Tree
Expr ::= implicit Id => Expr
-
def
importClause(): List[Global.Tree]
Import ::= import ImportExpr {`,' ImportExpr}
-
def
importExpr(): Global.Tree
ImportExpr ::= StableId `.' (Id | `_' | ImportSelectors)
-
def
importSelector(): Global.ImportSelector
ImportSelector ::= Id [`=>' Id | `=>' `_']
-
def
importSelectors(): List[Global.ImportSelector]
ImportSelectors ::= `{' {ImportSelector `,'} (ImportSelector | `_') `}'
-
final
def
inBraces[T](body: ⇒ T): T
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
final
def
inBracesOrError[T](body: ⇒ T, alt: T): T
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
final
def
inBracesOrNil[T](body: ⇒ List[T]): List[T]
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
final
def
inBracesOrUnit[T](body: ⇒ Global.Tree): Global.Tree
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
final
def
inBrackets[T](body: ⇒ T): T
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
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. LPAREN) will be returned instead of the contents of the groupers. However in all cases accept(LPAREN) will be called, so a parse error will still result. If the grouping is optional, in.token should be tested before calling these methods.
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
final
def
inParensOrError[T](body: ⇒ T, alt: T): T
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
final
def
inParensOrNil[T](body: ⇒ List[T]): List[T]
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
final
def
inParensOrUnit[T](body: ⇒ Global.Tree): Global.Tree
- Definition Classes
- ParserCommon
- Annotations
- @inline()
- def isAnnotation: Boolean
- def isCaseDefEnd: Boolean
- def isDclIntro: Boolean
- def isDefIntro: Boolean
- def isExprIntro: Boolean
- def isExprIntroToken(token: Parsers.Token): Boolean
- def isIdent: Boolean
- def isIdentExcept(except: Global.Name): Boolean
- def isIdentOf(name: Global.Name): Boolean
-
final
def
isInstanceOf[T0]: Boolean
Test whether the dynamic type of the receiver object is
T0
.Test whether the dynamic type of the receiver object is
T0
.Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression
1.isInstanceOf[String]
will returnfalse
, while the expressionList(1).isInstanceOf[List[String]]
will returntrue
. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.- returns
true
if the receiver object is an instance of erasure of typeT0
;false
otherwise.
- Definition Classes
- Any
- def isLiteral: Boolean
- def isLiteralToken(token: Parsers.Token): Boolean
- def isLocalModifier: Boolean
- def isMacro: Boolean
- def isModifier: Boolean
- def isNumericLit: Boolean
- def isRawBar: Boolean
- def isRawIdent: Boolean
- def isRawStar: Boolean
- def isSimpleExprIntro: Boolean
- def isSimpleExprIntroToken(token: Parsers.Token): Boolean
- def isStatSep: Boolean
- def isStatSep(token: Parsers.Token): Boolean
- def isStatSeqEnd: Boolean
- def isTemplateIntro: Boolean
- def isTypeIntroToken(token: Parsers.Token): Boolean
- def isTypedParam(t: Global.Tree): Boolean
- def isUnaryOp: Boolean
- def isWildcard(t: Global.Tree): Boolean
-
def
joinComment(trees: ⇒ List[Global.Tree]): List[Global.Tree]
A hook for joining the comment associated with a definition.
A hook for joining the comment associated with a definition. Overridden by scaladoc.
-
def
literal(isNegated: Boolean = false, inPattern: Boolean = false, start: Parsers.Offset = in.offset): Global.Tree
SimpleExpr ::= literal | symbol | null
-
def
localDef(implicitMod: Int): List[Global.Tree]
overridable IDE hook for local definitions of blockStatSeq Here's an idea how to fill in start and end positions.
overridable IDE hook for local definitions of blockStatSeq Here's an idea how to fill in start and end positions. def localDef : List[Tree] = { atEndPos { atStartPos(in.offset) { val annots = annotations(skipNewLines = true) val mods = localModifiers() withAnnotations annots if (!(mods hasFlag ~(Flags.IMPLICIT | Flags.LAZY))) defOrDcl(mods) else List(tmplDef(mods)) } } (in.offset) }
-
def
localModifiers(): Global.Modifiers
LocalModifiers ::= {LocalModifier} LocalModifier ::= abstract | final | sealed | implicit | lazy
-
final
def
lookingAhead[T](body: ⇒ T): T
Scoping operator used to temporarily look into the future.
Scoping operator used to temporarily look into the future. Backs up scanner data before evaluating a block and restores it after.
- Annotations
- @inline()
-
def
makeBinop(isExpr: Boolean, left: Global.Tree, op: Global.TermName, right: Global.Tree, opPos: Global.Position, targs: List[Global.Tree] = Nil): Global.Tree
Create tree representing (unencoded) binary operation expression or pattern.
- def makeEmptyPackage(start: Parsers.Offset, stats: List[Global.Tree]): Global.PackageDef
- def makeFilter(start: Parsers.Offset, tree: Global.Tree): Global.Apply
- def makePackageObject(start: Parsers.Offset, objDef: Global.ModuleDef): Global.PackageDef
-
def
makePackaging(start: Parsers.Offset, pkg: Global.Tree, stats: List[Global.Tree]): Global.PackageDef
Create a tree representing a packaging.
-
final
def
makeParens(body: ⇒ List[Global.Tree]): Global.Parens
Creates an actual Parens node (only used during parsing.)
Creates an actual Parens node (only used during parsing.)
- Definition Classes
- ParserCommon
- Annotations
- @inline()
-
def
makeSafeTupleTerm(elems: List[Global.Tree], offset: Parsers.Offset): Global.Tree
Create a tuple term Tree.
Create a tuple term Tree. If the arity is not supported, a syntax error is emitted.
-
def
makeSafeTupleType(elems: List[Global.Tree], offset: Parsers.Offset): Global.Tree
Create a tuple type Tree.
Create a tuple type Tree. If the arity is not supported, a syntax error is emitted.
-
def
mixinQualifierOpt(): Global.TypeName
MixinQualifier ::= `[' Id `]'
-
def
modifiers(): Global.Modifiers
Modifiers ::= {Modifier} Modifier ::= LocalModifier | AccessModifier | override
-
def
multipleArgumentExprs(): List[List[Global.Tree]]
A succession of argument lists.
-
final
def
ne(arg0: AnyRef): Boolean
Equivalent to
!(this eq that)
.Equivalent to
!(this eq that)
.- returns
true
if the argument is not a reference to the receiver object;false
otherwise.
- Definition Classes
- AnyRef
- def newLineOpt(): Unit
- def newLineOptWhenFollowedBy(token: Parsers.Offset): Unit
- def newLineOptWhenFollowing(p: (Parsers.Token) ⇒ Boolean): Unit
- def newLinesOpt(): Unit
- def nonLocalDefOrDcl: List[Global.Tree]
-
final
def
notify(): Unit
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up a single thread that is waiting on the receiver object's monitor.
- Definition Classes
- AnyRef
- Note
not specified by SLS as a member of AnyRef
-
final
def
notifyAll(): Unit
Wakes up all threads that are waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
- Definition Classes
- AnyRef
- Note
not specified by SLS as a member of AnyRef
- def o2p(offset: Parsers.Offset): Global.Position
-
def
objectDef(start: Parsers.Offset, mods: Global.Modifiers): Global.ModuleDef
ObjectDef ::= Id ClassTemplateOpt
- var opstack: List[OpInfo]
-
def
packageObjectDef(start: Parsers.Offset): Global.PackageDef
Create a tree representing a package object, converting
Create a tree representing a package object, converting
package object foo { ... }
to
package foo { object `package` { ... } }
- def packageOrPackageObject(start: Parsers.Offset): Global.Tree
- def param(owner: Global.Name, implicitmod: Int, caseParam: Boolean): Global.ValDef
-
def
paramClauses(owner: Global.Name, contextBounds: List[Global.Tree], ofCaseClass: Boolean): List[List[Global.ValDef]]
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]
- def paramType(useStartAsPosition: Boolean): Global.Tree
-
def
paramType(): Global.Tree
ParamType ::= Type | `=>' Type | Type `*'
-
def
parse(): Global.Tree
This is the general parse entry point.
- def parseRule[T](rule: (Parser.this.type) ⇒ T): T
-
def
parseStats(): List[Global.Tree]
These are alternative entry points for repl, script runner, toolbox and parsing in macros.
- def parseStatsOrPackages(): List[Global.Tree]
-
def
patDefOrDcl(pos: Int, mods: Global.Modifiers): List[Global.Tree]
PatDef ::= Pattern2 {`,' Pattern2} [`:' Type] `=' Expr ValDcl ::= Id {`,' Id} `:' Type VarDef ::= PatDef | Id {`,' Id} `:' Type `=' `_'
-
def
path(thisOK: Boolean, typeOK: Boolean): Global.Tree
Path ::= StableId | [Ident `.'] this AnnotType ::= Path [`.' type]
-
def
pattern(): Global.Tree
Default entry points into some pattern contexts.
-
def
peekingAhead(tree: ⇒ Global.Tree): Global.Tree
Perform an operation while peeking ahead.
Perform an operation while peeking ahead. Pushback if the operation yields an empty tree or blows to pieces.
- Annotations
- @inline()
-
var
placeholderParams: List[Global.ValDef]
The implicit parameters introduced by
_
in the current expression.The implicit parameters introduced by
_
in the current expression. Parameters appear in reverse order. - def placeholderTypeBoundary(op: ⇒ Global.Tree): Global.Tree
-
var
placeholderTypes: List[Global.TypeDef]
The placeholderTypes introduced by
_
in the current type.The placeholderTypes introduced by
_
in the current type. Parameters appear in reverse order. -
def
postfixExpr(): Global.Tree
PostfixExpr ::= InfixExpr [Id [nl]] InfixExpr ::= PrefixExpr | InfixExpr Id [nl] InfixExpr
-
def
prefixExpr(): Global.Tree
PrefixExpr ::= [`-' | `+' | `~' | `!'] SimpleExpr
-
def
qualId(): Global.Tree
QualId ::= Id {`.' Id}
- def r2p(offset: Parsers.Offset): Global.Position
- def r2p(start: Parsers.Offset, mid: Parsers.Offset): Global.Position
- def r2p(start: Parsers.Offset, mid: Parsers.Offset, end: Parsers.Offset): Global.Position
- def rawIdent(): Global.Name
- def readAnnots(part: ⇒ Global.Tree): List[Global.Tree]
- def reduceExprStack(base: List[OpInfo], top: Global.Tree): Global.Tree
- def reducePatternStack(base: List[OpInfo], top: Global.Tree): Global.Tree
- def reduceStack(isExpr: Boolean, base: List[OpInfo], top: Global.Tree, opPrecedence: Precedence, leftAssoc: Boolean): Global.Tree
- def reduceStack(isExpr: Boolean, base: List[OpInfo], top: Global.Tree): Global.Tree
- def refineStat(): List[Global.Tree]
-
def
refineStatSeq(): List[Global.Tree]
RefineStatSeq ::= RefineStat {semi RefineStat} RefineStat ::= Dcl | type TypeDef |
-
def
refinement(): List[Global.Tree]
Refinement ::= [nl] `{' RefineStat {semi RefineStat} `}'
- def resetPackage(): Unit
-
def
scriptBody(): Global.Tree
This is the parse entry point for code which is not self-contained, e.g.
This is the parse entry point for code which is not self-contained, e.g. a script which is a series of template statements. They will be swaddled in Trees until the AST is equivalent to the one returned by compilationUnit().
- def selector(t: Global.Tree): Global.Tree
- def selectors(t: Global.Tree, typeOK: Boolean, dotOffset: Parsers.Offset): Global.Tree
-
def
selfInvocation(vparamss: List[List[Global.ValDef]]): Global.Tree
SelfInvocation ::= this ArgumentExprs {ArgumentExprs}
- def seqPatterns(): List[Global.Tree]
- def setInPos[T <: Global.Tree](t: T): T
-
def
simpleExpr(): Global.Tree
SimpleExpr ::= new (ClassTemplate | TemplateBody) | BlockExpr | SimpleExpr1 [`_'] SimpleExpr1 ::= literal | xLiteral | Path | `(' [Exprs] `)' | SimpleExpr `.' Id | SimpleExpr TypeArgs | SimpleExpr1 ArgumentExprs
- def simpleExprRest(t: Global.Tree, canApply: Boolean): Global.Tree
-
def
skip(targetToken: Parsers.Token): Unit
- Attributes
- protected
-
def
stableId(): Global.Tree
StableId ::= Id | Path `.' Id | [id `.'] super [`[' id `]']`.' id
- def startAnnotType(): Global.Tree
- def startInfixType(): Global.Tree
- def statSeq(stat: PartialFunction[Parsers.Token, List[Global.Tree]], errorMsg: String = "illegal start of definition"): List[Global.Tree]
- def statement(location: Location): Global.Tree
-
def
stripParens(t: Global.Tree): Global.Tree
Strip the artifitial
Parens
node to create a tuple term Tree. -
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def syntaxError(offset: Parsers.Offset, msg: String, skipIt: Boolean): Unit
- def syntaxError(msg: String, skipIt: Boolean): Unit
- def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean): Unit
- def syntaxErrorOrIncompleteAnd[T](msg: String, skipIt: Boolean)(and: T): T
-
def
template(): (List[Global.Tree], Global.ValDef, List[Global.Tree])
ClassTemplate ::= [EarlyDefs with] ClassParents [TemplateBody] TraitTemplate ::= [EarlyDefs with] TraitParents [TemplateBody] EarlyDefs ::= `{' [EarlyDef {semi EarlyDef}] `}' EarlyDef ::= Annotations Modifiers PatDef
-
def
templateBody(isPre: Boolean): (Global.ValDef, List[Global.Tree])
TemplateBody ::= [nl] `{' TemplateStatSeq `}'
- isPre
specifies whether in early initializer (true) or not (false)
- def templateBodyOpt(parenMeansSyntaxError: Boolean): (Global.ValDef, List[Global.Tree])
-
def
templateOpt(mods: Global.Modifiers, name: Global.Name, constrMods: Global.Modifiers, vparamss: List[List[Global.ValDef]], tstart: Parsers.Offset): Global.Template
ClassTemplateOpt ::= `extends' ClassTemplate | [[`extends'] TemplateBody] TraitTemplateOpt ::= TraitExtends TraitTemplate | [[`extends'] TemplateBody] | `<:' TemplateBody TraitExtends ::= `extends' | `<:'
- def templateOrTopStatSeq(): List[Global.Tree]
-
def
templateParents(): List[Global.Tree]
ClassParents ::= AnnotType {`(' [Exprs] `)'} {with AnnotType} TraitParents ::= AnnotType {with AnnotType}
- def templateStat: PartialFunction[Parsers.Token, List[Global.Tree]]
-
def
templateStatSeq(isPre: Boolean): (Global.ValDef, List[Global.Tree])
TemplateStatSeq ::= [id [`:' Type] `=>'] TemplateStats
- isPre
specifies whether in early initializer (true) or not (false)
-
def
templateStats(): List[Global.Tree]
TemplateStats ::= TemplateStat {semi TemplateStat} TemplateStat ::= Import | Annotations Modifiers Def | Annotations Modifiers Dcl | Expr1 | super ArgumentExprs {ArgumentExprs} |
-
def
tmplDef(pos: Parsers.Offset, mods: Global.Modifiers): Global.Tree
TmplDef ::= [case] class ClassDef | [case] object ObjectDef | [override] trait TraitDef
-
def
toString(): String
Creates a String representation of this object.
Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.
- returns
a String representation of the object.
- Definition Classes
- AnyRef → Any
-
final
def
tokenSeparated[T](separator: Parsers.Token, sepFirst: Boolean, part: ⇒ T): List[T]
,or if sepFirst is true,
part { `sep` part }
,or if sepFirst is true,
{ `sep` part }
. {
sep
part } }}} part {sep
part } }}} -
def
topLevelTmplDef: Global.Tree
Hook for IDE, for top-level classes/objects.
- def topStat: PartialFunction[Parsers.Token, List[Global.Tree]]
-
def
topStatSeq(): List[Global.Tree]
TopStatSeq ::= TopStat {semi TopStat} TopStat ::= Annotations Modifiers TmplDef | Packaging | package object objectDef | Import |
- val treeBuilder: ParserTreeBuilder
-
def
typ(): Global.Tree
These are default entry points into the pattern context sensitive methods: they are all initiated from non-pattern context.
-
def
typeBounds(): Global.TypeBoundsTree
TypeBounds ::= [`>:' Type] [`<:' Type]
-
def
typeDefOrDcl(start: Parsers.Offset, mods: Global.Modifiers): Global.Tree
TypeDef ::= type Id [TypeParamClause] `=' Type | FunSig `=' Expr TypeDcl ::= type Id [TypeParamClause] TypeBounds
- def typeOrInfixType(location: Location): Global.Tree
-
def
typeParamClauseOpt(owner: Global.Name, contextBoundBuf: ListBuffer[Global.Tree]): List[Global.TypeDef]
TypeParamClauseOpt ::= [TypeParamClause] TypeParamClause ::= `[' VariantTypeParam {`,' VariantTypeParam} `]'] VariantTypeParam ::= {Annotation} [`+' | `-'] TypeParam FunTypeParamClauseOpt ::= [FunTypeParamClause] FunTypeParamClause ::= `[' TypeParam {`,' TypeParam} `]'] TypeParam ::= Id TypeParamClauseOpt TypeBounds {<% Type} {":" Type}
-
def
typedOpt(): Global.Tree
TypedOpt ::= [`:' Type]
-
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 warning(msg: String): Unit
- def wildcardOrIdent(): Global.Name
-
def
wildcardType(start: Parsers.Offset): Global.Ident
WildcardType ::= `_' TypeBounds
- def xmlSeqPatterns(): List[Global.Tree]
- def →[B](y: B): (Parser, B)
-
object
InfixMode
extends Enumeration
Modes for infix types.
-
object
noSeq
extends SeqContextSensitive
The implementation for parsing inside of patterns at points where sequences are disallowed.
-
object
outPattern
extends PatternContextSensitive
The implementation of the context sensitive methods for parsing outside of patterns.
-
object
seqOK
extends SeqContextSensitive
The implementation for parsing inside of patterns at points where sequences are allowed.
-
object
xmlSeqOK
extends SeqContextSensitive
For use from xml pattern, where sequence is allowed and encouraged.
Deprecated Value Members
-
def
precedence(operator: Global.Name): Int
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) Use
scala.reflect.internal.Precedence
The Scala compiler API.
The following resources are useful for Scala plugin/compiler development: