Scala Compiler 2.13.16 - scala.tools.nsc.doc.ScaladocSyntaxAnalyzer.ScaladocUnitParser
Keywords: Scala Compiler 2.13.16 scala.tools.nsc.doc.ScaladocSyntaxAnalyzer.ScaladocUnitParser

Scala Compiler2.13.16 < Back


# Packages

-  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package tools
  Definition Classes
    scala
-  package nsc
  Definition Classes
    tools
-  package doc
  Definition Classes
    nsc
-  abstract class ScaladocSyntaxAnalyzer[G <: Global] extends SyntaxAnalyzer
  Definition Classes
    doc
- AbstractJavaScanner
- AbstractJavaTokenData
- CommonTokenData
- ConfusedAboutBracesControl
- DocScanner
- JavaOpInfo
- JavaParser
- JavaScanner
- JavaScannerConfiguration
- JavaTokenData
- JavaUnitParser
- JavaUnitScanner
- MalformedInput
- MarkupParser
- MemberDefTraverser
- MemberPosReporter
- MissingEndTagControl
- OpInfo
- OutlineParser
- ParamOwner
- ParensAnalyzer
- Parser
- ParserCommon
- ParserPhase
- ScaladocJavaUnitParser
- ScaladocJavaUnitScanner
- ScaladocScanner
- ScaladocUnitParser
- ScaladocUnitScanner
- Scanner
- ScannerCommon
- ScannerData
- SourceFileParser
- SourceFileScanner
- StdPhase
- TokenData
- TruncatedXMLControl
- UnitParser
- UnitScanner

c

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

1. Alphabetic
2. By Inheritance

Inherited

1. ScaladocUnitParser
2. UnitParser
3. SourceFileParser
4. Parser
5. ParserCommon
6. AnyRef
7. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. Protected

### Instance Constructors

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

### Type Members

1.  class ParserTreeBuilder extends TreeBuilder
   Definition Classes
     Parser
2.  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
3.  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

1.  object InfixMode extends Enumeration

   Modes for infix types.

   Modes for infix types.

   Definition Classes
     Parser
2.  object symbXMLBuilder extends SymbolicXMLBuilder
   Definition Classes
     SourceFileParser
3.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
4.  final def ##: Int
   Definition Classes
     AnyRef → Any
5.  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
6.  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()
7.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
8.  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
9.  def acceptStatSep(): Unit

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

   Definition Classes
     Parser
10.  def acceptStatSepOpt(): Unit
    Definition Classes
      Parser
11.  def accessModifierOpt(): G.Modifiers

        AccessModifier ::= (private | protected) [AccessQualifier]

    Definition Classes
      Parser
12.  def accessQualifierOpt(mods: G.Modifiers): G.Modifiers

        AccessQualifier ::= `[` (Id | this) `]`

    Definition Classes
      Parser
13.  def annotTypeRest(t: G.Tree): G.Tree
    Definition Classes
      Parser
14.  def annotationExpr(): G.Tree
    Definition Classes
      Parser
15.  def annotations(skipNewLines: Boolean): List[G.Tree]

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

    Definition Classes
      Parser
16.  def argumentExprs(): List[G.Tree]

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

    Definition Classes
      Parser
17.  def argumentPatterns(): List[G.Tree]
    Definition Classes
      Parser
18.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
19.  val assumedClosingParens: Map[Int, Int]
    Definition Classes
      Parser
20.  def atInPos[T <: G.Tree](t: T): T
    Definition Classes
      Parser
21.  def atPos[T <: G.Tree](pos: G.Position)(t: T): T
    Definition Classes
      Parser
22.  def atPos[T <: G.Tree](start: ScaladocSyntaxAnalyzer.Offset, point: ScaladocSyntaxAnalyzer.Offset, end: ScaladocSyntaxAnalyzer.Offset)(t: T): T
    Definition Classes
      Parser
23.  def atPos[T <: G.Tree](start: ScaladocSyntaxAnalyzer.Offset, point: ScaladocSyntaxAnalyzer.Offset)(t: T): T
    Definition Classes
      Parser
