JavaParser

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

abstract def freshName(prefix: String): Name

abstract def freshTermName(prefix: String): TermName

abstract def freshTypeName(prefix: String): TypeName

implicit abstract def i2p(offset: Int): Position

abstract val in: JavaScanner

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

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (JavaParser, 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[Tree], cdef: ClassDef): List[Tree]

def annotation(): Unit

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

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

def annotations(): List[Tree]

def arrayOf(tpt: Tree): AppliedTypeTree

final def asInstanceOf[T0]: T0

def basicType(): Tree

def blankExpr: Ident

def bound(): Tree

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

def clone(): AnyRef

def compilationUnit(): Tree

CompilationUnit ::= [package QualId semi] TopStatSeq

def convertToTypeId(tree: Tree): Tree

Convert (qual)ident to type identifier

def definesInterface(token: Int): Boolean

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

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

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

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

def ensuring(cond: Boolean): JavaParser

def enumConst(enumType: Tree): ValDef

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorPatternTree: Ident

def errorTermTree: Literal

def errorTypeTree: TypeTree

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

Parse a sequence of field declarations, separated by commas.

def finalize(): Unit

def formalParam(): ValDef

def formalParams(): List[ValDef]

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def ident(): Name

def identForType(): TypeName

def importCompanionObject(cdef: ClassDef): Tree

def importDecl(): List[Tree]

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: ⇒ Tree): 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: ⇒ Tree): Tree

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

def interfacesOpt(): List[Tree]

final def isInstanceOf[T0]: Boolean

def javaDot(name: Name): Tree

def javaLangDot(name: Name): Tree

def javaLangObject(): Tree

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

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

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

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

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

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

Creates an actual Parens node (only used during parsing.

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

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

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

def methodBody(): Tree

def modifiers(inInterface: Boolean): Modifiers

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optArrayBrackets(tpt: Tree): Tree

def optThrows(): Unit

def parse(): Tree

this is the general parse method

def posToReport: Int

def qualId(): RefTree

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

val self: Any

val self: Any

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, skipIt: Boolean): Unit

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

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

def toString(): String

def typ(): Tree

def typeArgs(t: Tree): Tree

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

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

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

def typeParam(): TypeDef

def typeParams(): List[TypeDef]

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warning(msg: String): Unit

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

def x: JavaParser

def x: JavaParser