Pass

abstract val config: WalkerConfigStorage

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def assert(cond: Boolean, data: Any, message: String): Unit

Check the condition and calls Assertable.ice if condition is false.

var changed: Boolean

def clone(): AnyRef

def compatibleFunctions(f1: Function, f2: Function): Boolean

def compatibleWithFunction(f1: Function, retType: ScalarType, params: Seq[Variable]): Boolean

def convertScalar(exp: ScalarExpression, _type: ScalarType): ScalarExpression

def doNothing(): Unit

Default action for leaf processing.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def getArgsTemplate: PassArgumentStorage

final def getClass(): Class[_]

def getCleanBody(in: Option[BlockOperation]): BlockOperation

def getMaxType(t1: ScalarType, t2: ScalarType): ScalarType

def getScalarType(in: Type): ScalarType

def getScalarZero(in: ScalarType): ScalarExpression

def hashCode(): Int

def ice(data: Any, message: String): Nothing

Report internal compilation error and throw RuntimeException.

final def isInstanceOf[T0]: Boolean

def listFromSumTree(in: ScalarExpression): List[ScalarExpression]

Construct a list of terms from a summation/subtraction expression tree.

def make(init: Option[Operation]*): Option[Operation]

def makeBlock(init: Option[Operation]*): Option[BlockOperation]

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def registerOption[T](oname: String, default: T): () ⇒ T

def rerun: Boolean

def reset_changed(): Unit

final def run(in: Program, pargs: PassArgumentStorage): Program

def set_changed(): Unit

def sumTreeFromList(terms: List[ScalarExpression]): ScalarExpression

Construct a summation tree from a list of expressions.

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def walkAccessFunction(in: Option[Function]): Unit

def walkArrayConstant(in: ArrayConstant): (ArrayExpression, Option[Operation])

def walkArrayDeclOperation(in: ArrayDeclOperation): Option[Operation]

def walkArrayExpression(in: ArrayExpression): (ArrayExpression, Option[Operation])

def walkArrayIdxExpression(in: ArrayIdxExpression): (ArrayExpression, Option[Operation])

def walkArrayStructSubscription(in: ArrayStructSubscription): (ArrayExpression, Option[Operation])

def walkArrayType(in: ArrayType): Option[Operation]

def walkArrayVariable(in: ArrayVariableRef): (ArrayExpression, Option[Operation])

def walkArrayVariableInt(in: ArrayVariable): (ArrayExpression, Option[Operation])

All raw variables must be eliminated before leaving the front-end.

def walkAssignment(in: AssignmentOperation): Option[Operation]

def walkBlock(in: BlockOperation): Option[BlockOperation]

def walkBlock(in: Option[BlockOperation]): Option[BlockOperation]

def walkBreak(in: BreakOperation): Option[Operation]

def walkCallExpression(in: CallExpression): (ScalarExpression, Option[Operation])

def walkCallOp(in: CallOperation): Option[Operation]

def walkContinue(in: ContinueOperation): Option[Operation]

def walkConvertExpression(in: ConvertExpression): (ScalarExpression, Option[Operation])

def walkExpression(in: Expression): (Expression, Option[Operation])

def walkExpressionProxy(in: Expression): (Expression, Option[Operation])

def walkFor(in: ForOperation): Option[Operation]

def walkFunction(f: Function): Option[Function]

def walkFunctionArgument(in: Variable): Variable

def walkFunctionArguments(in: Seq[Variable]): Seq[Variable]

def walkFunctionBody(in: Option[BlockOperation]): Option[BlockOperation]

def walkFunctions(in: Traversable[Function]): Traversable[Function]

def walkGlobalConst(c: Variable): Some[Variable]

def walkGlobalConsts(in: Seq[Variable]): Seq[Variable]

def walkGlobalType(t: StructType): Some[StructType]

def walkGlobalTypes(in: Seq[StructType]): Seq[StructType]

def walkGuardExpression(in: ScalarExpression): (ScalarExpression, Option[Operation])

def walkIf(in: IfOperation): Option[Operation]

def walkIntrinsicCallExpression(in: IntrinsicCallExpression): (ScalarExpression, Option[Operation])

def walkIterationVariable(in: ScalarVariableRef): (ScalarVariableRef, Option[Operation])

def walkLValueExpression(in: ScalarExpression with LValue): (ScalarExpression with LValue, Option[Operation])

def walkOperation(in: Operation): Option[Operation]

def walkPENCILOperation(in: Operation with PENCILOperation): Option[Operation]

def walkProgram(program: Program): Program

def walkRange(in: Range): (Range, Option[Operation])

def walkReturn(in: ReturnOperation): Option[Operation]

def walkScalarBinaryExpression(in: ScalarBinaryExpression): (ScalarExpression, Option[Operation])

def walkScalarConstant(in: Constant with ScalarExpression): (ScalarExpression, Option[Operation])

def walkScalarExpression(in: ScalarExpression): (ScalarExpression, Option[Operation])

def walkScalarExpressionProxy(in: ScalarExpression): (ScalarExpression, Option[Operation])

def walkScalarIdxExpression(in: ScalarIdxExpression): (ScalarExpression, Option[Operation])

def walkScalarStructSubscription(in: ScalarStructSubscription): (ScalarExpression, Option[Operation])

def walkScalarTernaryExpression(in: TernaryExpression): (ScalarExpression, Option[Operation])

def walkScalarUnaryExpression(in: ScalarUnaryExpression): (ScalarExpression, Option[Operation])

def walkScalarVariable(in: ScalarVariableRef): (ScalarExpression, Option[Operation])

def walkScalarVariableInt(in: ScalarVariable): (ScalarExpression, Option[Operation])

All raw variables must be eliminated before leaving the front-end.

def walkSizeofExpression(in: SizeofExpression): (ScalarExpression, Option[Operation])

def walkWhile(in: WhileOperation): Option[Operation]