24.  def atPos[T <: G.Tree](offset: ScaladocSyntaxAnalyzer.Offset)(t: T): T
    Definition Classes
      Parser
25.  def block(): G.Tree

        Block ::= BlockStatSeq

    Definition Classes
      Parser
    Note

      Return tree does not carry position.

26.  def blockExpr(): G.Tree

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

    Definition Classes
      Parser
27.  def blockStatSeq(): List[G.Tree]

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

    Definition Classes
      Parser
28.  def bound(tok: ScaladocSyntaxAnalyzer.Token): G.Tree
    Definition Classes
      Parser
29.  def caseBlock(): G.Tree
    Definition Classes
      Parser
30.  def caseClause(): G.CaseDef
    Definition Classes
      Parser
31.  def caseClauses(): List[G.CaseDef]

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

    Definition Classes
      Parser
32.  final def caseSeparated[T](part: => T): List[T]
    Definition Classes
      Parser
    Annotations
      @inline()
33.  def checkAssoc(offset: ScaladocSyntaxAnalyzer.Offset, op: G.Name, leftAssoc: Boolean): Unit
    Definition Classes
      Parser
34.  def checkHeadAssoc(leftAssoc: Boolean): Unit
    Definition Classes
      Parser
35.  def checkKeywordDefinition(): Unit
    Definition Classes
      Parser
36.  def checkNoEscapingPlaceholders[T](op: => T): T
    Definition Classes
      Parser
37.  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
38.  def checkQMarkDefinition(): Unit
    Definition Classes
      Parser
39.  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
40.  def clone(): AnyRef
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.CloneNotSupportedException]) @native()
41.  final def commaSeparated[T](part: => T): List[T]

    , with the separator fixed to commas.

        tokenSeparated

    , with the separator fixed to commas.

    Definition Classes
      ParserCommon
    Annotations
      @inline()
42.  def compilationUnit(): G.PackageDef

        CompilationUnit ::= {package QualId semi} TopStatSeq

    Definition Classes
      Parser
43.  def condExpr(): G.Tree
    Definition Classes
      Parser
44.  def constrBlock(): G.Tree

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

    Definition Classes
      Parser
45.  def constrExpr(): G.Tree

        ConstrExpr      ::=  SelfInvocation
                          |  ConstrBlock

    Definition Classes
      Parser
46.  def constructorAnnotations(): List[G.Tree]
    Definition Classes
      Parser
47.  def convertToParam(tree: G.Tree): G.ValDef

    Convert tree to formal parameter.

    Convert tree to formal parameter.

    Definition Classes
      Parser
48.  def convertToParams(tree: G.Tree): List[G.ValDef]

    Convert tree to formal parameter list.

    Convert tree to formal parameter list.

    Definition Classes
      Parser
49.  def convertToTypeId(tree: G.Tree): G.Tree

    Convert (qual)ident to type identifier.

    Convert (qual)ident to type identifier.

    Definition Classes
      Parser
50.  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
51.  def deprecationWarning(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, since: String, actions: List[CodeAction]): Unit
    Definition Classes
      UnitParser → SourceFileParser → ParserCommon
52.  final def dropAnyBraces[T](body: => T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
53.  def ensureEarlyDef(tree: G.Tree): G.Tree
    Definition Classes
      Parser
54.  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
55.  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
56.  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
57.  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
58.  def enumerator(isFirst: Boolean, allowNestedIf: Boolean = true): List[G.Tree]
    Definition Classes
      Parser
59.  def enumerators(): List[G.Tree]

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

    Definition Classes
      Parser
60.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
61.  def equals(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef → Any
62.  def errorPatternTree: G.Ident
    Definition Classes
      Parser
63.  def errorTermTree: G.Literal
    Definition Classes
      Parser
64.  def errorTypeTree: G.TypeTree
    Definition Classes
      Parser
65.  def expectedMsg(token: ScaladocSyntaxAnalyzer.Token): String
    Definition Classes
      Parser
66.  def expectedMsgTemplate(exp: String, fnd: String): String
    Definition Classes
      Parser
67.  def expr(location: ScaladocSyntaxAnalyzer.Location): G.Tree
    Definition Classes
      Parser
68.  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
69.  def expr0(location: ScaladocSyntaxAnalyzer.Location): G.Tree
    Definition Classes
      Parser
70.  def exprSimpleType(): G.Tree
    Definition Classes
      Parser
71.  def exprTypeArgs(): List[G.Tree]
    Definition Classes
      Parser
72.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.Throwable])
73.  def finishBinaryOp(isExpr: Boolean, opinfo: ScaladocSyntaxAnalyzer.OpInfo, rhs: G.Tree): G.Tree
    Definition Classes
      Parser
