scala.tools.nsc.ast.parser.Parsers

OutlineParser

class OutlineParser extends SourceFileParser

Source
Parsers.scala
Linear Supertypes
SourceFileParser, Parser, Parsers.ParserCommon, AnyRef, Any
Type Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. OutlineParser
  2. SourceFileParser
  3. Parser
  4. ParserCommon
  5. AnyRef
  6. Any
Implicitly
  1. by any2stringadd
  2. by any2stringfmt
  3. by any2ArrowAssoc
  4. by any2Ensuring
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new OutlineParser(source: SourceFile)

Type Members

  1. trait PatternContextSensitive extends AnyRef

    Methods which implicitly propagate the context in which they were called: either in a pattern context or not.

  2. trait SeqContextSensitive extends PatternContextSensitive

    Methods which implicitly propagate whether the initial call took place in a context where sequences are allowed.

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. def +(other: String): String

    Implicit information
    This member is added by an implicit conversion from OutlineParser to StringAdd performed by method any2stringadd in scala.Predef.
    Definition Classes
    StringAdd
  5. def ->[B](y: B): (OutlineParser, B)

    Implicit information
    This member is added by an implicit conversion from OutlineParser to ArrowAssoc[OutlineParser] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  6. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  7. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  8. object InfixMode extends Enumeration

    Modes for infix types.

  9. def accept(token: Int): Int

    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
    ParserParserCommon
  10. def acceptStatSep(): Unit

    semi = nl {nl} | `;`
    nl  = `\n' // where allowed
    Definition Classes
    Parser
  11. def acceptStatSepOpt(): Unit

    Definition Classes
    Parser
  12. def accessModifierOpt(): Global.Modifiers

    AccessModifier ::= (private | protected) [AccessQualifier]
    Definition Classes
    Parser
  13. def accessQualifierOpt(mods: Global.Modifiers): Global.Modifiers

    AccessQualifier ::= `[' (Id | this) `]'
    Definition Classes
    Parser
  14. def annotTypeRest(t: Global.Tree): Global.Tree

    Definition Classes
    Parser
  15. def annotationExpr(): Global.Tree

    Definition Classes
    Parser
  16. def annotations(skipNewLines: Boolean): List[Global.Tree]

    Annotations      ::= {`@' SimpleType {ArgumentExprs}}
    ConsrAnnotations ::= {`@' SimpleType ArgumentExprs}
    Definition Classes
    Parser
  17. def argumentExprs(): List[Global.Tree]

    ArgumentExprs ::= `(' [Exprs] `)'
    | [nl] BlockExpr
    Definition Classes
    Parser
  18. def argumentPatterns(): List[Global.Tree]

    Definition Classes
    Parser
  19. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  20. var assumedClosingParens: Map[Int, Int]

    Definition Classes
    Parser
  21. def atPos[T <: Global.Tree](pos: Global.Position)(t: T): T

    Definition Classes
    Parser
  22. def atPos[T <: Global.Tree](start: Int, point: Int, end: Int)(t: T): T

    Definition Classes
    Parser
  23. def atPos[T <: Global.Tree](start: Int, point: Int)(t: T): T

    Definition Classes
    Parser
  24. def atPos[T <: Global.Tree](offset: Int)(t: T): T

    Definition Classes
    Parser
  25. def block(): Global.Tree

    Block ::= BlockStatSeq
    Definition Classes
    Parser
    Note

    Return tree does not carry position.

  26. def blockExpr(): Global.Tree

    BlockExpr ::= `{' (CaseClauses | Block) `}'
    Definition Classes
    OutlineParserParser
  27. def blockStatSeq(): List[Global.Tree]

    BlockStatSeq ::= { BlockStat semi } [ResultExpr]
    BlockStat    ::= Import
                   | Annotations [implicit] [lazy] Def
                   | Annotations LocalModifiers TmplDef
                   | Expr1
                   |
    Definition Classes
    Parser
  28. def bound(tok: Int, default: Global.TypeName): Global.Tree

    Definition Classes
    Parser
  29. def caseBlock(): Global.Tree

    Definition Classes
    Parser
  30. def caseClauses(): List[Global.CaseDef]

    CaseClauses ::= CaseClause {CaseClause}
    CaseClause  ::= case Pattern [Guard] `=>' Block
    Definition Classes
    Parser
  31. final def caseSeparated[T](part: ⇒ T): List[T]

    Definition Classes
    Parser
    Annotations
    @inline()
  32. def checkAssoc(offset: Int, op: Global.Name, leftAssoc: Boolean): Unit

    Definition Classes
    Parser
  33. def checkLegalExistential(t: Global.Tree): Unit

    Check that tree is a legal clause of a forSome.

    Check that tree is a legal clause of a forSome.

    Definition Classes
    Parser
  34. def checkNoEscapingPlaceholders[T](op: ⇒ T): T

    Definition Classes
    Parser
  35. def checkNotByNameOrVarargs(tpt: Global.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
  36. def checkSize(kind: String, size: Int, max: Int): Unit

    Definition Classes
    Parser
  37. def classDef(start: Int, mods: Global.Modifiers): Global.ClassDef

    ClassDef ::= Id [TypeParamClause] {Annotation}
                 [AccessModifier] ClassParamClauses RequiresTypeOpt ClassTemplateOpt
    TraitDef ::= Id [TypeParamClause] RequiresTypeOpt TraitTemplateOpt
    Definition Classes
    Parser
  38. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  39. final def commaSeparated[T](part: ⇒ T): List[T]

    Definition Classes
    Parser
    Annotations
    @inline()
  40. def compilationUnit(): Global.Tree

    CompilationUnit ::= {package QualId semi} TopStatSeq
    Definition Classes
    Parser
  41. def condExpr(): Global.Tree

    Definition Classes
    Parser
  42. def constrBlock(vparamss: List[List[Global.ValDef]]): Global.Tree

    ConstrBlock    ::=  `{' SelfInvocation {semi BlockStat} `}'
    Definition Classes
    Parser
  43. def constrExpr(vparamss: List[List[Global.ValDef]]): Global.Tree

    ConstrExpr      ::=  SelfInvocation
    |  ConstrBlock
    Definition Classes
    Parser
  44. def constructorAnnotations(): List[Global.Tree]

    Definition Classes
    Parser
  45. def convertToParam(tree: Global.Tree): Global.ValDef

    Convert tree to formal parameter.

    Convert tree to formal parameter.

    Definition Classes
    Parser
  46. def convertToParams(tree: Global.Tree): List[Global.ValDef]

    Convert tree to formal parameter list.

    Convert tree to formal parameter list.

    Definition Classes
    Parser
  47. def convertToTypeId(tree: Global.Tree): Global.Tree

    Convert (qual)ident to type identifier.

    Convert (qual)ident to type identifier.

    Definition Classes
    Parser
  48. def defOrDcl(pos: Int, mods: Global.Modifiers): List[Global.Tree]

    Def    ::= val PatDef
             | var PatDef
             | def FunDef
             | type [nl] TypeDef
             | TmplDef
    Dcl    ::= val PatDcl
             | var PatDcl
             | def FunDcl
             | type [nl] TypeDcl
    Definition Classes
    Parser
  49. def deprecationWarning(offset: Int, msg: String): Unit

    Definition Classes
    SourceFileParserParserCommon
  50. final def dropAnyBraces[T](body: ⇒ T): T

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  51. def ensuring(cond: (OutlineParser) ⇒ Boolean, msg: ⇒ Any): OutlineParser

    Implicit information
    This member is added by an implicit conversion from OutlineParser to Ensuring[OutlineParser] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  52. def ensuring(cond: (OutlineParser) ⇒ Boolean): OutlineParser

    Implicit information
    This member is added by an implicit conversion from OutlineParser to Ensuring[OutlineParser] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  53. def ensuring(cond: Boolean, msg: ⇒ Any): OutlineParser

    Implicit information
    This member is added by an implicit conversion from OutlineParser to Ensuring[OutlineParser] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  54. def ensuring(cond: Boolean): OutlineParser

    Implicit information
    This member is added by an implicit conversion from OutlineParser to Ensuring[OutlineParser] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  55. def enumerators(): List[Parser.treeBuilder.Enumerator]

    Enumerators ::= Generator {semi Enumerator}
    Enumerator  ::=  Generator
                  |  Guard
                  |  val Pattern1 `=' Expr
    Definition Classes
    Parser
  56. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    AnyRef → Any
  58. def equalsExpr(): Global.Tree

    EqualsExpr ::= `=' Expr
    Definition Classes
    Parser
  59. def errorPatternTree: Global.Ident

    Definition Classes
    Parser
  60. def errorTermTree: Global.Literal

    Definition Classes
    Parser
  61. def errorTypeTree: Global.TypeTree

    Definition Classes
    Parser
  62. def expectedMsg(token: Int): String

    Definition Classes
    Parser
  63. def expr(location: Int): Global.Tree

    Definition Classes
    Parser
  64. def expr(): Global.Tree

    Expr       ::= (Bindings | [`implicit'] Id | `_')  `=>' Expr
                 | Expr1
    ResultExpr ::= (Bindings | Id `:' CompoundType) `=>' Block
                 | Expr1
    Expr1      ::= if `(' Expr `)' {nl} Expr [[semi] else Expr]
                 | try (`{' Block `}' | Expr) [catch `{' CaseClauses `}'] [finally Expr]
                 | while `(' Expr `)' {nl} Expr
                 | do Expr [semi] while `(' Expr `)'
                 | for (`(' Enumerators `)' | `{' Enumerators `}') {nl} [yield] Expr
                 | throw Expr
                 | return [Expr]
                 | [SimpleExpr `.'] Id `=' Expr
                 | SimpleExpr1 ArgumentExprs `=' Expr
                 | PostfixExpr Ascription
                 | PostfixExpr match `{' CaseClauses `}'
    Bindings   ::= `(' [Binding {`,' Binding}] `)'
    Binding    ::= (Id | `_') [`:' Type]
    Ascription ::= `:' CompoundType
                 | `:' Annotation {Annotation}
                 | `:' `_' `*'
    Definition Classes
    Parser
  65. def expr0(location: Int): Global.Tree

    Definition Classes
    Parser
  66. def exprSimpleType(): Global.Tree

    Definition Classes
    Parser
  67. def exprTypeArgs(): List[Global.Tree]

    Definition Classes
    Parser
  68. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  69. def formatted(fmtstr: String): String

    Implicit information
    This member is added by an implicit conversion from OutlineParser to StringFormat performed by method any2stringfmt in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  70. def freshName(prefix: String): Global.Name

    Definition Classes
    SourceFileParserParserParserCommon
  71. def freshTermName(prefix: String): Global.TermName

    Definition Classes
    SourceFileParserParserParserCommon
  72. def freshTypeName(prefix: String): Global.TypeName

    Definition Classes
    SourceFileParserParserParserCommon
  73. def funDefOrDcl(start: Int, mods: Global.Modifiers): Global.Tree

    FunDef ::= FunSig [`:' Type] `=' [`macro'] Expr
            |  FunSig [nl] `{' Block `}'
            |  `this' ParamClause ParamClauses
                   (`=' ConstrExpr | [nl] ConstrBlock)
    FunDcl ::= FunSig [`:' Type]
    FunSig ::= id [FunTypeParamClause] ParamClauses
    Definition Classes
    Parser
  74. def funDefRest(start: Int, nameOffset: Int, mods: Global.Modifiers, name: Global.Name): Global.Tree

    Definition Classes
    Parser
  75. def generator(enums: ListBuffer[Parser.treeBuilder.Enumerator], eqOK: Boolean): Unit

    Generator ::= Pattern1 (`<-' | `=') Expr [Guard]
    Definition Classes
    Parser
  76. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  77. def guard(): Global.Tree

    Guard ::= if PostfixExpr
    Definition Classes
    Parser
  78. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  79. def ident(): Global.Name

    Definition Classes
    Parser
  80. def ident(skipIt: Boolean): Global.Name

    Assumed (provisionally) to be TermNames.

    Assumed (provisionally) to be TermNames.

    Definition Classes
    Parser
  81. def identForType(skipIt: Boolean): Global.TypeName

    Definition Classes
    Parser
  82. def identForType(): Global.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
  83. def implicitClosure(start: Int, location: Int): Global.Tree

    Expr ::= implicit Id => Expr
    Definition Classes
    Parser
  84. def importClause(): List[Global.Tree]

    Import  ::= import ImportExpr {`,' ImportExpr}
    Definition Classes
    Parser
  85. def importExpr(): Global.Tree

    ImportExpr ::= StableId `.' (Id | `_' | ImportSelectors)
    Definition Classes
    Parser
  86. def importSelector(): Global.ImportSelector

    ImportSelector ::= Id [`=>' Id | `=>' `_']
    Definition Classes
    Parser
  87. def importSelectors(): List[Global.ImportSelector]

    ImportSelectors ::= `{' {ImportSelector `,'} (ImportSelector | `_') `}'
    Definition Classes
    Parser
  88. val in: Parsers.SourceFileScanner

    Definition Classes
    SourceFileParserParserParserCommon
  89. final def inBraces[T](body: ⇒ T): T

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  90. final def inBracesOrError[T](body: ⇒ T, alt: T): T

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  91. final def inBracesOrNil[T](body: ⇒ List[T]): List[T]

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  92. final def inBracesOrUnit[T](body: ⇒ Global.Tree): Global.Tree

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  93. final def inBrackets[T](body: ⇒ T): T

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  94. final def inParens[T](body: ⇒ T): T

    Methods inParensOrError and similar take a second argument which, should the next token not be the expected opener (e.

    Methods inParensOrError and similar take a second argument which, should the next token not be the expected opener (e.g. LPAREN) will be returned instead of the contents of the groupers. However in all cases accept(LPAREN) will be called, so a parse error will still result. If the grouping is optional, in.token should be tested before calling these methods.

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  95. final def inParensOrError[T](body: ⇒ T, alt: T): T

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  96. final def inParensOrNil[T](body: ⇒ List[T]): List[T]

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  97. final def inParensOrUnit[T](body: ⇒ Global.Tree): Global.Tree

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  98. def incompleteInputError(msg: String): Unit

    Definition Classes
    SourceFileParserParser
  99. def isDclIntro: Boolean

    Definition Classes
    Parser
  100. def isDefIntro: Boolean

    Definition Classes
    Parser
  101. def isExprIntro: Boolean

    Definition Classes
    Parser
  102. def isExprIntroToken(token: Int): Boolean

    Definition Classes
    Parser
  103. def isIdent: Boolean

    Definition Classes
    Parser
  104. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  105. def isInterface(mods: Global.Modifiers, body: List[Global.Tree]): Boolean

    Definition Classes
    Parser
  106. def isLiteral: Boolean

    Definition Classes
    Parser
  107. def isLiteralToken(token: Int): Boolean

    Definition Classes
    Parser
  108. def isLocalModifier: Boolean

    Definition Classes
    Parser
  109. def isModifier: Boolean

    Definition Classes
    Parser
  110. def isNumericLit: Boolean

    Definition Classes
    Parser
  111. def isRawBar: Boolean

    Definition Classes
    Parser
  112. def isRawStar: Boolean

    Definition Classes
    Parser
  113. def isStatSep: Boolean

    Definition Classes
    Parser
  114. def isStatSep(token: Int): Boolean

    Definition Classes
    Parser
  115. def isStatSeqEnd: Boolean

    Definition Classes
    Parser
  116. def isTemplateIntro: Boolean

    Definition Classes
    Parser
  117. def isTypeIntro: Boolean

    Definition Classes
    Parser
  118. def isTypeIntroToken(token: Int): Boolean

    Definition Classes
    Parser
  119. def isUnaryOp: Boolean

    Definition Classes
    Parser
  120. def isWildcard(t: Global.Tree): Boolean

    Definition Classes
    Parser
  121. def joinComment(trees: ⇒ List[Global.Tree]): List[Global.Tree]

    Join the comment associated with a definition.

    Join the comment associated with a definition.

    Definition Classes
    Parser
  122. def literal(isNegated: Boolean = false, inPattern: Boolean = false): Global.Tree

    SimpleExpr    ::= literal
    | symbol
    | null
    Definition Classes
    Parser
    Note

    The returned tree does not yet have a position

  123. def localDef(implicitMod: Int): List[Global.Tree]

    overridable IDE hook for local definitions of blockStatSeq Here's an idea how to fill in start and end positions.

    overridable IDE hook for local definitions of blockStatSeq Here's an idea how to fill in start and end positions. def localDef : List[Tree] = { atEndPos { atStartPos(in.offset) { val annots = annotations(skipNewLines = true) val mods = localModifiers() withAnnotations annots if (!(mods hasFlag ~(Flags.IMPLICIT | Flags.LAZY))) defOrDcl(mods) else List(tmplDef(mods)) } } (in.offset) }

    Definition Classes
    Parser
  124. def localModifiers(): Global.Modifiers

    LocalModifiers ::= {LocalModifier}
    LocalModifier  ::= abstract | final | sealed | implicit | lazy
    Definition Classes
    Parser
  125. def makeFilter(start: Int, tree: Global.Tree): Parser.treeBuilder.Filter

    Definition Classes
    Parser
  126. def makePackageObject(start: Int, objDef: Global.ModuleDef): Global.PackageDef

    Create a tree representing a package object, converting

    Create a tree representing a package object, converting

    package object foo { ... }

    to

    package foo {
    object `package` { ... }
    }
    Definition Classes
    Parser
  127. def makePackaging(start: Int, pkg: Global.Tree, stats: List[Global.Tree]): Global.PackageDef

    Create a tree representing a packaging.

    Create a tree representing a packaging.

    Definition Classes
    Parser
  128. final def makeParens(body: ⇒ List[Global.Tree]): Global.Parens

    Creates an actual Parens node (only used during parsing.

    Creates an actual Parens node (only used during parsing.)

    Definition Classes
    ParserCommon
    Annotations
    @inline()
  129. def mixinQualifierOpt(): Global.TypeName

    MixinQualifier ::= `[' Id `]'
    Definition Classes
    Parser
  130. def modifiers(): Global.Modifiers

    Modifiers ::= {Modifier}
    Modifier  ::= LocalModifier
                |  AccessModifier
                |  override
    Definition Classes
    Parser
  131. def multipleArgumentExprs(): List[List[Global.Tree]]

    A succession of argument lists.

    A succession of argument lists.

    Definition Classes
    Parser
  132. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  133. def newLineOpt(): Unit

    Definition Classes
    Parser
  134. def newLineOptWhenFollowedBy(token: Int): Unit

    Definition Classes
    Parser
  135. def newLineOptWhenFollowing(p: (Int) ⇒ Boolean): Unit

    Definition Classes
    Parser
  136. def newLinesOpt(): Unit

    Definition Classes
    Parser
  137. def newScanner: Parsers.SourceFileScanner

    Definition Classes
    SourceFileParser
  138. object noSeq extends SeqContextSensitive

    The implementation for parsing inside of patterns at points where sequences are disallowed.

  139. def nonLocalDefOrDcl: List[Global.Tree]

    Definition Classes
    Parser
  140. final def notify(): Unit

    Definition Classes
    AnyRef
  141. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  142. def o2p(offset: Int): Global.Position

    Definition Classes
    SourceFileParserParser
  143. def objectDef(start: Int, mods: Global.Modifiers): Global.ModuleDef

    ObjectDef       ::= Id ClassTemplateOpt
    Definition Classes
    Parser
  144. var opstack: List[OpInfo]

    Definition Classes
    Parser
  145. object outPattern extends PatternContextSensitive

    The implementation of the context sensitive methods for parsing outside of patterns.

  146. def packaging(start: Int): Global.Tree

    Packaging ::= package QualId [nl] `{' TopStatSeq `}'
    Definition Classes
    Parser
  147. def paramClauses(owner: Global.Name, contextBounds: List[Global.Tree], ofCaseClass: Boolean): List[List[Global.ValDef]]

    ParamClauses      ::= {ParamClause} [[nl] `(' implicit Params `)']
    ParamClause       ::= [nl] `(' [Params] `)'
    Params            ::= Param {`,' Param}
    Param             ::= {Annotation} Id [`:' ParamType] [`=' Expr]
    ClassParamClauses ::= {ClassParamClause} [[nl] `(' implicit ClassParams `)']
    ClassParamClause  ::= [nl] `(' [ClassParams] `)'
    ClassParams       ::= ClassParam {`,' ClassParam}
    ClassParam        ::= {Annotation}  [{Modifier} (`val' | `var')] Id [`:' ParamType] [`=' Expr]
    Definition Classes
    Parser
  148. def paramType(useStartAsPosition: Boolean): Global.Tree

    Definition Classes
    Parser
  149. def paramType(): Global.Tree

    ParamType ::= Type | `=>' Type | Type `*'
    Definition Classes
    Parser
  150. def parse(): Global.Tree

    This is the general parse entry point.

    This is the general parse entry point.

    Definition Classes
    Parser
  151. def parseStartRule: () ⇒ Global.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
    SourceFileParserParser
  152. def patDefOrDcl(pos: Int, mods: Global.Modifiers): List[Global.Tree]

    PatDef ::= Pattern2 {`,' Pattern2} [`:' Type] `=' Expr
    ValDcl ::= Id {`,' Id} `:' Type
    VarDef ::= PatDef | Id {`,' Id} `:' Type `=' `_'
    Definition Classes
    Parser
  153. def path(thisOK: Boolean, typeOK: Boolean): Global.Tree

    Path       ::= StableId
                |  [Ident `.'] this
    AnnotType ::= Path [`.' type]
    Definition Classes
    Parser
  154. def pattern(): Global.Tree

    Default entry points into some pattern contexts.

    Default entry points into some pattern contexts.

    Definition Classes
    Parser
  155. def patterns(): List[Global.Tree]

    Definition Classes
    Parser
  156. var placeholderParams: List[Global.ValDef]

    The implicit parameters introduced by _ in the current expression.

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

    Definition Classes
    Parser
  157. def placeholderTypeBoundary(op: ⇒ Global.Tree): Global.Tree

    Definition Classes
    Parser
  158. var placeholderTypes: List[Global.TypeDef]

    The placeholderTypes introduced by _ in the current type.

    The placeholderTypes introduced by _ in the current type. Parameters appear in reverse order.

    Definition Classes
    Parser
  159. def postfixExpr(): Global.Tree

    PostfixExpr   ::= InfixExpr [Id [nl]]
    InfixExpr     ::= PrefixExpr
                    | InfixExpr Id [nl] InfixExpr
    Definition Classes
    Parser
  160. def precedence(operator: Global.Name): Int

    Definition Classes
    Parser
  161. def prefixExpr(): Global.Tree

    PrefixExpr   ::= [`-' | `+' | `~' | `!' | `&'] SimpleExpr
    Definition Classes
    Parser
  162. def qualId(): Global.Tree

    QualId ::= Id {`.' Id}
    Definition Classes
    Parser
  163. def r2p(start: Int, mid: Int, end: Int): Global.Position

    Definition Classes
    SourceFileParserParser
  164. def rawIdent(): Global.Name

    Definition Classes
    Parser
  165. final def readAnnots[T](part: ⇒ T): List[T]

    Definition Classes
    Parser
    Annotations
    @inline()
  166. def reduceStack(isExpr: Boolean, base: List[OpInfo], top0: Global.Tree, prec: Int, leftAssoc: Boolean): Global.Tree

    Definition Classes
    Parser
  167. def refineStatSeq(): List[Global.Tree]

    RefineStatSeq    ::= RefineStat {semi RefineStat}
    RefineStat       ::= Dcl
                       | type TypeDef
                       |
    Definition Classes
    Parser
  168. def refinement(): List[Global.Tree]

    Refinement ::= [nl] `{' RefineStat {semi RefineStat} `}'
    Definition Classes
    Parser
  169. def resetPackage(): Unit

    Definition Classes
    Parser
  170. def scriptBody(): Global.Tree

    This is the parse entry point for code which is not self-contained, e.

    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
  171. def selector(t: Global.Tree): Global.Tree

    Definition Classes
    Parser
  172. def selectors(t: Global.Tree, typeOK: Boolean, dotOffset: Int): Global.Tree

    Definition Classes
    Parser
  173. def selfInvocation(vparamss: List[List[Global.ValDef]]): Global.Tree

    SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}
    Definition Classes
    Parser
  174. object seqOK extends SeqContextSensitive

    The implementation for parsing inside of patterns at points where sequences are allowed.

  175. def seqPatterns(): List[Global.Tree]

    Definition Classes
    Parser
  176. def simpleExpr(): Global.Tree

    SimpleExpr    ::= new (ClassTemplate | TemplateBody)
                    |  BlockExpr
                    |  SimpleExpr1 [`_']
    SimpleExpr1   ::= literal
                    |  xLiteral
                    |  Path
                    |  `(' [Exprs] `)'
                    |  SimpleExpr `.' Id
                    |  SimpleExpr TypeArgs
                    |  SimpleExpr1 ArgumentExprs
    Definition Classes
    Parser
  177. def simpleExprRest(t: Global.Tree, canApply: Boolean): Global.Tree

    Definition Classes
    Parser
  178. def skip(targetToken: Int): Unit

    Attributes
    protected
    Definition Classes
    Parser
  179. def skipBraces[T](body: T): T

  180. def stableId(): Global.Tree

    StableId ::= Id
    |  Path `.' Id
    |  [id `.'] super [`[' id `]']`.' id
    Definition Classes
    Parser
  181. def startAnnotType(): Global.Tree

    Definition Classes
    Parser
  182. def startInfixType(): Global.Tree

    Definition Classes
    Parser
  183. def statement(location: Int): Global.Tree

    Definition Classes
    Parser
  184. object symbXMLBuilder extends SymbolicXMLBuilder

    Definition Classes
    SourceFileParser
  185. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  186. def syntaxError(offset: Int, msg: String): Unit

    Definition Classes
    SourceFileParserParser
  187. def syntaxError(offset: Int, msg: String, skipIt: Boolean): Unit

    Definition Classes
    Parser
  188. def syntaxError(msg: String, skipIt: Boolean): Unit

    Definition Classes
    Parser
  189. def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean): Unit

    Definition Classes
    Parser
  190. def template(isTrait: Boolean): (List[Global.Tree], List[List[Global.Tree]], Global.ValDef, List[Global.Tree])

    ClassTemplate ::= [EarlyDefs with] ClassParents [TemplateBody]
    TraitTemplate ::= [EarlyDefs with] TraitParents [TemplateBody]
    EarlyDefs     ::= `{' [EarlyDef {semi EarlyDef}] `}'
    EarlyDef      ::= Annotations Modifiers PatDef
    Definition Classes
    Parser
  191. def templateBody(isPre: Boolean): (Global.emptyValDef.type, collection.immutable.List[Global.EmptyTree.type])

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

    specifies whether in early initializer (true) or not (false)

    Definition Classes
    OutlineParserParser
  192. def templateBodyOpt(traitParentSeen: Boolean): (Global.ValDef, List[Global.Tree])

    Definition Classes
    Parser
  193. def templateOpt(mods: Global.Modifiers, name: Global.Name, constrMods: Global.Modifiers, vparamss: List[List[Global.ValDef]], tstart: Int): Global.Template

    ClassTemplateOpt ::= `extends' ClassTemplate | [[`extends'] TemplateBody]
    TraitTemplateOpt ::= TraitExtends TraitTemplate | [[`extends'] TemplateBody] | `<:' TemplateBody
    TraitExtends     ::= `extends' | `<:'
    Definition Classes
    Parser
  194. def templateParents(isTrait: Boolean): (List[Global.Tree], List[List[Global.Tree]])

    ClassParents       ::= AnnotType {`(' [Exprs] `)'} {with AnnotType}
    TraitParents       ::= AnnotType {with AnnotType}
    Definition Classes
    Parser
  195. def templateStatSeq(isPre: Boolean): (Global.ValDef, List[Global.Tree])

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

    specifies whether in early initializer (true) or not (false)

    Definition Classes
    Parser
  196. def templateStats(): List[Global.Tree]

    Informal - for the repl and other direct parser accessors.

    Informal - for the repl and other direct parser accessors.

    Definition Classes
    Parser
  197. def tmplDef(pos: Int, mods: Global.Modifiers): Global.Tree

    TmplDef ::= [case] class ClassDef
    |  [case] object ObjectDef
    |  [override] trait TraitDef
    Definition Classes
    Parser
  198. def toString(): String

    Definition Classes
    AnyRef → Any
  199. final def tokenSeparated[T](separator: Int, sepFirst: Boolean, part: ⇒ T): List[T]

    ,or if sepFirst is true,

    part { `sep` part }

    ,or if sepFirst is true,

    { `sep` part }

    . { sep part } }}} part { sep part } }}}

    Definition Classes
    Parser
  200. def topLevelTmplDef: Global.Tree

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

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

    Definition Classes
    Parser
  201. def topStatSeq(): List[Global.Tree]

    TopStatSeq ::= TopStat {semi TopStat}
    TopStat ::= Annotations Modifiers TmplDef
              | Packaging
              | package object objectDef
              | Import
              |
    Definition Classes
    Parser
  202. object treeBuilder extends TreeBuilder

    Definition Classes
    Parser
  203. def typ(): Global.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
  204. def typeBounds(): Global.TypeBoundsTree

    TypeBounds ::= [`>:' Type] [`<:' Type]
    Definition Classes
    Parser
  205. def typeDefOrDcl(start: Int, mods: Global.Modifiers): Global.Tree

    TypeDef ::= type Id [TypeParamClause] `=' Type
              | FunSig `=' Expr
    TypeDcl ::= type Id [TypeParamClause] TypeBounds
    Definition Classes
    Parser
  206. def typeOrInfixType(location: Int): Global.Tree

    Definition Classes
    Parser
  207. def typeParamClauseOpt(owner: Global.Name, contextBoundBuf: ListBuffer[Global.Tree]): List[Global.TypeDef]

    TypeParamClauseOpt    ::= [TypeParamClause]
    TypeParamClause       ::= `[' VariantTypeParam {`,' VariantTypeParam} `]']
    VariantTypeParam      ::= {Annotation} [`+' | `-'] TypeParam
    FunTypeParamClauseOpt ::= [FunTypeParamClause]
    FunTypeParamClause    ::= `[' TypeParam {`,' TypeParam} `]']
    TypeParam             ::= Id TypeParamClauseOpt TypeBounds {<% Type} {":" Type}
    Definition Classes
    Parser
  208. def typedOpt(): Global.Tree

    TypedOpt ::= [`:' Type]
    Definition Classes
    Parser
  209. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws()
  212. def warning(offset: Int, msg: String): Unit

    Definition Classes
    SourceFileParserParser
  213. def warning(msg: String): Unit

    Definition Classes
    Parser
  214. def wildcardOrIdent(): Global.Name

    Definition Classes
    Parser
  215. def wildcardType(start: Int): Global.Ident

    WildcardType ::= `_' TypeBounds
    Definition Classes
    Parser
  216. def xmlLiteral(): Global.Tree

    Definition Classes
    SourceFileParserParser
  217. def xmlLiteralPattern(): Global.Tree

    Definition Classes
    SourceFileParserParser
  218. object xmlSeqOK extends SeqContextSensitive

    For use from xml pattern, where sequence is allowed and encouraged.

  219. def xmlSeqPatterns(): List[Global.Tree]

    Definition Classes
    Parser
  220. lazy val xmlp: Parsers.MarkupParser

    the markup parser

    the markup parser

    Definition Classes
    SourceFileParser
  221. def [B](y: B): (OutlineParser, B)

    Implicit information
    This member is added by an implicit conversion from OutlineParser to ArrowAssoc[OutlineParser] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Shadowed Implict Value Members

  1. val self: Any

    Implicit information
    This member is added by an implicit conversion from OutlineParser to StringAdd performed by method any2stringadd in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (outlineParser: StringAdd).self
    Definition Classes
    StringAdd
  2. val self: Any

    Implicit information
    This member is added by an implicit conversion from OutlineParser to StringFormat performed by method any2stringfmt in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (outlineParser: StringFormat).self
    Definition Classes
    StringFormat

Deprecated Value Members

  1. def x: OutlineParser

    Implicit information
    This member is added by an implicit conversion from OutlineParser to ArrowAssoc[OutlineParser] performed by method any2ArrowAssoc in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (outlineParser: ArrowAssoc[OutlineParser]).x
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use leftOfArrow instead

  2. def x: OutlineParser

    Implicit information
    This member is added by an implicit conversion from OutlineParser to Ensuring[OutlineParser] performed by method any2Ensuring in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (outlineParser: Ensuring[OutlineParser]).x
    Definition Classes
    Ensuring
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use resultOfEnsuring instead

Inherited from SourceFileParser

Inherited from Parser

Inherited from Parsers.ParserCommon

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from OutlineParser to StringAdd

Inherited by implicit conversion any2stringfmt from OutlineParser to StringFormat

Inherited by implicit conversion any2ArrowAssoc from OutlineParser to ArrowAssoc[OutlineParser]

Inherited by implicit conversion any2Ensuring from OutlineParser to Ensuring[OutlineParser]

No Group