A2bTests

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object MultipleEntity extends Entity with ErrorEntity with Product with Serializable

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

object UnknownEntity extends Entity with ErrorEntity with Product with Serializable

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

def angles(d: Doc): Doc

def any: PackratParser[Char]

def any(a: Any): Doc

implicit def anyToPrettyPrintable(a: Any): PrettyPrintable

def artefact: String

The name of this artefact.

final def asInstanceOf[T0]: T0

def assert(o: Option[String]): Unit

def assert(o: Option[String], clue: Any): Unit

def assert(condition: Boolean, clue: Any): Unit

def assert(condition: Boolean): Unit

lazy val assignment: Parser[Assignment]

def assume(o: Option[String]): Unit

def assume(o: Option[String], clue: Any): Unit

def assume(condition: Boolean, clue: Any): Unit

def assume(condition: Boolean): Unit

def backslash: Doc

lazy val basetype: (Expression) ⇒ Type

The actual type of an expression following type aliases.

lazy val block: Parser[Block]

def blockToDoc(b: Block, beginend: Boolean = false): Doc

Pretty-print a block, omitting the BEGIN if there are no statements.

lazy val booleanType: BuiltinType

Built-in Boolean type.

def braces(d: Doc): Doc

def bracket(inner: PrettyOperatorExpression, outer: PrettyOperatorExpression, side: Side): Doc

def brackets(d: Doc): Doc

def cancel(cause: Throwable): Nothing

def cancel(message: String, cause: Throwable): Nothing

def cancel(message: String): Nothing

def cancel(): Nothing

lazy val caseStatement: Parser[CaseStatement]

def caseToDoc(s: CaseStatement): Doc

lazy val cases: Parser[List[Case]]

def casesToDoc(l: List[Case]): Doc

def cat(ds: Seq[Doc]): Doc

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

var challengeFlag: Boolean

val challengeFlagDefault: Boolean

implicit def char(c: Char): Doc

def check(n: SourceASTNode): Unit

Check an AST node for semantic errors.

def checkargs(args: Array[String], emitter: Emitter): Array[String]

Process the command-line arguments and return an array of the input file names if processing should continue, None otherwise.

def clone(): AnyRef

def colon: Doc

def comma: Doc

lazy val comment: PackratParser[Any]

def commit[T](p: ⇒ Parser[T]): Parser[T]

def compile(args: Array[String], console: Console): String

lazy val condition: Parser[Condition with Serializable]

lazy val conditions: Parser[List[Condition with Serializable]]

implicit def constToTupleFunction2[A, B, R](r: (A, B) ⇒ R): (~[A, B]) ⇒ R

implicit def constToTupleFunction3[A, B, C, R](r: (A, B, C) ⇒ R): (~[~[A, B], C]) ⇒ R

implicit def constToTupleFunction4[A, B, C, D, R](r: (A, B, C, D) ⇒ R): (~[~[~[A, B], C], D]) ⇒ R

implicit def constToTupleFunction5[A, B, C, D, E, R](r: (A, B, C, D, E) ⇒ R): (~[~[~[~[A, B], C], D], E]) ⇒ R

implicit def constToTupleFunction6[A, B, C, D, E, F, R](r: (A, B, C, D, E, F) ⇒ R): (~[~[~[~[~[A, B], C], D], E], F]) ⇒ R

lazy val constdecl: Parser[ConstDecl]

lazy val constdeclsection: Parser[List[ConstDecl]]

lazy val constrainedInt: PackratParser[Int]

def consumeast(ast: ModuleDecl, console: Console, emitter: Emitter): Unit

Consume the AST.

implicit def convertToEqualizer(left: Any): Equalizer

lazy val declarations: PackratParser[List[Declaration]]

def declarationsDef: PackratParser[List[Declaration with Serializable]]

def declsToDoc(ds: List[Declaration]): Doc

def declsection(d: Declaration): String

lazy val decltype: (TypeDecl) ⇒ Type

The built-in type associated with a type declaration.

val defaultIndent: Int

val defaultWidth: Int

def defenv: Environment

The default environment.

def defenvPairs: List[(String, Entity)]

def define(env: Environment, i: String, e: Entity): Environment

lazy val deftype: (TypeDef) ⇒ Type

The type given by a type definition.

def deftypeDef: (TypeDef) ⇒ Type

def dosanitisation: Boolean

Flag to decide whether to sanitise the output before comparison of test results with expected results (see sanitise method).

def dot: Doc

def dquote: Doc

def dquotes(d: Doc): Doc

def driver(args: Array[String], console: Console, emitter: Emitter): Unit