74.  def finishPostfixOp(start: Int, base: List[ScaladocSyntaxAnalyzer.OpInfo], opinfo: ScaladocSyntaxAnalyzer.OpInfo): G.Tree
    Definition Classes
      Parser
75.  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
76.  implicit def fresh: FreshNameCreator
    Definition Classes
      Parser
77.  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
78.  def funDefRest(start: ScaladocSyntaxAnalyzer.Offset, nameOffset: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers, name: G.Name): G.Tree
    Definition Classes
      Parser
79.  def generator(eqOK: Boolean, allowNestedIf: Boolean = true): List[G.Tree]

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

    Definition Classes
      Parser
80.  final def getClass(): Class[_ <: AnyRef]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
81.  def guard(): G.Tree

        Guard ::= if PostfixExpr

    Definition Classes
      Parser
82.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
83.  def ident(): G.Name
    Definition Classes
      Parser
84.  def ident(skipIt: Boolean): G.Name

    Assumed (provisionally) to be TermNames.

    Assumed (provisionally) to be TermNames.

    Definition Classes
      Parser
85.  def identForType(skipIt: Boolean): G.TypeName
    Definition Classes
      Parser
86.  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
87.  def identOrMacro(): G.Name
    Definition Classes
      Parser
88.  def implicitClosure(start: ScaladocSyntaxAnalyzer.Offset, location: ScaladocSyntaxAnalyzer.Location): G.Tree

        Expr ::= implicit Id `=>` Expr

    Definition Classes
      Parser
89.  def importClause(): List[G.Tree]

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

    Definition Classes
      Parser
90.  def importExpr(): G.Tree

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

    Definition Classes
      Parser
91.  def importSelector(): G.ImportSelector

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

    Definition Classes
      Parser
92.  def importSelectors(): List[G.ImportSelector]

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

    Definition Classes
      Parser
93.  val in: ScaladocSyntaxAnalyzer.Scanner
    Definition Classes
      SourceFileParser → Parser → ParserCommon
