SeqContextSensitive

abstract def interceptStarPattern(top: Tree): Option[Tree]

Returns Some(tree) if it finds a star and prematurely ends parsing.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def annotType(): Tree

 AnnotType        ::=  SimpleType {Annotation}

def argType(): Tree

 ArgType       ::=  Type

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compoundType(): Tree

 CompoundType ::= AnnotType {with AnnotType} [Refinement]
               |  Refinement

def compoundTypeRest(t: Tree): Tree

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def functionArgType(): Tree

def functionTypes(): List[Tree]

final def getClass(): Class[_]

def hashCode(): Int

def infixType(mode: Value): Tree

 InfixType ::= CompoundType {id [nl] CompoundType}

def infixTypeRest(t: Tree, mode: Value): Tree

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pattern(): Tree

 Pattern  ::=  Pattern1 { `|' Pattern1 }
 SeqPattern ::= SeqPattern1 { `|' SeqPattern1 }

def pattern1(): Tree

 Pattern1    ::= varid `:' TypePat
               |  `_' `:' TypePat
               |  Pattern2
 SeqPattern1 ::= varid `:' TypePat
               |  `_' `:' TypePat
               |  [SeqPattern2]

def pattern2(): Tree

 Pattern2    ::=  varid [ @ Pattern3 ]
               |   Pattern3
 SeqPattern2 ::=  varid [ @ SeqPattern3 ]
               |   SeqPattern3

def pattern3(): Tree

 Pattern3    ::= SimplePattern
               |  SimplePattern {Id [nl] SimplePattern}
 SeqPattern3 ::= SeqSimplePattern [ `*' | `?' | `+' ]
               |  SeqSimplePattern {Id [nl] SeqSimplePattern}

def patterns(): List[Tree]

 Patterns ::= Pattern { `,' Pattern }
 SeqPatterns ::= SeqPattern { `,' SeqPattern }

def simplePattern(): Tree

 SimplePattern    ::= varid
                   |  `_'
                   |  literal
                   |  XmlPattern
                   |  StableId  [TypeArgs] [`(' [SeqPatterns] `)']
                   |  `(' [Patterns] `)'
 SimpleSeqPattern ::= varid
                   |  `_'
                   |  literal
                   |  XmlPattern
                   |  `<' xLiteralPattern
                   |  StableId [TypeArgs] [`(' [SeqPatterns] `)']
                   |  `(' [SeqPatterns] `)'

def simpleType(): Tree

 SimpleType       ::=  SimpleType TypeArgs
                    |  SimpleType `#' Id
                    |  StableId
                    |  Path `.' type
                    |  `(' Types `)'
                    |  WildcardType

def simpleTypeRest(t: Tree): Tree

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def typ(): Tree

 Type ::= InfixType `=>' Type
        | `(' [`=>' Type] `)' `=>' Type
        | InfixType [ExistentialClause]
 ExistentialClause ::= forSome `{' ExistentialDcl {semi ExistentialDcl}} `}'
 ExistentialDcl    ::= type TypeDcl | val ValDcl

def typeArgs(): List[Tree]

 TypeArgs    ::= `[' ArgType {`,' ArgType} `]'

def types(): List[Tree]

 Types ::= Type {`,' Type}

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit