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 ast
    Definition Classes
    nsc
  • package parser
    Definition Classes
    ast
  • trait Parsers extends Scanners with MarkupParsers with ParsersCommon

    Performs the following context-free rewritings:

    Performs the following context-free rewritings:

    - Places all pattern variables in Bind nodes. In a pattern, for identifiers x:

                    x  => x @ _
                  x:T  => x @ (_ : T)
    

    • Removes pattern definitions (PatDef's) as follows: If pattern is a simple (typed) identifier:
             val x = e     ==>  val x = e
             val x: T = e  ==>  val x: T = e
      

    if there are no variables in pattern

           val p = e  ==>  e match (case p => ())
    

    if there is exactly one variable in pattern

           val x_1 = e match (case p => (x_1))
    

    if there is more than one variable in pattern

           val p = e  ==>  private synthetic val t$ = e match (case p => (x_1, ..., x_N))
                           val x_1 = t$._1
                           ...
                           val x_N = t$._N
    

    - Removes function types as follows:

           (argtpes) => restpe   ==>   scala.Function_n[argtpes, restpe]
    

    - Wraps naked case definitions in a match as follows:

           { cases }   ==>   (x => x.match {cases}), except when already argument to match
    

    Definition Classes
    parser
  • abstract class Parser extends ParserCommon
    Definition Classes
    Parsers
  • InfixMode
  • ParserTreeBuilder
  • PatternContextSensitive
  • SeqContextSensitive
c

scala.tools.nsc.ast.parser.Parsers.Parser

SeqContextSensitive

final class SeqContextSensitive extends PatternContextSensitive

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.

Source
Parsers.scala
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SeqContextSensitive
  2. PatternContextSensitive
  3. AnyRef
  4. 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 SeqContextSensitive(isSequenceOK: Boolean, isXML: Boolean)

    isSequenceOK

    is a sequence pattern _* allowed?

    isXML

    are we in an XML pattern?

Value Members

  1. def annotType(): Global.Tree

    AnnotType        ::=  SimpleType {Annotation}
    Definition Classes
    PatternContextSensitive
  2. final def argType(): Global.Tree

    ArgType       ::=  Type
    Definition Classes
    SeqContextSensitivePatternContextSensitive
  3. def badPattern3(): Global.Tree
  4. def compoundType(): Global.Tree

    CompoundType ::= AnnotType {with AnnotType} [Refinement]
                  |  Refinement
    Definition Classes
    PatternContextSensitive
  5. def compoundTypeRest(t: Global.Tree): Global.Tree
    Definition Classes
    PatternContextSensitive
  6. final def functionArgType(): Global.Tree
  7. def functionTypes(): List[Global.Tree]
    Definition Classes
    PatternContextSensitive
  8. def infixType(mode: InfixMode.Value): Global.Tree

    InfixType ::= CompoundType {id [nl] CompoundType}
    Definition Classes
    PatternContextSensitive
  9. def infixTypeRest(t: Global.Tree, mode: InfixMode.Value): Global.Tree
    Definition Classes
    PatternContextSensitive
  10. val isSequenceOK: Boolean
  11. val isXML: Boolean
  12. def pattern(): Global.Tree

    Pattern  ::=  Pattern1 { `|` Pattern1 }
    SeqPattern ::= SeqPattern1 { `|` SeqPattern1 }
  13. def pattern1(): Global.Tree

    Pattern1    ::= boundvarid `:` TypePat
                  |  `_` `:` TypePat
                  |  Pattern2
    SeqPattern1 ::= boundvarid `:` TypePat
                  |  `_` `:` TypePat
                  |  [SeqPattern2]
  14. def pattern2(): Global.Tree

    Pattern2    ::=  id  `@` Pattern3
                  |  `_` `@` Pattern3
                  |   Pattern3
  15. def pattern3(): Global.Tree

    Pattern3    ::= SimplePattern
                  |  SimplePattern {Id [nl] SimplePattern}
  16. def patterns(): List[Global.Tree]

    Patterns ::= Pattern { `,` Pattern }
    SeqPatterns ::= SeqPattern { `,` SeqPattern }
  17. def simplePattern(onError: () => Global.Tree): Global.Tree
  18. def simplePattern(): Global.Tree

    SimplePattern    ::= varid
                      |  `_`
                      |  literal
                      |  XmlPattern
                      |  StableId  /[TypeArgs]/ [`(` [Patterns] `)`]
                      |  StableId  [`(` [Patterns] `)`]
                      |  StableId  [`(` [Patterns] `,` [varid `@`] `_` `*` `)`]
                      |  `(` [Patterns] `)`

    XXX: Hook for IDE

  19. def simpleType(): Global.Tree

    SimpleType       ::=  SimpleType TypeArgs
                       |  SimpleType `#` Id
                       |  StableId
                       |  Path `.` type
                       |  Literal
                       |  `(` Types `)`
                       |  WildcardType
    Definition Classes
    PatternContextSensitive
  20. final def simpleTypeRest(t: Global.Tree): Global.Tree
    Definition Classes
    PatternContextSensitive
    Annotations
    @tailrec()
  21. def typ(): Global.Tree

    Type ::= InfixType `=>` Type
           | `(` [`=>` Type] `)` `=>` Type
           | InfixType [ExistentialClause]
    ExistentialClause ::= forSome `{` ExistentialDcl {semi ExistentialDcl} `}`
    ExistentialDcl    ::= type TypeDcl | val ValDcl
    Definition Classes
    PatternContextSensitive
  22. def typeArgs(): List[Global.Tree]

    TypeArgs    ::= `[` ArgType {`,` ArgType} `]`
    Definition Classes
    PatternContextSensitive
  23. def types(): List[Global.Tree]

    Types ::= Type {`,` Type}
    Definition Classes
    PatternContextSensitive