94.  final def inBraces[T](body: => T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
95.  final def inBracesOrError[T](body: => T, alt: T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
96.  final def inBracesOrNil[T](body: => List[T]): List[T]
    Definition Classes
      ParserCommon
    Annotations
      @inline()
97.  final def inBracesOrUnit[T](body: => G.Tree): G.Tree
    Definition Classes
      ParserCommon
    Annotations
      @inline()
98.  final def inBrackets[T](body: => T): T
    Definition Classes
      ParserCommon
    Annotations
      @inline()
99.  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()
100.  final def inParens[T](body: => T): T
     Definition Classes
       ParserCommon
     Annotations
       @inline()
101.  final def inParensOrError[T](body: => T, alt: T): T
     Definition Classes
       ParserCommon
     Annotations
       @inline()
102.  final def inParensOrNil[T](body: => List[T]): List[T]
     Definition Classes
       ParserCommon
     Annotations
       @inline()
103.  final def inParensOrUnit[T](body: => G.Tree): G.Tree
     Definition Classes
       ParserCommon
     Annotations
       @inline()
104.  def incompleteInputError(msg: String, actions: List[CodeAction]): Unit
     Definition Classes
       UnitParser → SourceFileParser → Parser
105.  def isAnnotation: Boolean
     Definition Classes
       Parser
106.  def isCaseDefEnd: Boolean
     Definition Classes
       Parser
107.  def isDclIntro: Boolean
     Definition Classes
       Parser
108.  def isDefIntro: Boolean
     Definition Classes
       Parser
109.  def isExprIntro: Boolean
     Definition Classes
       Parser
110.  def isExprIntroToken(token: ScaladocSyntaxAnalyzer.Token): Boolean
     Definition Classes
       Parser
111.  def isIdent: Boolean
     Definition Classes
       Parser
112.  def isIdentExcept(except: G.Name): Boolean
     Definition Classes
       Parser
113.  def isIdentOf(name: G.Name): Boolean
     Definition Classes
       Parser
114.  final def isInstanceOf[T0]: Boolean
     Definition Classes
       Any
115.  def isLiteral: Boolean
     Definition Classes
       Parser
116.  def isLiteralToken(token: ScaladocSyntaxAnalyzer.Token): Boolean
     Definition Classes
       Parser
117.  def isLocalModifier: Boolean
     Definition Classes
       Parser
118.  def isMacro: Boolean
     Definition Classes
       Parser
119.  def isModifier: Boolean
     Definition Classes
       Parser
120.  def isNumericLit: Boolean
     Definition Classes
       Parser
121.  def isRawBar: Boolean
     Definition Classes
       Parser
122.  def isRawIdent: Boolean
     Definition Classes
       Parser
123.  def isRawStar: Boolean
     Definition Classes
       Parser
124.  def isScala3WildcardType: Boolean
     Definition Classes
       Parser
125.  def isSoftModifier: Boolean
     Definition Classes
       Parser
126.  def isStatSep: Boolean
     Definition Classes
       Parser
127.  def isStatSep(token: ScaladocSyntaxAnalyzer.Token): Boolean
     Definition Classes
       Parser
128.  def isStatSeqEnd: Boolean
     Definition Classes
       Parser
129.  def isTemplateIntro: Boolean
     Definition Classes
       Parser
130.  def isTypeIntroToken(token: ScaladocSyntaxAnalyzer.Token): Boolean
     Definition Classes
       Parser
131.  def isTypedParam(t: G.Tree): Boolean
     Definition Classes
       Parser
132.  def isUnaryOp: Boolean
     Definition Classes
       Parser
133.  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
134.  final def isWildcard(t: G.Tree): Boolean
     Definition Classes
       Parser
     Annotations
       @tailrec()
135.  def isWildcardType: Boolean
     Definition Classes
       Parser
136.  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
137.  def literal(isNegated: Boolean = false, inPattern: Boolean = false, start: ScaladocSyntaxAnalyzer.Offset = in.offset): G.Tree

         SimpleExpr    ::= literal
                         | symbol
                         | null

     Definition Classes
       Parser
138.  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
139.  def localModifiers(): G.Modifiers

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

     Definition Classes
       Parser
140.  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()
141.  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
142.  def makeEmptyPackage(start: ScaladocSyntaxAnalyzer.Offset, stats: List[G.Tree]): G.PackageDef
     Definition Classes
       Parser
143.  def makeFilter(start: ScaladocSyntaxAnalyzer.Offset, tree: G.Tree): G.Apply
     Definition Classes
       Parser
144.  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
145.  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()
146.  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
147.  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
148.  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
149.  def migrationWarning(offset: ScaladocSyntaxAnalyzer.Offset, depr: => String, migr: => String, since: String): Unit
     Definition Classes
       Parser
150.  def migrationWarning(offset: ScaladocSyntaxAnalyzer.Offset, depr: => String, migr: => String, since: String, actions: (String) => List[CodeAction]): Unit
     Definition Classes
       Parser
151.  def migrationWarning(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, since: String = "", actions: List[CodeAction] = Nil): Unit
     Definition Classes
       Parser
152.  def mixinQualifierOpt(): G.TypeName

         MixinQualifier ::= `[` Id `]`

     Definition Classes
       Parser
153.  def modifiers(): G.Modifiers

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

     Definition Classes
       Parser
154.  def multipleArgumentExprs(): List[List[G.Tree]]

     A succession of argument lists.

     A succession of argument lists.

     Definition Classes
       Parser
155.  final def ne(arg0: AnyRef): Boolean
     Definition Classes
       AnyRef
156.  def newLineOpt(): Unit
     Definition Classes
       Parser
157.  def newLineOptWhenFollowedBy(token: ScaladocSyntaxAnalyzer.Offset): Unit
     Definition Classes
       Parser
158.  def newLineOptWhenFollowing(p: (ScaladocSyntaxAnalyzer.Token) => Boolean): Unit
     Definition Classes
       Parser
159.  def newLinesOpt(): Unit
     Definition Classes
       Parser
160.  def newScanner(): ScaladocUnitScanner
     Definition Classes
       ScaladocUnitParser → UnitParser → SourceFileParser
161.  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
162.  def nonLocalDefOrDcl: List[G.Tree]
     Definition Classes
       Parser
163.  final def notify(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
164.  final def notifyAll(): Unit
     Definition Classes
       AnyRef
     Annotations
       @native()
165.  def o2p(offset: ScaladocSyntaxAnalyzer.Offset): G.Position
     Definition Classes
       Parser
166.  def objectDef(start: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers, isPackageObject: Boolean = false): G.ModuleDef

         ObjectDef       ::= Id ClassTemplateOpt

     Definition Classes
       Parser
167.  var opstack: List[ScaladocSyntaxAnalyzer.OpInfo]
     Definition Classes
       Parser
168.  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
169.  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
170.  def packageOrPackageObject(start: ScaladocSyntaxAnalyzer.Offset): G.Tree
     Definition Classes
       Parser
171.  def param(owner: G.Name, implicitmod: Long, caseParam: Boolean): G.ValDef
     Definition Classes
       Parser
172.  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
173.  def paramType(repeatedParameterOK: Boolean, useStartAsPosition: Boolean): G.Tree
     Definition Classes
       Parser
174.  def paramType(): G.Tree

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

     Definition Classes
       Parser
175.  def parse(): G.Tree

     This is the general parse entry point.

     This is the general parse entry point.

     Definition Classes
       Parser
176.  def parseRule[T](rule: (ScaladocUnitParser.this.type) => T): T
     Definition Classes
       Parser
177.  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
178.  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
179.  def parseStatsOrPackages(): List[G.Tree]
     Definition Classes
       Parser
180.  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
181.  def path(thisOK: Boolean, typeOK: Boolean): G.Tree

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

     Definition Classes
       Parser
182.  def pattern(): G.Tree

     Default entry points into some pattern contexts.

     Default entry points into some pattern contexts.

     Definition Classes
       Parser
183.  var placeholderParams: List[G.ValDef]

     The parameters introduced by `_` "placeholder syntax" in the current expression.

     The parameters introduced by `_` "placeholder syntax" in the current expression. Parameters appear in reverse order.

     Definition Classes
       Parser
184.  def placeholderTypeBoundary(op: => G.Tree): G.Tree
     Definition Classes
       Parser
185.  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
186.  def postfixExpr(): G.Tree

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

     Definition Classes
       Parser
187.  def prefixExpr(): G.Tree

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

     Definition Classes
       Parser
188.  def qualId(): G.Tree

         QualId ::= Id {`.` Id}

     Definition Classes
       Parser
189.  def r2p(offset: ScaladocSyntaxAnalyzer.Offset): G.Position
     Definition Classes
       Parser
190.  def r2p(start: ScaladocSyntaxAnalyzer.Offset, mid: ScaladocSyntaxAnalyzer.Offset): G.Position
     Definition Classes
       Parser
191.  def r2p(start: ScaladocSyntaxAnalyzer.Offset, mid: ScaladocSyntaxAnalyzer.Offset, end: ScaladocSyntaxAnalyzer.Offset): G.Position
     Definition Classes
       Parser
192.  def rawIdent(): G.Name
     Definition Classes
       Parser
193.  def readAnnots(part: => G.Tree): List[G.Tree]
     Definition Classes
       Parser
194.  def reduceExprStack(base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree): G.Tree
     Definition Classes
       Parser
195.  def reducePatternStack(base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree): G.Tree
     Definition Classes
       Parser
196.  def reduceStack(isExpr: Boolean, base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree, opPrecedence: Precedence, leftAssoc: Boolean): G.Tree
     Definition Classes
       Parser
197.  def reduceStack(isExpr: Boolean, base: List[ScaladocSyntaxAnalyzer.OpInfo], top: G.Tree): G.Tree
     Definition Classes
       Parser
198.  def refineStat(): List[G.Tree]
     Definition Classes
       Parser
199.  def refineStatSeq(): List[G.Tree]

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

     Definition Classes
       Parser
200.  def refinement(): List[G.Tree]

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

     Definition Classes
       Parser
201.  def resetPackage(): Unit
     Definition Classes
       Parser
202.  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
203.  def selector(start: ScaladocSyntaxAnalyzer.Offset, t0: G.Tree): G.Tree
     Definition Classes
       Parser
204.  final def selectors(start: ScaladocSyntaxAnalyzer.Offset, t: G.Tree, typeOK: Boolean, dotOffset: ScaladocSyntaxAnalyzer.Offset): G.Tree
     Definition Classes
       Parser
     Annotations
       @tailrec()
205.  def selfInvocation(): G.Tree

         SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}

     Definition Classes
       Parser
206.  final def separatedToken[T](separator: ScaladocSyntaxAnalyzer.Token, part: => T): List[T]

     .

         { `sep` part }

     .

     Definition Classes
       Parser → ParserCommon
207.  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
208.  def seqPatterns(): List[G.Tree]
     Definition Classes
       Parser
209.  def setInPos[T <: G.Tree](t: T): T
     Definition Classes
       Parser
210.  def showSyntaxErrors(): Unit
     Definition Classes
       UnitParser
211.  def simpleExpr(): G.Tree

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

     Definition Classes
       Parser
212.  final def simpleExprRest(start: ScaladocSyntaxAnalyzer.Offset, t: G.Tree, canApply: Boolean): G.Tree
     Definition Classes
       Parser
     Annotations
       @tailrec()
213.  def skip(targetToken: ScaladocSyntaxAnalyzer.Token): Unit
     Attributes
       protected
     Definition Classes
       Parser
214.  def smartParse(): G.Tree

     parse unit.

     parse unit. If there are unbalanced braces, try to correct them and reparse.

     Definition Classes
       UnitParser
215.  val source: SourceFile
     Definition Classes
       SourceFileParser → Parser
216.  def stableId(): G.Tree

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

     Definition Classes
       Parser
217.  def startAnnotType(): G.Tree
     Definition Classes
       Parser
218.  def startInfixType(): G.Tree
     Definition Classes
       Parser
219.  def statSeq(stat: PartialFunction[ScaladocSyntaxAnalyzer.Token, List[G.Tree]], errorMsg: String = "illegal start of definition"): List[G.Tree]
     Definition Classes
       Parser
220.  def statement(location: ScaladocSyntaxAnalyzer.Location): G.Tree
     Definition Classes
       Parser
221.  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
222.  final def synchronized[T0](arg0: => T0): T0
     Definition Classes
       AnyRef
223.  def syntaxError(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, actions: List[CodeAction]): Unit
     Definition Classes
       UnitParser → SourceFileParser → Parser
224.  def syntaxError(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, skipIt: Boolean, actions: List[CodeAction]): Unit
     Definition Classes
       Parser
225.  def syntaxError(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, skipIt: Boolean): Unit
     Definition Classes
       Parser
226.  def syntaxError(msg: String, skipIt: Boolean, actions: List[CodeAction]): Unit
     Definition Classes
       Parser
227.  def syntaxError(msg: String, skipIt: Boolean): Unit
     Definition Classes
       Parser
228.  def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean, actions: List[CodeAction] = Nil): Unit
     Definition Classes
       Parser
229.  def syntaxErrorOrIncompleteAnd[T](msg: String, skipIt: Boolean, actions: List[CodeAction] = Nil)(and: T): T
     Definition Classes
       Parser
230.  val syntaxErrors: ListBuffer[(Int, String, List[CodeAction])]
     Definition Classes
       UnitParser
231.  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
232.  def templateBody(): (G.ValDef, List[G.Tree])

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

     Definition Classes
       Parser
233.  def templateBodyOpt(parenMeansSyntaxError: Boolean): (G.ValDef, List[G.Tree])
     Definition Classes
       Parser
234.  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
235.  def templateOrTopStatSeq(): List[G.Tree]
     Definition Classes
       Parser
236.  def templateParents(): List[G.Tree]

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

     Definition Classes
       Parser
237.  def templateStat: PartialFunction[ScaladocSyntaxAnalyzer.Token, List[G.Tree]]
     Definition Classes
       Parser
238.  def templateStatSeq(): (G.ValDef, List[G.Tree])

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

     Definition Classes
       Parser
239.  def templateStats(): List[G.Tree]

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

     Definition Classes
       Parser
240.  def tmplDef(pos: ScaladocSyntaxAnalyzer.Offset, mods: G.Modifiers): G.Tree

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

     Definition Classes
       Parser
241.  def toString(): String
     Definition Classes
       AnyRef → Any
242.  final def tokenSeparated[T](separator: ScaladocSyntaxAnalyzer.Token, part: => T): List[T]

     .

         part { `sep` part }

     .

     Definition Classes
       Parser → ParserCommon
243.  def topLevelTmplDef: G.Tree

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

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

     Definition Classes
       Parser
244.  def topStat: PartialFunction[ScaladocSyntaxAnalyzer.Token, List[G.Tree]]
     Definition Classes
       Parser
245.  def topStatSeq(): List[G.Tree]

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

     Definition Classes
       Parser
246.  val treeBuilder: ParserTreeBuilder
     Definition Classes
       Parser
247.  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
248.  def typeBounds(): G.TypeBoundsTree

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

     Definition Classes
       Parser
249.  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
250.  def typeOrInfixType(location: ScaladocSyntaxAnalyzer.Location): G.Tree
     Definition Classes
       Parser
251.  def typeParamClauseOpt(owner: G.Name, contextBoundBuf: ListBuffer[G.Tree], ownerKind: ScaladocSyntaxAnalyzer.ParamOwner): 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
252.  def typedOpt(): G.Tree

         TypedOpt ::= [`:` Type]

     Definition Classes
       Parser
253.  val unit: G.CompilationUnit
     Definition Classes
       UnitParser → SourceFileParser → Parser
254.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
255.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException])
256.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws(classOf[java.lang.InterruptedException]) @native()
257.  def warning(offset: ScaladocSyntaxAnalyzer.Offset, msg: String, category: WarningCategory, actions: List[CodeAction]): Unit
     Definition Classes
       UnitParser → SourceFileParser → Parser
258.  def warning(msg: String, category: WarningCategory, actions: List[CodeAction]): Unit
     Definition Classes
       Parser
259.  def warning(msg: String, category: WarningCategory): Unit
     Definition Classes
       Parser
260.  def wildImportSelector(): G.ImportSelector
     Definition Classes
       Parser
261.  def wildcardOrIdent(): G.Name
     Definition Classes
       Parser
262.  def wildcardType(start: ScaladocSyntaxAnalyzer.Offset, qmark: Boolean): G.Ident

         WildcardType ::= `_` TypeBounds

     Definition Classes
       Parser
263.  def withPatches(patches: List[BracePatch]): ScaladocUnitParser
     Definition Classes
       ScaladocUnitParser → UnitParser
264.  def xmlLiteral(): G.Tree
     Definition Classes
       SourceFileParser → Parser
265.  def xmlLiteralPattern(): G.Tree
     Definition Classes
       SourceFileParser → Parser
266.  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
267.  def xmlSeqPatterns(): List[G.Tree]
     Definition Classes
       Parser

### Deprecated Value Members

1.  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
     @deprecated @inline()
   Deprecated

     (Since version 2.12.16) Use `formatString.format(value)` instead of `value.formatted(formatString)`, or use the `f""` string interpolator. In Java 15 and later, `formatted` resolves to the new method in String which has reversed parameters.

2.  def precedence(operator: G.Name): Int
   Definition Classes
     Parser
   Annotations
     @deprecated
   Deprecated

     (Since version 2.11.0) Use `scala.reflect.internal.Precedence`

3.  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.

### 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