scala.tools.nsc.doc.ScaladocSyntaxAnalyzer

ScaladocUnitParser

class ScaladocUnitParser extends UnitParser

Source: ScaladocAnalyzer.scala

Linear Supertypes

ScaladocSyntaxAnalyzer.UnitParser, ScaladocSyntaxAnalyzer.SourceFileParser, ScaladocSyntaxAnalyzer.Parser, ScaladocSyntaxAnalyzer.ParserCommon, AnyRef, Any

Type Hierarchy

Ordering

Alphabetic
By Inheritance

Inherited

ScaladocUnitParser
UnitParser
SourceFileParser
Parser
ParserCommon
AnyRef
Any

Implicitly

by any2stringadd
by StringFormat
by Ensuring
by ArrowAssoc

Hide All
Show All

Visibility

Public
Protected

Instance Constructors

new ScaladocUnitParser(unit: G.CompilationUnit, patches: List[BracePatch])

Type Members

class ParserTreeBuilder extends TreeBuilder
Definition Classes
Parser
sealed 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.
Definition Classes
Parser
final class 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.
Definition Classes
Parser

Value Members

object InfixMode extends Enumeration
Modes for infix types.
Modes for infix types.
Definition Classes
Parser
object symbXMLBuilder extends SymbolicXMLBuilder
Definition Classes
SourceFileParser
final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
def +(other: String): String
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toany2stringadd[ScaladocUnitParser] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (ScaladocUnitParser, B)
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toArrowAssoc[ScaladocUnitParser] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def accept(token: ScaladocSyntaxAnalyzer.Token): ScaladocSyntaxAnalyzer.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
```
Definition Classes
Parser
def acceptStatSepOpt(): Unit
Definition Classes
Parser
def accessModifierOpt(): G.Modifiers
```
AccessModifier ::= (private | protected) [AccessQualifier]
```
Definition Classes
Parser
def accessQualifierOpt(mods: G.Modifiers): G.Modifiers
```
AccessQualifier ::= `[` (Id | this) `]`
```
Definition Classes
Parser
def annotTypeRest(t: G.Tree): G.Tree
Definition Classes
Parser
def annotationExpr(): G.Tree
Definition Classes
Parser

def annotations(skipNewLines: Boolean): List[G.Tree]

Annotations       ::= {`@` SimpleType {ArgumentExprs}}
ConstrAnnotations ::= {`@` SimpleType ArgumentExprs}

Definition Classes: Parser

def argumentExprs(): List[G.Tree]

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

Definition Classes: Parser

def argumentPatterns(): List[G.Tree]
Definition Classes
Parser
final def asInstanceOf[T0]: T0
Definition Classes
Any
val assumedClosingParens: Map[Int, Int]
Definition Classes
Parser
def atInPos[T <: G.Tree](t: T): T
Definition Classes
Parser
def atPos[T <: G.Tree](pos: G.Position)(t: T): T
Definition Classes
Parser
def atPos[T <: G.Tree](start: ScaladocSyntaxAnalyzer.Offset, point: ScaladocSyntaxAnalyzer.Offset, end: ScaladocSyntaxAnalyzer.Offset)(t: T): T
Definition Classes
Parser
def atPos[T <: G.Tree](start: ScaladocSyntaxAnalyzer.Offset, point: ScaladocSyntaxAnalyzer.Offset)(t: T): T
Definition Classes
Parser
def atPos[T <: G.Tree](offset: ScaladocSyntaxAnalyzer.Offset)(t: T): T
Definition Classes
Parser
def block(): G.Tree
```
Block ::= BlockStatSeq
```
Definition Classes
Parser
Note
Return tree does not carry position.
def blockExpr(): G.Tree
```
BlockExpr ::= `{` (CaseClauses | Block) `}`
```
Definition Classes
Parser

def blockStatSeq(): List[G.Tree]

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

Definition Classes: Parser

def bound(tok: ScaladocSyntaxAnalyzer.Token): G.Tree
Definition Classes
Parser
def caseBlock(): G.Tree
Definition Classes
Parser
def caseClause(): G.CaseDef
Definition Classes
Parser

def caseClauses(): List[G.CaseDef]

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

Definition Classes: Parser

final def caseSeparated[T](part: => T): List[T]
Definition Classes
Parser
Annotations
@inline()
def checkAssoc(offset: ScaladocSyntaxAnalyzer.Offset, op: G.Name, leftAssoc: Boolean): Unit
Definition Classes
Parser
def checkHeadAssoc(leftAssoc: Boolean): Unit
Definition Classes
Parser
def checkNoEscapingPlaceholders[T](op: => T): T
Definition Classes
Parser
def checkNotByNameOrVarargs(tpt: G.Tree): Unit
Check that type parameter is not by name or repeated.
Check that type parameter is not by name or repeated.
Definition Classes
Parser
def checkQMarkDefinition(): Unit
Definition Classes
Parser
def checkQMarkUsage(): Unit
Definition Classes
Parser

def classDef(start: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers): G.ClassDef

ClassDef ::= Id [TypeParamClause] ConstrAnnotations
             [AccessModifier] ClassParamClauses RequiresTypeOpt ClassTemplateOpt
TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt

Definition Classes: Parser

def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
final def commaSeparated[T](part: => T): List[T]
, with the separator fixed to commas.
```
tokenSeparated
```
, with the separator fixed to commas. tokenSeparated }}}
Definition Classes
ParserCommon
Annotations
@inline()
def compilationUnit(): G.PackageDef
```
CompilationUnit ::= {package QualId semi} TopStatSeq
```
Definition Classes
Parser
def condExpr(): G.Tree
Definition Classes
Parser
def constrBlock(vparamss: List[List[G.ValDef]]): G.Tree
```
ConstrBlock    ::=  `{` SelfInvocation {semi BlockStat} `}`
```
Definition Classes
Parser
def constrExpr(vparamss: List[List[G.ValDef]]): G.Tree
```
ConstrExpr      ::=  SelfInvocation
                  |  ConstrBlock