Custom driver for section tagging and challenge mode for errors.

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

lazy val elsif: PackratParser[(Expression, Block)]

lazy val elsifs: Parser[List[(Expression, Block)]]

def empty: Doc

def enclose(l: Doc, d: Doc, r: Doc): Doc

def enter(env: Environment): Environment

lazy val entity: (Identifier) ⇒ Entity

The program entity referred to by an identifier definition or use.

def entityFromDecl(n: IdnDef, i: String): Entity

The entity for an identifier definition as given by its declaration context.

lazy val env: Chain[SourceASTNode, Environment]

The environment containing bindings for all identifiers visible at the given node.

def envin(in: (SourceASTNode) ⇒ Environment): ==>[SourceASTNode, Environment]

def envout(out: (SourceASTNode) ⇒ Environment): ==>[SourceASTNode, Environment]

final def eq(arg0: AnyRef): Boolean

def equal: Doc

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

final def execute: Unit

final def execute(testName: String, configMap: Map[String, Any], color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

lazy val expconst: (Expression) ⇒ Boolean

Is an expression expected to be constant or not? Either the expression is the root of an expected constant expression or its parent expression is expected to be constant.

def expectResult(expected: Any)(actual: Any): Unit

def expectResult(expected: Any, clue: Any)(actual: Any): Unit

def expectedTestCount(filter: Filter): Int

lazy val expression: Parser[Expression]

lazy val exptype: (Expression) ⇒ Type

The type expected of an expression as defined by its context.

def exptypeDef: (Expression) ⇒ Type

The type expected of an expression as defined by its context.

lazy val factor: PackratParser[Expression]

def fail(cause: Throwable): Nothing

def fail(message: String, cause: Throwable): Nothing

def fail(message: String): Nothing

def fail(): Nothing

def failure(msg: String): Parser[Nothing]

lazy val falseConstant: IntegerValue

Built-in false constant.

def filetests(name: String, path: String, srcext: String, resext: String, optinext: Option[String] = None, indefault: String = "", argslist: List[Array[String]] = List (Array ())): Unit

Make tests that process the files in path.

def fillcat(ds: Seq[Doc]): Doc

def fillsep(ds: Seq[Doc], sep: Doc): Doc

def fillsep(ds: Seq[Doc]): Doc

def finalize(): Unit

lazy val forStatement: Parser[ForStatement]

def forToDoc(s: ForStatement): Doc

lazy val forVar: Parser[IdnExp]

def forwslash: Doc

final def getClass(): Class[_]

def group(d: Doc): Doc

def guard[T](p: ⇒ Parser[T]): Parser[T]

def handleWhiteSpace(in: Input): Int

def handleWhiteSpace(source: CharSequence, offset: Int): Int

def hashCode(): Int

def hcat(ds: Seq[Doc]): Doc

var helpFlag: Boolean

val helpFlagDefault: Boolean

def hsep(ds: Seq[Doc], sep: Doc): Doc

def hsep(ds: Seq[Doc]): Doc

lazy val ident: Parser[String]

def idlistToDoc(ids: List[IdnDef]): Doc

lazy val idndef: Parser[IdnDef]

lazy val idndeflist: Parser[List[IdnDef]]

lazy val idntype: (IdnUse) ⇒ Type

The type of the entity denoted by an identifier use.

def idntypeDef: (IdnUse) ⇒ Type

lazy val idnuse: Parser[IdnUse]

lazy val ifStatement: Parser[IfStatement]

def ifToDoc(s: IfStatement): Doc

def ignore(testName: String, testTags: Tag*)(testFun: ⇒ Unit): Unit

implicit def info: Informer

def initialiseSemanticAnalysis: Unit

Perform initialisation of semantic analysis that is necessary before processing an AST.

var input: String

lazy val integerType: BuiltinType

Built-in integer type.

def intercept[T <: AnyRef](f: ⇒ Any)(implicit manifest: Manifest[T]): T

lazy val intexp: Parser[IntExp]

def isBoolean(e: Type): Boolean

Return true if the given type is Boolean or an unknown type.

def isCompatible(tipe: Type, exptype: Type): Boolean

Compatibility of types.

def isConstant(e: Entity): Boolean

Return true if the entity is erroneous or is a constant.

def isDefinedInEnv(env: Environment, i: String): Boolean

def isDefinedInInner(env: Environment, i: String): Boolean

def isDefinedInOuter(env: Environment, i: String): Boolean

def isDefinedInScope(scope: Scope, i: String): Boolean

def isDefinedInScope(env: Environment, i: String): Boolean

def isError(e: Entity): Boolean

Return true if the entity is an error, false otherwise.

final def isInstanceOf[T0]: Boolean

def isInteger(e: Type): Boolean

Return true if the given type is integer or an unknown type.

def isLvalue(l: Expression): Boolean

Return true if the expression can legally appear on the left-hand side of an assignment statement.

def isModule(e: Entity): Boolean

Return true if the entity is erroneous or is a module.

def isRvalue(r: IdnExp): Boolean

Return true if the identifier is an r-value and hence its value can be used (ie.

def isType(e: Entity): Boolean

Return true if the entity is erroneous or is a type.

def isVariable(e: Entity): Boolean

Return true if the entity is erroneous or is a variable.

lazy val isconst: (Expression) ⇒ Boolean

Is an expression constant or not? Unknown entities are constant.

lazy val kase: Parser[Case]

lazy val keyword: Parser[String]

def keywordStrings: List[String]

def keywords(ext: Regex, kws: List[String]): Parser[String]

def langle: Doc

def langlevel: Int

def lbrace: Doc

def lbracket: Doc

def leave(env: Environment): Environment

lazy val lhs: PackratParser[Expression]

def lhsDef: PackratParser[Expression]

def line: Doc

def linebreak: Doc

def list[T](l: List[T], prefix: String, elemToDoc: (T) ⇒ Doc, sep: Doc, sepfn: (Seq[Doc], Doc) ⇒ Doc): Doc

implicit def literal(s: String): Parser[String]

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

def lookup(env: Environment, i: String, e: Entity, scope: Boolean): Entity

def lparen: Doc

def lsep(ds: Seq[Doc], sep: Doc): Doc

def lsep2(ds: Seq[Doc], sep: Doc): Doc

def lterm(ds: Seq[Doc], term: Doc): Doc

def main(args: Array[String]): Unit

def makeast(reader: Reader, filename: String, emitter: Emitter): Either[ModuleDecl, String]

implicit def markup: Documenter

val maxlanglevel: Int

The maximum language level we support.

def memo[T](p: Parser[T]): PackratParser[T]

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

def mktests(proglang: String): Unit

Make the tests for a given language subset.

lazy val moduledecl: Parser[ModuleDecl]

lazy val namedtypedef: Parser[NamedType]

final def ne(arg0: AnyRef): Boolean

def nest(d: Doc, j: Indent): Doc

def nestedSuites: IndexedSeq[Suite]

def noparens(inner: PrettyOperatorExpression, outer: PrettyOperatorExpression, side: Side): Boolean

def not[T](p: ⇒ Parser[T]): Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

def optSectionToDoc(section: String, optds: Option[List[Declaration]]): Doc

lazy val optelse: Parser[Option[Block]]

def parens(d: Doc): Doc

def parse[T](p: Parser[T], in: Reader): ParseResult[T]

def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

def parseAndPosition[T](f: (Input) ⇒ ParseResult[T], in: Input): ParseResult[T]

implicit def parseResultToTuple2[A, B](p: Parser[~[A, B]]): PackratParser[(A, B)]

implicit def parseResultToTuple3[A, B, C](p: Parser[~[~[A, B], C]]): PackratParser[(A, B, C)]

implicit def parseResultToTuple4[A, B, C, D](p: Parser[~[~[~[A, B], C], D]]): PackratParser[(A, B, C, D)]

implicit def parseResultToTuple5[A, B, C, D, E](p: Parser[~[~[~[~[A, B], C], D], E]]): PackratParser[(A, B, C, D, E)]

implicit def parseResultToTuple6[A, B, C, D, E, F](p: Parser[~[~[~[~[~[A, B], C], D], E], F]]): PackratParser[(A, B, C, D, E, F)]

def parseString[T](parser: Parser[T], str: String): Either[T, String]

def parseWhitespace(in: Input): ParseResult[Any]

lazy val parser: PackratParser[ModuleDecl]

implicit def parser2packrat[T](p: ⇒ Parser[T]): PackratParser[T]

var parsingWhitespace: Boolean

def pending: PendingNothing

def pendingUntilFixed(f: ⇒ Unit): Unit

def phrase[T](p: Parser[T]): PackratParser[T]

def plist(l: List[PrettyPrintable], prefix: String, elemToDoc: (PrettyPrintable) ⇒ Doc, sep: Doc, sepfn: (Seq[Doc], Doc) ⇒ Doc): Doc

def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

var pprintastFlag: Boolean

val pprintastFlagDefault: Boolean

def pretty(d: Doc, w: Width): Layout

def pretty(p: PrettyPrintable): Layout

def pretty_any(a: Any): Layout

var printastFlag: Boolean

val printastFlagDefault: Boolean

def process(ast: ModuleDecl, console: Console, emitter: Emitter): Boolean

Process the given abstract syntax tree.

def processargs(args: List[String]): Boolean

def processast(ast: ModuleDecl, console: Console, emitter: Emitter): ModuleDecl

Process the AST, returning the new one.

def rangle: Doc

def rbrace: Doc

def rbracket: Doc

implicit def regex(r: Regex): Parser[String]

def regexnows(r: Regex): Parser[String]

def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def rerunner: Option[String]

def resetEnvironments: Unit

def resetflags(): Unit

def result[T](v: ⇒ T): Parser[T]

lazy val rootconstexp: (Expression) ⇒ Boolean

Is this expression the root of what is expected to be a constant expression? At this level only expressions on the RHS of a constant declaration have this property.

def rootconstexpDef: (Expression) ⇒ Boolean

def rootenv(bindings: (String, Entity)*): Environment

def rparen: Doc

def run(testName: Option[String], args: Args): Unit

final def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

def runNestedSuites(args: Args): Unit

def runTest(testName: String, args: Args): Unit

def runTests(testName: Option[String], args: Args): Unit

def sanitise(s: String): String

Sanitise the output from a test.

def section(emitter: Emitter, name: String): Unit

Output a section heading so that the output can be split later.

def semi: Doc

def semisep(l: List[SourceASTNode], sep: Doc = semi): Doc

Pretty-print a nested list of nodes separated by sep (default: semi colon) and line breaks.

def sep(ds: Seq[Doc]): Doc

lazy val simpexp: PackratParser[Expression]

def skipWhitespace: Boolean

def softbreak: Doc

def softline: Doc

def space: Doc

def spaces(n: Int): Doc

def squote: Doc

def squotes(d: Doc): Doc

def ssep(ds: Seq[Doc], sep: Doc): Doc

lazy val statement: PackratParser[Statement]

def statementDef: PackratParser[Statement]

lazy val statementSequence: Parser[Block]

lazy val statements: Parser[Block]

lazy val step: Parser[Option[Expression]]

def sterm(ds: Seq[Doc], term: Doc): Doc

def string(s: String): Doc

def stringToInt(s: String): Either[Int, String]

final val styleName: String

def success[T](v: T): Parser[T]

def suiteId: String

def suiteName: String

def surround(d: Doc, b: Doc): Doc

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

def tags: Map[String, Set[String]]

def tasklevel: Int

lazy val term: PackratParser[Expression]

def test(testName: String, testTags: Tag*)(testFun: ⇒ Unit): Unit

def testNames: Set[String]

def testsFor(unit: Unit): Unit

implicit def text(t: String): Doc

lazy val tipe: (Expression) ⇒ Type

The type of an expression.

def tipeDef: (Expression) ⇒ Type

def toDoc(n: SourceASTNode): Doc

def toParenDoc(e: PrettyExpression): Doc

def toString(): String

lazy val trueConstant: IntegerValue

Built-in true constant.

lazy val typebasetype: (Type) ⇒ Type

The actual type that a user type denotes.

lazy val typedecl: Parser[TypeDecl]

lazy val typedeclsection: Parser[List[TypeDecl]]

lazy val typedef: PackratParser[TypeDef]

def typedefDef: PackratParser[TypeDef]

lazy val unknownType: BuiltinType

A type that is unknown, eg because the typed thing is erroneously defined.

def usageMessage: String

def value(v: Any): Doc

lazy val value: (Expression) ⇒ Int

What is the value of an integer expression? Only needs to be valid if the expression is an integer constant (see isconst above) and is defined (eg, no divide by zero.

lazy val vardecl: Parser[VarDecl]

lazy val vardeclsection: Parser[List[VarDecl]]

def vcat(ds: Seq[Doc]): Doc

def vsep(ds: Seq[Doc], sep: Doc): Doc

def vsep(ds: Seq[Doc]): Doc

final def wait(): Unit

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

final def wait(arg0: Long): Unit

lazy val whileStatement: Parser[WhileStatement]

val whiteSpace: Regex

lazy val whitespaceParser: PackratParser[Any]

def withClue[T](clue: Any)(fun: ⇒ T): T

def withFixture(test: NoArgTest): Unit

def wrap[T, U](p: ⇒ Parser[T], f: (T) ⇒ Either[U, String]): Parser[U]

def expect(expected: Any)(actual: Any): Unit

def expect(expected: Any, clue: Any)(actual: Any): Unit

def lastNoSuccess: NoSuccess

def lastNoSuccess_=(x: NoSuccess): Unit

def product(p: Any): Doc