[+] final object symbXMLBuilder

[+] val argumentExpr : () => Tree [ T ]

[+] val constrApp : () => Tree

ConstrApp ::= SimpleType {ParArgumentExprs}

[+] private implicit val ctx : Context

[+] val exprInParens : () => Tree

Expr ::= [implicit'] FunParams=>' Expr | Expr1 FunParams ::= Bindings | id | _' ExprInParens ::= PostfixExpr:' Type | Ex... [`implicit'] FunParams `=>' Block | `try' Expr Catches [`finally' Expr] [Expr] [SimpleExpr `.'] id `=' Expr Bindings ::= `(' [Binding {`,' Binding}]

Expr ::= [implicit'] FunParams=>' Expr | Expr1 FunParams ::= Bindings | id | _' ExprInParens ::= PostfixExpr:' Type | Expr BlockResult ::= [implicit'] FunParams=>' Block | Expr1 Expr1 ::= if'(' Expr )' {nl} Expr [[semi] else Expr] |if' Expr then' Expr [[semi] else Expr] |while' (' Expr)' {nl} Expr | while' Exprdo' Expr | do' Expr [semi]while' Expr | try' Expr Catches [finally' Expr] | try' Expr [finally' Expr] | throw' Expr |return' [Expr] | ForExpr | [SimpleExpr .'] id=' Expr | SimpleExpr1 ArgumentExprs =' Expr | PostfixExpr [Ascription] | PostfixExprmatch' {' CaseClauses}' Bindings ::= (' [Binding {,' Binding}] )' Binding ::= (id |_') [:' Type] Ascription ::=:' CompoundType | :' Annotation {Annotation} |:' _'*'

[+] val funArgType : () => Tree

FunArgType ::= Type | `=>' Type

[+] val handleImport : Tree => Tree

[+] val handleSingletonType : Tree => Tree

[+] private val id : Tree => Tree

[+] val importExpr : () => Import

ImportExpr ::= StableId .' (id |_' | ImportSelectors)

[+] val in : Scanner

[+] private var inFunReturnType : Boolean

[+] private var lastStatOffset : Int

The offset of the last time when a statement on a new line was definitely encountered in the current scope or an outer scope.

[+] val namedTypeArg : () => NamedArg

NamedTypeArg ::= id `=' Type

[+] var opStack : List [ OpInfo ]

[+] val openParens : ParensCounters

[+] val pattern : () => Tree

Pattern ::= Pattern1 { `|' Pattern1 }

[+] val pattern2 : () => Tree [ T ]

Pattern2 ::= [varid `@'] InfixPattern

[+] var placeholderParams : List [ ValDef ]

The implicit parameters introduced by _ in the current expression. Parameters appear in reverse order.

[+] val prefixExpr : () => Tree

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

[+] val refinedType : () => Tree

RefinedType ::= WithType {Annotation | [nl] Refinement}

[+] val simplePattern : () => Tree

SimplePattern ::= PatVar | Literal | XmlPattern | (' [Patterns])' | SimplePattern1 [TypeArgs] [ArgumentPatterns] SimplePattern1 ::= Path | {' Block}...

SimplePattern ::= PatVar | Literal | XmlPattern | (' [Patterns])' | SimplePattern1 [TypeArgs] [ArgumentPatterns] SimplePattern1 ::= Path | {' Block}' | SimplePattern1 .' id PatVar ::= id |_'

[+] private val source : SourceFile

[+] lazy val xmlp : MarkupParser

the markup parser

[+] def accept ( token: Int ) : Int

Consume one token of the specified type, or signal an error if it is not there.

[+] def acceptStatSep ( ) : Unit

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

[+] def acceptStatSepUnlessAtEnd ( altEnd: Token ) : Unit

[+] def acceptStatSepUnlessAtEnd$default$1 : Int

[+] def accessQualifierOpt ( mods: Modifiers ) : Modifiers

AccessQualifier ::= "[" (id | this) "]"

[+] def addFlag ( mods: Modifiers , flag: FlagSet ) : Modifiers

[+] def addMod ( mods: Modifiers , mod: Mod ) : Modifiers

Always add the syntactic mod, but check and conditionally add semantic mod.flags

[+] private def addModifier ( mods: Modifiers ) : Modifiers

[+] def adjustStart ( start: Offset ) ( tree: Tree ) : Tree

Adjust start of annotation or constructor to position of preceding @ or new

[+] def annot ( ) : Tree

Annotation ::= `@' SimpleType {ParArgumentExprs}

[+] def annotType ( ) : Tree

AnnotType ::= SimpleType {Annotation}

[+] def annotTypeRest ( t: Tree ) : Tree

[+] def annotations ( skipNewLines: Boolean ) : List [ Tree ]

[+] def annotations$default$1 : Boolean

[+] def annotsAsMods ( skipNewLines: Boolean ) : Modifiers

[+] def annotsAsMods$default$1 : Boolean

[+] def argTypes ( namedOK: Boolean , wildOK: Boolean ) : List [ Tree [ T ] ]

ArgTypes ::= Type {,' Type} | NamedTypeArg {,' NamedTypeArg}

[+] def argumentExprs ( ) : List [ Tree ]

ArgumentExprs ::= ParArgumentExprs | [nl] BlockExpr

[+] def argumentExprss ( fn: Tree ) : Tree

ArgumentExprss ::= {ArgumentExprs}

[+] def argumentPatterns ( ) : List [ Tree ]

ArgumentPatterns ::= (' [Patterns])' | (' [Patterns,'] Pattern2 :'_' `*' ')

[+] def ascription ( t: Tree , location: Value ) : Tree

[+] def binding ( mods: Modifiers ) : Tree

Binding ::= (id | _') [:' Type]

[+] def bindingName ( ) : TermName

[+] def block ( ) : Tree

Block ::= BlockStatSeq

[+] def blockExpr ( ) : Tree

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

[+] def blockStatSeq ( ) : List [ Tree ]

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

[+] private def bound ( tok: Int ) : Tree

[+] def caseClause ( ) : CaseDef

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

[+] def caseClauses ( ) : List [ CaseDef ]

CaseClauses ::= CaseClause {CaseClause}

[+] def checkAssoc ( offset: Int , op: Name , leftAssoc: Boolean ) : Unit

[+] def checkNoEscapingPlaceholders ( op: => T ) : T

[+] def classDef ( start: Offset , mods: Modifiers , docstring: Option [ Comment ] ) : TypeDef

ClassDef ::= id [ClsTypeParamClause] [ConstrMods] ClsParamClauses TemplateOpt

[+] def closureRest ( start: Int , location: Value , params: List [ Tree ] ) : Tree

[+] def commaSeparated ( part: () => T ) : List [ T ]

[+] private def compatible ( flags1: FlagSet , flags2: FlagSet ) : Boolean

[+] def compilationUnit ( ) : Tree

CompilationUnit ::= {package QualId semi} TopStatSeq

[+] def condExpr ( altToken: Token ) : Tree

[+] def constrBlock ( ) : Tree

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

[+] def constrExpr ( ) : Tree

ConstrExpr ::= SelfInvocation | ConstrBlock

[+] def constrModsOpt ( ) : Modifiers

ConstrMods ::= AccessModifier | Annotation {Annotation} (AccessModifier | `this')

[+] def contextBounds ( pname: TypeName ) : List [ Tree ]

[+] def convertToParam ( tree: Tree , mods: Modifiers , expected: String ) : ValDef

Convert tree to formal parameter

[+] def convertToParam$default$2 : R

Convert tree to formal parameter

[+] def convertToParam$default$3 : String

Convert tree to formal parameter

[+] def convertToParams ( tree: Tree ) : List [ ValDef ]

Convert tree to formal parameter list

[+] def convertToTypeId ( tree: Tree ) : Tree

Convert (qual)ident to type identifier

[+] def defAnnotsMods ( allowed: BitSet ) : Modifiers

[+] def defDefOrDcl ( start: Offset , mods: Modifiers , docstring: Option [ Comment ] ) : Tree

DefDef ::= DefSig (:' Type [=' Expr] | "=" Expr) | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id DefTypeParamClaus...

DefDef ::= DefSig (:' Type [=' Expr] | "=" Expr) | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id [DefTypeParamClause] ParamClauses

[+] def defDefOrDcl$default$3 : None$

DefDef ::= DefSig (:' Type [=' Expr] | "=" Expr) | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id DefTypeParamClaus...

DefDef ::= DefSig (:' Type [=' Expr] | "=" Expr) | this ParamClause ParamClauses =' ConstrExpr DefDcl ::= DefSig:' Type DefSig ::= id [DefTypeParamClause] ParamClauses

[+] def defOrDcl ( start: Int , mods: Modifiers ) : Tree

Def ::= val PatDef | var VarDef | def DefDef | type {nl} TypeDcl | TmplDef Dcl ::= val ValDcl | var ValDcl | def DefDcl | type {nl} TypeDcl

[+] def deprecationWarning ( msg: => Message , offset: Int ) : Unit

[+] def deprecationWarning$default$2 : Offset

[+] def dotSelectors ( t: Tree , finish: Tree => Tree ) : Tree

DotSelectors ::= { `.' id }

Accept .' separated identifiers acting as a selectors on given treet`.

DotSelectors ::= { `.' id }

Accept .' separated identifiers acting as a selectors on given treet`.

[+] def dotSelectors$default$2 : Tree => Tree

DotSelectors ::= { `.' id }

Accept .' separated identifiers acting as a selectors on given treet`.

DotSelectors ::= { `.' id }

Accept .' separated identifiers acting as a selectors on given treet`.

[+] def enclosed ( tok: Token , body: => T ) : T

[+] def enumerator ( ) : Tree

Enumerator ::= Generator | Guard | Pattern1 `=' Expr

[+] def enumerators ( ) : List [ Tree ]

Enumerators ::= Generator {semi Enumerator | Guard}

[+] def enumeratorsRest ( ) : List [ Tree ]

[+] def equalsExpr ( ) : Tree

EqualsExpr ::= `=' Expr

[+] def errorTermTree : Literal [ T ]

[+] private def expectedMessage ( what: String ) : String

[+] private def expectedMsg ( token: Int ) : String

[+] def expr ( ) : Tree

[+] def expr ( location: Value ) : Tree

[+] def expr1 ( location: Value ) : Tree

[+] def expr1$default$1 : Value

[+] def expr1Rest ( t: Tree , location: Value ) : Tree

[+] def exprsInParensOpt ( ) : List [ Tree ]

ExprsInParens ::= ExprInParens {`,' ExprInParens}

[+] @tailrec private final def findWildcardType ( t: Tree ) : Option [ Position ]

Checks whether t is a wildcard type. If it is, returns the [[Position]] where the wildcard occurs.

[+] def forExpr ( ) : Tree

ForExpr ::= for' ((' Enumerators )' |{' Enumerators }') {nl} [yield'] Expr | for' Enumerators (do' Expr | `yield' Expr)

[+] private def fromWithinReturnType ( body: => T ) : T

[+] def funParams ( mods: Modifiers , location: Value ) : List [ Tree ]

[+] def generator ( ) : Tree

Generator ::= Pattern `<-' Expr

[+] def generatorRest ( pat: Tree ) : GenFrom

[+] def guard ( ) : Tree

Guard ::= if PostfixExpr

[+] def ident ( ) : TermName

Accept identifier and return its name as a term name.

[+] def implicitClosure ( start: Int , location: Value , implicitMods: Modifiers ) : Tree

Expr ::= implicit id =>' Expr BlockResult ::= implicit id [:' InfixType] `=>' Block // Scala2 only

[+] def implicitMods ( ) : Modifiers

[+] def importClause ( ) : List [ Tree ]

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

[+] def importSelector ( ) : Tree

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

[+] def importSelectors ( ) : List [ Tree ]

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

[+] def inBraces ( body: => T ) : T

[+] def inBrackets ( body: => T ) : T

[+] def inDefScopeBraces ( body: => T ) : T

[+] private def inFunReturnType_= ( x$1: Boolean ) : Unit

[+] def inParens ( body: => T ) : T

[+] def incompleteInputError ( msg: => Message ) : Unit

Issue an error at current offset taht input is incomplete

[+] def infixOps ( first: Tree , canStartOperand: Token => Boolean , operand: () => Tree , isType: Boolean , notAnOperator: Name , maybePostfix: Boolean ) : Tree

operand { infixop operand} [postfixop], respecting rules of associativity and precedence.

[+] def infixOps$default$4 : Boolean

operand { infixop operand} [postfixop], respecting rules of associativity and precedence.

[+] def infixOps$default$5 : N

operand { infixop operand} [postfixop], respecting rules of associativity and precedence.

[+] def infixOps$default$6 : Boolean

operand { infixop operand} [postfixop], respecting rules of associativity and precedence.

[+] def infixPattern ( ) : Tree

InfixPattern ::= SimplePattern {id [nl] SimplePattern}

[+] def infixType ( ) : Tree

InfixType ::= RefinedType {id [nl] refinedType}

[+] def infixTypeRest ( t: Tree ) : Tree

[+] private def interpolatedString ( inPattern: Boolean ) : Tree

[+] def interpolatedString$default$1 : Boolean

[+] def isBindingIntro : Boolean

[+] def isDclIntro : Boolean

[+] def isDefIntro ( allowedMods: BitSet ) : Boolean

[+] def isExprIntro : Boolean

[+] def isIdent : Boolean

[+] def isIdent ( name: Name ) : Boolean

[+] def isLeqIndented ( offset1: Int , offset2: Int ) : Boolean

Is offset1 less or equally indented than offset2? This is the case if the characters between the preceding end-of-line and offset1 are a prefix of the c...

Is offset1 less or equally indented than offset2? This is the case if the characters between the preceding end-of-line and offset1 are a prefix of the characters between the preceding end-of-line and offset2.

[+] def isLiteral : Boolean

[+] def isModifier : Boolean

[+] def isNumericLit : Boolean

[+] def isSimpleLiteral : Boolean

[+] def isStatSep : Boolean

[+] def isStatSeqEnd : Boolean

[+] def isTemplateIntro : Boolean

[+] def isWildcard ( t: Tree ) : Boolean

[+] private def lastStatOffset_= ( x$1: Int ) : Unit

The offset of the last time when a statement on a new line was definitely encountered in the current scope or an outer scope.

[+] def literal ( negOffset: Int , inPattern: Boolean ) : Tree

SimpleExpr ::= literal | symbol | null

[+] def literal$default$1 : Offset

SimpleExpr ::= literal | symbol | null

[+] def literal$default$2 : Boolean

SimpleExpr ::= literal | symbol | null

[+] def localDef ( start: Int , implicitMods: Modifiers ) : Tree

[+] def localDef$default$2 : Modifiers

[+] private def makeIdent ( tok: Token , name: Name ) : Ident

[+] def makePackaging ( start: Int , pkg: Tree , stats: List [ Tree ] ) : PackageDef

Create a tree representing a packaging

[+] def migrationWarningOrError ( msg: String , offset: Int ) : Unit

[+] def migrationWarningOrError$default$2 : Offset

[+] def mixinQualifierOpt ( ) : Ident

MixinQualifier ::= [' id]'

[+] private def modOfToken ( tok: Int ) : Mod

[+] def modifiers ( allowed: BitSet , start: Modifiers ) : Modifiers

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier...

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier ::= LocalModifier | AccessModifier | override LocalModifier ::= abstract | final | sealed | implicit | lazy

[+] def modifiers$default$1 : This

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier...

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier ::= LocalModifier | AccessModifier | override LocalModifier ::= abstract | final | sealed | implicit | lazy

[+] def modifiers$default$2 : R

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier...

{Annotation} {Modifier} Modifiers ::= {Modifier} LocalModifiers ::= {LocalModifier} AccessModifier ::= (private | protected) [AccessQualifier] Modifier ::= LocalModifier | AccessModifier | override LocalModifier ::= abstract | final | sealed | implicit | lazy

[+] def mustStartStat : Boolean

[+] def newLineOpt ( ) : Unit

[+] def newLineOptWhenFollowedBy ( token: Int ) : Unit

[+] def newLineOptWhenFollowing ( p: Int => Boolean ) : Unit

[+] def newLinesOpt ( ) : Unit

[+] private def normalize ( mods: Modifiers ) : Modifiers

Drop private' modifier when followed by a qualifier. Contractabstract' and `override' to ABSOVERRIDE

[+] def objectDef ( start: Offset , mods: Modifiers , docstring: Option [ Comment ] ) : ModuleDef

ObjectDef ::= id TemplateOpt

[+] def objectDef$default$3 : None$

ObjectDef ::= id TemplateOpt

[+] def opStack_= ( x$1: List [ OpInfo ] ) : Unit

[+] def packaging ( start: Int ) : Tree

Packaging ::= package QualId [nl] {' TopStatSeq}'

[+] def parArgumentExprs ( ) : List [ Tree ]

ParArgumentExprs ::= (' [ExprsInParens])' | (' [ExprsInParens,'] PostfixExpr :'_' `*' ')' \

[+] def parArgumentExprss ( fn: Tree ) : Tree

ParArgumentExprss ::= {ParArgumentExprs}

[+] def paramClauses ( owner: Name , ofCaseClass: Boolean ) : List [ List [ ValDef ] ]

ClsParamClauses ::= {ClsParamClause} [[nl] ('implicit' ClsParams )'] ClsParamClause ::= [nl](' [ClsParams] ')' ClsParams ::= ClsParam {'... [nl][DefParams]

ClsParamClauses ::= {ClsParamClause} [[nl] ('implicit' ClsParams )'] ClsParamClause ::= [nl](' [ClsParams] ')' ClsParams ::= ClsParam {' ClsParam} ClsParam ::= {Annotation} [{Modifier} (val' | var') |inline'] Param DefParamClauses ::= {DefParamClause} [[nl] ('implicit' DefParams )'] DefParamClause ::= [nl](' [DefParams] ')' DefParams ::= DefParam {,' DefParam} DefParam ::= {Annotation} [inline'] Param Param ::= id :' ParamType [=' Expr]

[+] def paramClauses$default$2 : Boolean

ClsParamClauses ::= {ClsParamClause} [[nl] ('implicit' ClsParams )'] ClsParamClause ::= [nl](' [ClsParams] ')' ClsParams ::= ClsParam {'... [nl][DefParams]

ClsParamClauses ::= {ClsParamClause} [[nl] ('implicit' ClsParams )'] ClsParamClause ::= [nl](' [ClsParams] ')' ClsParams ::= ClsParam {' ClsParam} ClsParam ::= {Annotation} [{Modifier} (val' | var') |inline'] Param DefParamClauses ::= {DefParamClause} [[nl] ('implicit' DefParams )'] DefParamClause ::= [nl](' [DefParams] ')' DefParams ::= DefParam {,' DefParam} DefParam ::= {Annotation} [inline'] Param Param ::= id :' ParamType [=' Expr]

[+] def paramType ( ) : Tree

ParamType ::= [`=>'] ParamValueType

[+] def paramValueType ( ) : Tree

ParamValueType ::= Type [`*']

[+] def parse ( ) : Tree

This is the general parse entry point. Overridden by ScriptParser

[+] def patDefOrDcl ( start: Offset , mods: Modifiers , docstring: Option [ Comment ] ) : Tree

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

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

[+] def patDefOrDcl$default$3 : None$

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

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

[+] def path ( thisOK: Boolean , finish: Tree => Tree ) : Tree

Path ::= StableId | [id `.'] this

[+] def path$default$2 : Tree => Tree

Path ::= StableId | [id `.'] this

[+] def pattern1 ( ) : Tree

Pattern1 ::= PatVar Ascription | Pattern2

[+] def patternAlts ( ) : List [ Tree ]

[+] def patterns ( ) : List [ Tree [ T ] ]

Patterns ::= Pattern [`,' Pattern]

[+] def patternsOpt ( ) : List [ Tree ]

[+] def placeholderParams_= ( x$1: List [ ValDef ] ) : Unit

The implicit parameters introduced by _ in the current expression. Parameters appear in reverse order.

[+] def posMods ( start: Int , mods: Modifiers ) : Modifiers

[+] def postfixExpr ( ) : Tree

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

[+] def qualId ( ) : Tree

QualId ::= id {`.' id}

[+] def reduceStack ( base: List [ OpInfo ] , top: Tree , prec: Int , leftAssoc: Boolean ) : Tree

[+] def refineStatSeq ( ) : List [ Tree ]

RefineStatSeq ::= RefineStat {semi RefineStat} RefineStat ::= Dcl | (in reality we admit Defs and filter them out afterwards)

[+] def refinedTypeRest ( t: Tree ) : Tree

[+] def refinement ( ) : List [ Tree ]

Refinement ::= {' RefineStatSeq}'

[+] def selector ( t: Tree ) : Tree

Accept identifier acting as a selector on given tree t.

[+] def selectors ( t: Tree , finish: Tree => Tree ) : Tree

Selectors ::= id { `.' id }

Accept .' separated identifiers acting as a selectors on given treet`.

Selectors ::= id { `.' id }

Accept .' separated identifiers acting as a selectors on given treet`.

[+] def selfInvocation ( ) : Tree

SelfInvocation ::= this ArgumentExprs {ArgumentExprs}

[+] def setLastStatOffset ( ) : Unit

[+] def simpleExpr ( ) : Tree

[+] def simpleExprRest ( t: Tree , canApply: Boolean ) : Tree

[+] def simpleExprRest$default$2 : Boolean

[+] def simplePatternRest ( t: Tree ) : Tree

[+] def simpleType ( ) : Tree

[+] private def simpleTypeRest ( t: Tree ) : Tree

[+] protected def skip ( ) : Unit

Skip on error to next safe point. Safe points are: - Closing braces, provided they match an opening brace before the error point. - Closing parens and br...

Skip on error to next safe point. Safe points are: - Closing braces, provided they match an opening brace before the error point. - Closing parens and brackets, provided they match an opening parent or bracket before the error point and there are no intervening other kinds of parens. - Semicolons and newlines, provided there are no intervening braces. - Definite statement starts on new lines, provided they are not more indented than the last known statement start before the error point.

[+] def stableId ( ) : Tree

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

[+] def syntaxErrorOrIncomplete ( msg: => Message ) : Unit

If at end of file, issue an incompleteInputError. Otherwise issue a syntax error and skip to next safe point.

[+] def template ( constr: DefDef ) : ( Template, Boolean )

Template ::= ConstrApps [TemplateBody] | TemplateBody ConstrApps ::= ConstrApp {`with' ConstrApp}

[+] def templateBody ( ) : ( ValDef, List [ Tree ] )

[+] def templateBodyOpt ( constr: DefDef , parents: List [ Tree ] ) : Template

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

[+] def templateOpt ( constr: DefDef ) : Template

TemplateOpt = [`extends' Template | TemplateBody]

[+] def templateStatSeq ( ) : ( ValDef, List [ Tree ] )

TemplateStatSeq ::= [id [:' Type]=>'] TemplateStat {semi TemplateStat} TemplateStat ::= Import | Annotations Modifiers Def | Annotations Modifiers Dc...

TemplateStatSeq ::= [id [:' Type]=>'] TemplateStat {semi TemplateStat} TemplateStat ::= Import | Annotations Modifiers Def | Annotations Modifiers Dcl | Expr1 | super ArgumentExprs {ArgumentExprs} |

[+] def termIdent ( ) : Ident

Accept identifier and return Ident with its name as a term name.

[+] def termIdentOrWildcard ( ) : Ident

[+] def tmplDef ( start: Int , mods: Modifiers ) : Tree

TmplDef ::= ([case']class' | trait') ClassDef | [case'] `object' ObjectDef

[+] def tokenSeparated ( separator: Int , part: () => T ) : List [ T ]

part { separator part }

[+] def topStatSeq ( ) : List [ Tree ]

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

[+] def toplevelTyp ( ) : Tree

Same as [[typ]], but if this results in a wildcard it emits a syntax error and returns a tree for type Any instead.

[+] def typ ( ) : Tree

Type ::= [implicit'] FunArgTypes=>' Type | HkTypeParamClause ->' Type | InfixType FunArgTypes ::= InfixType |(' [ FunArgType {,' FunArgTy...

Type ::= [implicit'] FunArgTypes=>' Type | HkTypeParamClause ->' Type | InfixType FunArgTypes ::= InfixType |(' [ FunArgType {,' FunArgType } ])'

[+] def typeArgs ( namedOK: Boolean , wildOK: Boolean ) : List [ Tree ]

TypeArgs ::= [' Type {,' Type} ]' NamedTypeArgs ::=[' NamedTypeArg {,' NamedTypeArg}]'

[+] def typeBounds ( ) : TypeBoundsTree

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

[+] def typeDefOrDcl ( start: Offset , mods: Modifiers , docstring: Option [ Comment ] ) : Tree

TypeDef ::= type id [TypeParamClause] `=' Type TypeDcl ::= type id [TypeParamClause] TypeBounds

[+] def typeDefOrDcl$default$3 : None$

TypeDef ::= type id [TypeParamClause] `=' Type TypeDcl ::= type id [TypeParamClause] TypeBounds

[+] def typeDependingOn ( location: Value ) : Tree

[+] def typeIdent ( ) : Ident

Accept identifier and return Ident with its name as a type name.

[+] def typeParamBounds ( pname: TypeName ) : Tree

TypeParamBounds ::= TypeBounds {<%' Type} {:' Type}

[+] def typeParamClause ( ownerKind: Value ) : List [ TypeDef ]

ClsTypeParamClause::= [' ClsTypeParam {,' ClsTypeParam} ]' ClsTypeParam ::= {Annotation} [{Modifier} type] [+' | `-'] id [HkTypeParamClause] TypeP...

[HkTypeParamClause]

[HkTypePamClause]

ClsTypeParamClause::= [' ClsTypeParam {,' ClsTypeParam} ]' ClsTypeParam ::= {Annotation} [{Modifier} type] [+' | `-'] id [HkTypeParamClause] TypeParamBounds

DefTypeParamClause::= [' DefTypeParam {,' DefTypeParam} `]' DefTypeParam ::= {Annotation} id [HkTypeParamClause] TypeParamBounds

TypTypeParamCaluse::= [' TypTypeParam {,' TypTypeParam} `]' TypTypeParam ::= {Annotation} id [HkTypePamClause] TypeBounds

HkTypeParamClause ::= [' HkTypeParam {,' HkTypeParam} ]' HkTypeParam ::= {Annotation} ['+' |-'] (id [HkTypePamClause] | _') TypeBounds

[+] def typeParamClauseOpt ( ownerKind: Value ) : List [ TypeDef ]

[+] private def typeProjection ( t: Tree ) : Tree

[+] def typedOpt ( ) : Tree

[+] def warning ( msg: => Message , sourcePos: SourcePosition ) : Unit

[+] def warning ( msg: => Message , offset: Int ) : Unit

[+] def warning$default$2 : Offset

[+] def wildcardIdent ( ) : Ident

[+] def withType ( ) : Tree

WithType ::= AnnotType {`with' AnnotType} (deprecated)

[+] def withTypeRest ( t: Tree ) : Tree

[+] def wrapNew ( tpt: Tree ) : Select

Wrap annotation or constructor in New(...).

[+] def xmlLiteral ( ) : Tree

[+] def xmlLiteralPattern ( ) : Tree

Constructors

Members