```
Definition Classes
Parser
def constructorAnnotations(): List[G.Tree]
Definition Classes
Parser
def convertToParam(tree: G.Tree): G.ValDef
Convert tree to formal parameter.
Convert tree to formal parameter.
Definition Classes
Parser
def convertToParams(tree: G.Tree): List[G.ValDef]
Convert tree to formal parameter list.
Convert tree to formal parameter list.
Definition Classes
Parser
def convertToTypeId(tree: G.Tree): G.Tree
Convert (qual)ident to type identifier.
Convert (qual)ident to type identifier.
Definition Classes
Parser

def defOrDcl(pos: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers): List[G.Tree]

Def    ::= val PatDef
         | var PatDef
         | def FunDef
         | type [nl] TypeDef
         | TmplDef
Dcl    ::= val PatDcl
         | var PatDcl
         | def FunDcl
         | type [nl] TypeDcl

Definition Classes: Parser

def deprecationWarning(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, since: String): Unit
Definition Classes
UnitParser → SourceFileParser → ParserCommon
final def dropAnyBraces[T](body: => T): T
Definition Classes
ParserCommon
Annotations
@inline()
def ensureEarlyDef(tree: G.Tree): G.Tree
Definition Classes
Parser
def ensuring(cond: (ScaladocUnitParser) => Boolean, msg: => Any): ScaladocUnitParser
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toEnsuring[ScaladocUnitParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (ScaladocUnitParser) => Boolean): ScaladocUnitParser
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toEnsuring[ScaladocUnitParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: => Any): ScaladocUnitParser
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toEnsuring[ScaladocUnitParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): ScaladocUnitParser
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toEnsuring[ScaladocUnitParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): List[G.Tree]
Definition Classes
Parser

def enumerators(): List[G.Tree]

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

Definition Classes: Parser

final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def errorPatternTree: G.Ident
Definition Classes
Parser
def errorTermTree: G.Literal
Definition Classes
Parser
def errorTypeTree: G.TypeTree
Definition Classes
Parser
def expectedMsg(token: ScaladocSyntaxAnalyzer.Token): String
Definition Classes
Parser
def expectedMsgTemplate(exp: String, fnd: String): String
Definition Classes
Parser
def expr(location: ScaladocSyntaxAnalyzer.Location): G.Tree
Definition Classes
Parser

def expr(): G.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}
             | `:` `_` `*`

Definition Classes: Parser

def expr0(location: ScaladocSyntaxAnalyzer.Location): G.Tree
Definition Classes
Parser
def exprSimpleType(): G.Tree
Definition Classes
Parser
def exprTypeArgs(): List[G.Tree]
Definition Classes
Parser
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
def finishBinaryOp(isExpr: Boolean, opinfo: ScaladocSyntaxAnalyzer.OpInfo, rhs: G.Tree): G.Tree
Definition Classes
Parser
def finishPostfixOp(start: Int, base: List[ScaladocSyntaxAnalyzer.OpInfo], opinfo: ScaladocSyntaxAnalyzer.OpInfo): G.Tree
Definition Classes
Parser
def followingIsScala3Vararg(): Boolean
Is current ident a *, and is it followed by a ) or , )?
Is current ident a *, and is it followed by a ) or , )?
Definition Classes
Parser
def formatted(fmtstr: String): String
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toStringFormat[ScaladocUnitParser] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
implicit def fresh: FreshNameCreator
Definition Classes
Parser

def funDefOrDcl(start: Int, mods: G.Modifiers): G.Tree

FunDef ::= FunSig [`:` Type] `=` [`macro`] Expr
        |  FunSig [nl] `{` Block `}`
        |  `this` ParamClause ParamClauses
               (`=` ConstrExpr | [nl] ConstrBlock)
FunDcl ::= FunSig [`:` Type]
FunSig ::= id [FunTypeParamClause] ParamClauses

Definition Classes: Parser

def funDefRest(start: ScaladocSyntaxAnalyzer.Offset, nameOffset: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers, name: G.Name): G.Tree
Definition Classes
Parser
def generator(eqOK: Boolean, allowNestedIf: Boolean = true): List[G.Tree]
```
Generator ::= Pattern1 (`<-` | `=`) Expr [Guard]
```
Definition Classes
Parser
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def guard(): G.Tree
```
Guard ::= if PostfixExpr
```
Definition Classes
Parser
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
def ident(): G.Name
Definition Classes
Parser
def ident(skipIt: Boolean): G.Name
Assumed (provisionally) to be TermNames.
Assumed (provisionally) to be TermNames.
Definition Classes
Parser
def identForType(skipIt: Boolean): G.TypeName
Definition Classes
Parser
def identForType(): G.TypeName
For when it's known already to be a type name.
For when it's known already to be a type name.
Definition Classes
Parser
def identOrMacro(): G.Name
Definition Classes
Parser
def implicitClosure(start: ScaladocSyntaxAnalyzer.Offset, location: ScaladocSyntaxAnalyzer.Location): G.Tree
```
Expr ::= implicit Id `=>` Expr
```
Definition Classes
Parser
def importClause(): List[G.Tree]
```
Import  ::= import ImportExpr {`,` ImportExpr}
```
Definition Classes
Parser

def importExpr(): G.Tree

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

Definition Classes: Parser

def importSelector(): G.ImportSelector
```
ImportSelector ::= Id [`=>` Id | `=>` `_`]
```
Definition Classes
Parser

def importSelectors(): List[G.ImportSelector]

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

Definition Classes: Parser

val in: ScaladocSyntaxAnalyzer.Scanner
Definition Classes
SourceFileParser → Parser → ParserCommon
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: => G.Tree): G.Tree
Definition Classes
ParserCommon
Annotations
@inline()
final def inBrackets[T](body: => T): T
Definition Classes
ParserCommon
Annotations
@inline()
final def inGroupers[T](left: ScaladocSyntaxAnalyzer.Token)(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.
Skip trailing comma is pushed down to scanner because this abstract parser doesn't have token info.
Definition Classes
ParserCommon
Annotations
@inline()
final def inParens[T](body: => T): T
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: => G.Tree): G.Tree
Definition Classes
ParserCommon
Annotations
@inline()
def incompleteInputError(msg: String): Unit
Definition Classes
UnitParser → SourceFileParser → Parser
def isAnnotation: Boolean
Definition Classes
Parser
def isCaseDefEnd: Boolean
Definition Classes
Parser
def isDclIntro: Boolean
Definition Classes
Parser
def isDefIntro: Boolean
Definition Classes
Parser
def isExprIntro: Boolean
Definition Classes
Parser
def isExprIntroToken(token: ScaladocSyntaxAnalyzer.Token): Boolean
Definition Classes
Parser
def isIdent: Boolean
Definition Classes
Parser
def isIdentExcept(except: G.Name): Boolean
Definition Classes
Parser
def isIdentOf(name: G.Name): Boolean
Definition Classes
Parser
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
def isLiteral: Boolean
Definition Classes
Parser
def isLiteralToken(token: ScaladocSyntaxAnalyzer.Token): Boolean
Definition Classes
Parser
def isLocalModifier: Boolean
Definition Classes
Parser
def isMacro: Boolean
Definition Classes
Parser
def isModifier: Boolean
Definition Classes
Parser
def isNumericLit: Boolean
Definition Classes
Parser
def isRawBar: Boolean
Definition Classes
Parser
def isRawIdent: Boolean
Definition Classes
Parser
def isRawStar: Boolean
Definition Classes
Parser
def isScala3WildcardType: Boolean
Definition Classes
Parser
def isSoftModifier: Boolean
Definition Classes
Parser
def isStatSep: Boolean
Definition Classes
Parser
def isStatSep(token: ScaladocSyntaxAnalyzer.Token): Boolean
Definition Classes
Parser
def isStatSeqEnd: Boolean
Definition Classes
Parser
def isTemplateIntro: Boolean
Definition Classes
Parser
def isTypeIntroToken(token: ScaladocSyntaxAnalyzer.Token): Boolean
Definition Classes
Parser
def isTypedParam(t: G.Tree): Boolean
Definition Classes
Parser
def isUnaryOp: Boolean
Definition Classes
Parser
def isValidSoftModifier: Boolean
Is the current token a soft modifier in a position where such a modifier is allowed?
Is the current token a soft modifier in a position where such a modifier is allowed?
Definition Classes
Parser
final def isWildcard(t: G.Tree): Boolean
Definition Classes
Parser
Annotations
@tailrec()
def isWildcardType: Boolean
Definition Classes
Parser
def joinComment(trees: => List[G.Tree]): List[G.Tree]
A hook for joining the comment associated with a definition.
A hook for joining the comment associated with a definition. Overridden by scaladoc.
Definition Classes
ScaladocUnitParser → Parser
def literal(isNegated: Boolean = false, inPattern: Boolean = false, start: ScaladocSyntaxAnalyzer.Offset = in.offset): G.Tree
```
SimpleExpr    ::= literal
                | symbol
                | null
