JavaUnitParser

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (JavaUnitParser, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def accept(token: Int): Int

Consume one token of the specified type, or signal an error if it is not there.

def acceptClosingAngle(): Unit

def addCompanionObject(statics: List[Global.Tree], cdef: Global.ClassDef): List[Global.Tree]

def annotation(): Unit

Annotation ::= TypeName [( AnnotationArgument {, AnnotationArgument} )]

def annotationDecl(mods: Global.Modifiers): List[Global.Tree]

def annotationParents: collection.immutable.List[Global.Select]

def annotations(): List[Global.Tree]

def arrayOf(tpt: Global.Tree): Global.AppliedTypeTree

final def asInstanceOf[T0]: T0

def basicType(): Global.Tree

def blankExpr: Global.Ident

def bound(): Global.Tree

def classDecl(mods: Global.Modifiers): List[Global.Tree]

def clone(): AnyRef

def compilationUnit(): Global.Tree

CompilationUnit ::= [package QualId semi] TopStatSeq

def convertToTypeId(tree: Global.Tree): Global.Tree

Convert (qual)ident to type identifier

def definesInterface(token: Int): Boolean

def deprecationWarning(off: Int, msg: String): Unit

final def dropAnyBraces[T](body: ⇒ T): T

def ensuring(cond: (JavaUnitParser) ⇒ Boolean, msg: ⇒ Any): JavaUnitParser

def ensuring(cond: (JavaUnitParser) ⇒ Boolean): JavaUnitParser

def ensuring(cond: Boolean, msg: ⇒ Any): JavaUnitParser

def ensuring(cond: Boolean): JavaUnitParser

def enumConst(enumType: Global.Tree): Global.ValDef

def enumDecl(mods: Global.Modifiers): List[Global.Tree]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorPatternTree: Global.Ident

def errorTermTree: Global.Literal

def errorTypeTree: Global.TypeTree

def fieldDecls(pos: Global.Position, mods: Global.Modifiers, tpt: Global.Tree, name: Global.Name): List[Global.Tree]

Parse a sequence of field declarations, separated by commas.

def finalize(): Unit

def formalParam(): Global.ValDef

def formalParams(): List[Global.ValDef]

def formatted(fmtstr: String): String

def freshName(prefix: String): Global.Name

def freshTermName(prefix: String): Global.TermName

def freshTypeName(prefix: String): Global.TypeName

final def getClass(): Class[_]

def hashCode(): Int

implicit def i2p(offset: Int): Global.Position

def ident(): Global.Name

def identForType(): Global.TypeName

def importCompanionObject(cdef: Global.ClassDef): Global.Tree

def importDecl(): List[Global.Tree]

val in: JavaParsers.JavaUnitScanner

final def inBraces[T](body: ⇒ T): T

final def inBracesOrError[T](body: ⇒ T, alt: T): T

final def inBracesOrNil[T](body: ⇒ List[T]): List[T]

final def inBracesOrUnit[T](body: ⇒ Global.Tree): Global.Tree

final def inBrackets[T](body: ⇒ T): T

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.

final def inParensOrError[T](body: ⇒ T, alt: T): T

final def inParensOrNil[T](body: ⇒ List[T]): List[T]

final def inParensOrUnit[T](body: ⇒ Global.Tree): Global.Tree

def interfaceDecl(mods: Global.Modifiers): List[Global.Tree]

def interfacesOpt(): List[Global.Tree]

final def isInstanceOf[T0]: Boolean

def javaDot(name: Global.Name): Global.Tree

def javaLangDot(name: Global.Name): Global.Tree

def javaLangObject(): Global.Tree

def makeCompanionObject(cdef: Global.ClassDef, statics: List[Global.Tree]): Global.Tree

def makeConstructor(formals: List[Global.Tree]): Global.DefDef

def makePackaging(pkg: Global.RefTree, stats: List[Global.Tree]): Global.PackageDef

def makeParam(name: Global.TermName, tpt: Global.Tree): Global.ValDef

def makeParam(name: String, tpt: Global.Tree): Global.ValDef

final def makeParens(body: ⇒ List[Global.Tree]): Global.Parens

Creates an actual Parens node (only used during parsing.

def makeSyntheticParam(count: Int, tpt: Global.Tree): Global.ValDef

def makeTemplate(parents: List[Global.Tree], stats: List[Global.Tree]): Global.Template

def memberDecl(mods: Global.Modifiers, parentToken: Int): List[Global.Tree]

def methodBody(): Global.Tree

def modifiers(inInterface: Boolean): Global.Modifiers

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optArrayBrackets(tpt: Global.Tree): Global.Tree

def optThrows(): Unit

def parse(): Global.Tree

this is the general parse method

def posToReport: Int

def qualId(): Global.RefTree

def repsep[T <: Global.Tree](p: () ⇒ T, sep: Int): List[T]

def skip(): Unit

def skipAhead(): Unit

skip parent or brace enclosed sequence of things

def skipTo(tokens: Int*): Unit

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

def syntaxError(pos: Int, msg: String): Unit

def syntaxError(pos: Int, msg: String, skipIt: Boolean): Unit

def syntaxError(msg: String, skipIt: Boolean): Unit

def termDecl(mods: Global.Modifiers, parentToken: Int): List[Global.Tree]

def toString(): String

def typ(): Global.Tree

def typeArgs(t: Global.Tree): Global.Tree

def typeBody(leadingToken: Int, parentName: Global.Name): (List[Global.Tree], List[Global.Tree])

def typeBodyDecls(parentToken: Int, parentName: Global.Name): (List[Global.Tree], List[Global.Tree])

def typeDecl(mods: Global.Modifiers): List[Global.Tree]

def typeParam(): Global.TypeDef

def typeParams(): List[Global.TypeDef]

val unit: Global.CompilationUnit

def varDecl(pos: Global.Position, mods: Global.Modifiers, tpt: Global.Tree, name: Global.TermName): Global.ValDef

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warning(pos: Int, msg: String): Unit

def warning(msg: String): Unit

def →[B](y: B): (JavaUnitParser, B)

val self: Any

val self: Any

def x: JavaUnitParser

def x: JavaUnitParser