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
  • noSeq
  • outPattern
  • seqOK
  • xmlSeqOK

object outPattern extends PatternContextSensitive

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

Source
Parsers.scala
Linear Supertypes
PatternContextSensitive, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. outPattern
  2. PatternContextSensitive
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. def annotType(): Global.Tree 

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

    ArgType       ::=  Type
    Definition Classes
    outPattern → PatternContextSensitive
  3. def compoundType(): Global.Tree 

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

    InfixType ::= CompoundType {id [nl] CompoundType}
    Definition Classes
    PatternContextSensitive
  8. def infixTypeRest(t: Global.Tree, mode: InfixMode.Value): Global.Tree
    Definition Classes
    PatternContextSensitive
  9. def simpleType(): Global.Tree 

    SimpleType       ::=  SimpleType TypeArgs
                   |  SimpleType `#' Id
                   |  StableId
                   |  Path `.' type
                   |  `(' Types `)'
                   |  WildcardType
    Definition Classes
    PatternContextSensitive
  10. def simpleTypeRest(t: Global.Tree): Global.Tree
    Definition Classes
    PatternContextSensitive
  11. def typ(): Global.Tree 

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

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

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