```
Definition Classes
Parser
def localDef(implicitMod: Long): List[G.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) }
Definition Classes
Parser

def localModifiers(): G.Modifiers

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

Definition Classes: Parser

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.
Definition Classes
Parser
Annotations
@inline()
def makeBinop(isExpr: Boolean, left: G.Tree, op: G.TermName, right: G.Tree, opPos: G.Position, targs: List[G.Tree] = Nil): G.Tree
Create tree representing (unencoded) binary operation expression or pattern.
Create tree representing (unencoded) binary operation expression or pattern.
Definition Classes
Parser
def makeEmptyPackage(start: ScaladocSyntaxAnalyzer.Offset, stats: List[G.Tree]): G.PackageDef
Definition Classes
Parser
def makeFilter(start: ScaladocSyntaxAnalyzer.Offset, tree: G.Tree): G.Apply
Definition Classes
Parser
def makePackaging(start: ScaladocSyntaxAnalyzer.Offset, pkg: G.Tree, stats: List[G.Tree]): G.PackageDef
Create a tree representing a packaging.
Create a tree representing a packaging.
Definition Classes
Parser
final def makeParens(body: => List[G.Tree]): G.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 makeSafeFunctionType(argtpes: List[G.Tree], restpe: G.Tree): G.Tree
Create a function Tree.
Create a function Tree. If the arity is not supported, a syntax error is emitted.
Definition Classes
Parser
def makeSafeTupleTerm(elems: List[G.Tree]): G.Tree
Create a tuple term Tree.
Create a tuple term Tree. If the arity is not supported, a syntax error is emitted.
Definition Classes
Parser
def makeSafeTupleType(elems: List[G.Tree]): G.Tree
Create a tuple type Tree.
Create a tuple type Tree. If the arity is not supported, a syntax error is emitted.
Definition Classes
Parser
def mixinQualifierOpt(): G.TypeName
```
MixinQualifier ::= `[` Id `]`
```
Definition Classes
Parser

def modifiers(): G.Modifiers

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

Definition Classes: Parser

def multipleArgumentExprs(): List[List[G.Tree]]
A succession of argument lists.
A succession of argument lists.
Definition Classes
Parser
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def newLineOpt(): Unit
Definition Classes
Parser
def newLineOptWhenFollowedBy(token: ScaladocSyntaxAnalyzer.Offset): Unit
Definition Classes
Parser
def newLineOptWhenFollowing(p: (ScaladocSyntaxAnalyzer.Token) => Boolean): Unit
Definition Classes
Parser
def newLinesOpt(): Unit
Definition Classes
Parser
def newScanner(): ScaladocUnitScanner
Definition Classes
ScaladocUnitParser → UnitParser → SourceFileParser
final val noSeq: SeqContextSensitive
The implementation for parsing inside of patterns at points where sequences are disallowed.
The implementation for parsing inside of patterns at points where sequences are disallowed.
Definition Classes
Parser
def nonLocalDefOrDcl: List[G.Tree]
Definition Classes
Parser
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
def o2p(offset: ScaladocSyntaxAnalyzer.Offset): G.Position
Definition Classes
Parser
def objectDef(start: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers, isPackageObject: Boolean = false): G.ModuleDef
```
ObjectDef       ::= Id ClassTemplateOpt
```
Definition Classes
Parser
var opstack: List[ScaladocSyntaxAnalyzer.OpInfo]
Definition Classes
Parser
final val outPattern: PatternContextSensitive
The implementation of the context sensitive methods for parsing outside of patterns.
The implementation of the context sensitive methods for parsing outside of patterns.
Definition Classes
Parser
def packageObjectDef(start: ScaladocSyntaxAnalyzer.Offset): G.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` { ... }
}
```
Definition Classes
Parser
def packageOrPackageObject(start: ScaladocSyntaxAnalyzer.Offset): G.Tree
Definition Classes
Parser
def param(owner: G.Name, implicitmod: Long, caseParam: Boolean): G.ValDef
Definition Classes
Parser

def paramClauses(owner: G.Name, contextBounds: List[G.Tree], ofCaseClass: Boolean): List[List[G.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]

Definition Classes: Parser

def paramType(repeatedParameterOK: Boolean, useStartAsPosition: Boolean): G.Tree
Definition Classes
Parser
def paramType(): G.Tree
```
ParamType ::= Type | `=>` Type | Type `*`
```
Definition Classes
Parser
def parse(): G.Tree
This is the general parse entry point.
This is the general parse entry point.
Definition Classes
Parser
def parseRule[T](rule: (ScaladocUnitParser.this.type) => T): T
Definition Classes
Parser
def parseStartRule: () => G.Tree
The parse starting point depends on whether the source file is self-contained: if not, the AST will be supplemented.
The parse starting point depends on whether the source file is self-contained: if not, the AST will be supplemented.
Definition Classes
SourceFileParser → Parser
def parseStats(): List[G.Tree]
These are alternative entry points for repl, script runner, toolbox and parsing in macros.
These are alternative entry points for repl, script runner, toolbox and parsing in macros.
Definition Classes
Parser
def parseStatsOrPackages(): List[G.Tree]
Definition Classes
Parser

def patDefOrDcl(pos: Int, mods: G.Modifiers): List[G.Tree]

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

Definition Classes: Parser

def path(thisOK: Boolean, typeOK: Boolean): G.Tree

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

Definition Classes: Parser

def pattern(): G.Tree
Default entry points into some pattern contexts.
Default entry points into some pattern contexts.
Definition Classes
Parser
def peekingAhead(tree: => G.Tree): G.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.
Definition Classes
Parser
Annotations
@inline()
var placeholderParams: List[G.ValDef]
The implicit parameters introduced by _ in the current expression.
The implicit parameters introduced by _ in the current expression. Parameters appear in reverse order.
Definition Classes
Parser
def placeholderTypeBoundary(op: => G.Tree): G.Tree
Definition Classes
Parser
var placeholderTypes: List[G.TypeDef]
The placeholderTypes introduced by _ in the current type.
The placeholderTypes introduced by _ in the current type. Parameters appear in reverse order.
Definition Classes
Parser

def postfixExpr(): G.Tree

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

Definition Classes: Parser

def prefixExpr(): G.Tree

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

Definition Classes: Parser

def qualId(): G.Tree
```
QualId ::= Id {`.` Id}
```
Definition Classes
Parser
def r2p(offset: ScaladocSyntaxAnalyzer.Offset): G.Position
Definition Classes
Parser
def r2p(start: ScaladocSyntaxAnalyzer.Offset, mid: ScaladocSyntaxAnalyzer.Offset): G.Position
Definition Classes
Parser
def r2p(start: ScaladocSyntaxAnalyzer.Offset, mid: ScaladocSyntaxAnalyzer.Offset, end: ScaladocSyntaxAnalyzer.Offset): G.Position
Definition Classes
Parser
def rawIdent(): G.Name
Definition Classes
Parser
def readAnnots(part: => G.Tree): List[G.Tree]
Definition Classes
Parser
def reduceExprStack(base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree): G.Tree
Definition Classes
Parser
def reducePatternStack(base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree): G.Tree
Definition Classes
Parser
def reduceStack(isExpr: Boolean, base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree, opPrecedence: Precedence, leftAssoc: Boolean): G.Tree
Definition Classes
Parser
def reduceStack(isExpr: Boolean, base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree): G.Tree
Definition Classes
Parser
def refineStat(): List[G.Tree]
Definition Classes
Parser

def refineStatSeq(): List[G.Tree]

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

Definition Classes: Parser

def refinement(): List[G.Tree]

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

Definition Classes: Parser

def resetPackage(): Unit
Definition Classes
Parser
def scriptBody(): G.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().
Definition Classes
Parser
def selector(t: G.Tree): G.Tree
Definition Classes
Parser
final def selectors(t: G.Tree, typeOK: Boolean, dotOffset: ScaladocSyntaxAnalyzer.Offset): G.Tree
Definition Classes
Parser
Annotations
@tailrec()
def selfInvocation(vparamss: List[List[G.ValDef]]): G.Tree
```
SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}
```
Definition Classes
Parser
final def separatedToken[T](separator: ScaladocSyntaxAnalyzer.Token, part: => T): List[T]
.
```
{ `sep` part }
```
. { sep part } }}}
Definition Classes
Parser → ParserCommon
final val seqOK: SeqContextSensitive
The implementation for parsing inside of patterns at points where sequences are allowed.
The implementation for parsing inside of patterns at points where sequences are allowed.
Definition Classes
Parser
def seqPatterns(): List[G.Tree]
Definition Classes
Parser
def setInPos[T <: G.Tree](t: T): T
Definition Classes
Parser
def showSyntaxErrors(): Unit
Definition Classes
UnitParser

def simpleExpr(): G.Tree

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

Definition Classes: Parser

final def simpleExprRest(t: G.Tree, canApply: Boolean): G.Tree
Definition Classes
Parser
Annotations
@tailrec()
def skip(targetToken: ScaladocSyntaxAnalyzer.Token): Unit
Attributes
protected
Definition Classes
Parser
def smartParse(): G.Tree
parse unit.
parse unit. If there are unbalanced braces, try to correct them and reparse.
Definition Classes
UnitParser
val source: SourceFile
Definition Classes
SourceFileParser → Parser

def stableId(): G.Tree

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

Definition Classes: Parser

def startAnnotType(): G.Tree
Definition Classes
Parser
def startInfixType(): G.Tree
Definition Classes
Parser
def statSeq(stat: PartialFunction[ScaladocSyntaxAnalyzer.Token, List[G.Tree]], errorMsg: String = "illegal start of definition"): List[G.Tree]
Definition Classes
Parser
def statement(location: ScaladocSyntaxAnalyzer.Location): G.Tree
Definition Classes
Parser
def stripParens(t: G.Tree): G.Tree
Strip the artificial Parens node to create a tuple term Tree.
Strip the artificial Parens node to create a tuple term Tree.
Definition Classes
Parser
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def syntaxError(offset: ScaladocSyntaxAnalyzer.Offset, msg: String): Unit
Definition Classes
UnitParser → SourceFileParser → Parser
def syntaxError(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, skipIt: Boolean): Unit
Definition Classes
Parser
def syntaxError(msg: String, skipIt: Boolean): Unit
Definition Classes
Parser
def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean): Unit
Definition Classes
Parser
def syntaxErrorOrIncompleteAnd[T](msg: String, skipIt: Boolean)(and: T): T
Definition Classes
Parser
val syntaxErrors: ListBuffer[(Int, String)]
Definition Classes
UnitParser

def template(): (List[G.Tree], G.ValDef, List[G.Tree])

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

Definition Classes: Parser

def templateBody(isPre: Boolean): (G.ValDef, List[G.Tree])
```
TemplateBody ::= [nl] `{` TemplateStatSeq `}`
```
isPre
specifies whether in early initializer (true) or not (false)
Definition Classes
Parser
def templateBodyOpt(parenMeansSyntaxError: Boolean): (G.ValDef, List[G.Tree])
Definition Classes
Parser

def templateOpt(mods: G.Modifiers, name: G.Name, constrMods: G.Modifiers, vparamss: List[List[G.ValDef]], tstart: ScaladocSyntaxAnalyzer.Offset): G.Template

ClassTemplateOpt ::= `extends` ClassTemplate | [[`extends`] TemplateBody]
TraitTemplateOpt ::= TraitExtends TraitTemplate | [[TraitExtends] TemplateBody]
TraitExtends     ::= `extends` | `<:` (deprecated)

Definition Classes: Parser

def templateOrTopStatSeq(): List[G.Tree]
Definition Classes
Parser

def templateParents(): List[G.Tree]

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

Definition Classes: Parser

def templateStat: PartialFunction[ScaladocSyntaxAnalyzer.Token, List[G.Tree]]
Definition Classes
Parser
def templateStatSeq(isPre: Boolean): (G.ValDef, List[G.Tree])
```
TemplateStatSeq  ::= [id [`:` Type] `=>`] TemplateStats
```
isPre
specifies whether in early initializer (true) or not (false)
Definition Classes
Parser

def templateStats(): List[G.Tree]

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

Definition Classes: Parser

def tmplDef(pos: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers): G.Tree

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

Definition Classes: Parser

def toString(): String
Definition Classes
AnyRef → Any
final def tokenSeparated[T](separator: ScaladocSyntaxAnalyzer.Token, part: => T): List[T]
.
```
part { `sep` part }
```
. part { sep part } }}}
Definition Classes
Parser → ParserCommon
def topLevelTmplDef: G.Tree
Hook for IDE, for top-level classes/objects.
Hook for IDE, for top-level classes/objects.
Definition Classes
Parser
def topStat: PartialFunction[ScaladocSyntaxAnalyzer.Token, List[G.Tree]]
Definition Classes
Parser

def topStatSeq(): List[G.Tree]

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

Definition Classes: Parser

val treeBuilder: ParserTreeBuilder
Definition Classes
Parser
def typ(): G.Tree
These are default entry points into the pattern context sensitive methods: they are all initiated from non-pattern context.
These are default entry points into the pattern context sensitive methods: they are all initiated from non-pattern context.
Definition Classes
Parser
def typeBounds(): G.TypeBoundsTree
```
TypeBounds ::= [`>:` Type] [`<:` Type]
```
Definition Classes
Parser

def typeDefOrDcl(start: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers): G.Tree

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

Definition Classes: Parser

def typeOrInfixType(location: ScaladocSyntaxAnalyzer.Location): G.Tree
Definition Classes
Parser

def typeParamClauseOpt(owner: G.Name, contextBoundBuf: ListBuffer[G.Tree]): List[G.TypeDef]

TypeParamClauseOpt    ::= [TypeParamClause]
TypeParamClause       ::= `[` VariantTypeParam {`,` VariantTypeParam} `]`]
VariantTypeParam      ::= {Annotation} [`+` | `-`] TypeParam
FunTypeParamClauseOpt ::= [FunTypeParamClause]
FunTypeParamClause    ::= `[` TypeParam {`,` TypeParam} `]`]
TypeParam             ::= Id TypeParamClauseOpt TypeBounds {`<%` Type} {`:` Type}

Definition Classes: Parser

def typedOpt(): G.Tree
```
TypedOpt ::= [`:` Type]
```
Definition Classes
Parser
val unit: G.CompilationUnit
Definition Classes
UnitParser → SourceFileParser → Parser
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
def warning(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, category: WarningCategory): Unit
Definition Classes
UnitParser → SourceFileParser → Parser
def warning(msg: String, category: WarningCategory): Unit
Definition Classes
Parser
def wildImportSelector(): G.ImportSelector
Definition Classes
Parser
def wildcardOrIdent(): G.Name
Definition Classes
Parser
def wildcardType(start: ScaladocSyntaxAnalyzer.Offset, qmark: Boolean): G.Ident
```
WildcardType ::= `_` TypeBounds
```
Definition Classes
Parser
def withPatches(patches: List[BracePatch]): ScaladocUnitParser
Definition Classes
ScaladocUnitParser → UnitParser
def xmlLiteral(): G.Tree
Definition Classes
SourceFileParser → Parser
def xmlLiteralPattern(): G.Tree
Definition Classes
SourceFileParser → Parser
final val xmlSeqOK: SeqContextSensitive
For use from xml pattern, where sequence is allowed and encouraged.
For use from xml pattern, where sequence is allowed and encouraged.
Definition Classes
Parser
def xmlSeqPatterns(): List[G.Tree]
Definition Classes
Parser

Deprecated Value Members

def precedence(operator: G.Name): Int
Definition Classes
Parser
Annotations
@deprecated
Deprecated
(Since version 2.11.0) Use scala.reflect.internal.Precedence
def →[B](y: B): (ScaladocUnitParser, B)
Implicit
This member is added by an implicit conversion from ScaladocUnitParser toArrowAssoc[ScaladocUnitParser] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@deprecated
Deprecated
(Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

Packages

ScaladocUnitParser

class ScaladocUnitParser extends UnitParser

Instance Constructors

Type Members

Value Members

Deprecated Value Members

Inherited from ScaladocSyntaxAnalyzer.UnitParser

Inherited from ScaladocSyntaxAnalyzer.SourceFileParser

Inherited from ScaladocSyntaxAnalyzer.Parser

Inherited from ScaladocSyntaxAnalyzer.ParserCommon

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromScaladocUnitParser to any2stringadd[ScaladocUnitParser]

Inherited by implicit conversion StringFormat fromScaladocUnitParser to StringFormat[ScaladocUnitParser]

Inherited by implicit conversion Ensuring fromScaladocUnitParser to Ensuring[ScaladocUnitParser]

Inherited by implicit conversion ArrowAssoc fromScaladocUnitParser to ArrowAssoc[ScaladocUnitParser]

Ungrouped

Packages

ScaladocUnitParser

class ScaladocUnitParser extends UnitParser

Instance Constructors

Type Members

Value Members

Deprecated Value Members

Inherited from ScaladocSyntaxAnalyzer.UnitParser

Inherited from ScaladocSyntaxAnalyzer.SourceFileParser

Inherited from ScaladocSyntaxAnalyzer.Parser

Inherited from ScaladocSyntaxAnalyzer.ParserCommon

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromScaladocUnitParser to any2stringadd[ScaladocUnitParser]

Inherited by implicit conversion StringFormat fromScaladocUnitParser to StringFormat[ScaladocUnitParser]

Inherited by implicit conversion Ensuring fromScaladocUnitParser to Ensuring[ScaladocUnitParser]

Inherited by implicit conversion ArrowAssoc fromScaladocUnitParser to ArrowAssoc[ScaladocUnitParser]

Ungrouped

ScaladocUnitParser