DownStepExpression

abstract def compiledDPath: CompiledDPath

abstract def stepElementDefs: Seq[DPathElementCompileInfo]

abstract def text: String

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def LV[T](sym: Symbol)(body: ⇒ T): OOLAGValue[T]

def NoAnnotationContext: Option[SchemaFileLocation]

def SDE(id: String, args: Any*): Nothing

final def SDE(th: Throwable): Nothing

def SDEButContinue(id: String, args: Any*): Unit

def SDW(warnID: WarnID, fmt: String, args: Any*): Unit

def ThrowSDE: PartialFunction[Throwable, Nothing]

final def areLogging(lvl: Type): Boolean

final def asInstanceOf[T0]: T0

final def assuming(pred: Boolean): Unit

final def checkErrors: Unit

lazy val checkTypeCorrectness: Boolean

lazy val children: List[PredicateExpression]

def clone(): AnyRef

lazy val compileInfo: DPathCompileInfo

def contentReferencedElementInfos: Set[DPathElementCompileInfo]

lazy val conversions: List[RecipeOp]

final var currentOVList: Seq[OOLAGValueBase]

lazy val diagnosticDebugName: String

def diagnostics: Seq[Diagnostic]

def doLogging(lvl: Type, msg: String, args: Seq[Any]): Unit

final lazy val enclosingElementCompileInfos: Seq[DPathElementCompileInfo]

final def eq(arg0: AnyRef): Boolean

def equals(x: Any): Boolean

def error(th: Diagnostic): Unit

final def errors: Seq[Diagnostic]

def finalize(): Unit

final def getClass(): Class[_]

def getDiagnostics: Seq[Diagnostic]

def getLogWriter(): LogWriter

final def getLoggingLevel(): Type

final def hasOOLAGRootSetup: Boolean

final def hasReferenceTo(elem: DPathElementCompileInfo): Boolean

def hashCode(): Int

lazy val inherentType: Kind

Since an expresion can be in a reused group, type, or element, the downward path step may actually represent a step downward to distinct elements that happen to just have the same name/namespace, but they could be different types.

lazy val isAbsolutePath: Boolean

final lazy val isArray: Boolean

def isError: Boolean

lazy val isFirstStep: Boolean

final def isInstanceOf[T0]: Boolean

lazy val isLastStep: Boolean

lazy val isTypeCorrect: Boolean

def leafContentLengthReferencedElements: Set[DPathElementCompileInfo]

Override where we traverse/access elements.

def leafValueLengthReferencedElements: Set[DPathElementCompileInfo]

final macro def log(lvl: Type, msg: String, args: Any*): Unit

lazy val logID: String

var logLevel: Maybe[Type]

var logWriter: Maybe[LogWriter]

final val nArgs: Args

lazy val namespaces: NamespaceBinding

final def ne(arg0: AnyRef): Boolean

final def notYetImplemented(msg: String, args: Any*): Nothing

final def notify(): Unit

final def notifyAll(): Unit

final lazy val oolagContext: OOLAGHost

final def oolagContextViaArgs: Option[OOLAGHost]

def oolagError(th: Diagnostic): Unit

final def oolagParent: OOLAGHost

def oolagWarn(th: Diagnostic): Unit

final lazy val optOolagContext: Option[OOLAGHost]

final lazy val parent: Expression

final lazy val parentOpt: Option[Expression]

lazy val path: String

final def polymorphicExpressionErrorDetails(context: Expression): (Expression, String)

lazy val positionInStepsSequence: Int

val pred: Option[PredicateExpression]

lazy val priorStep: Option[StepExpression]

def qNameForProperty(local: String, ns: NS): GlobalQName

def relPathErr(): Nothing

lazy val relPathParent: RelativePathExpression

def removePrefix(prefixedValue: String): String

final def requiredEvaluations(lv: OOLAGValueBase): Unit

final def requiredEvaluations(arg: ⇒ Any): Unit

def resolveQName(qnString: String): RefQName

def resolveRef(qnameString: String): RefQName

final lazy val rootElement: DPathElementCompileInfo

final def schemaDefinitionError(str: String, args: Any*): Nothing

def schemaDefinitionErrorButContinue(str: String, args: Any*): Unit

def schemaDefinitionErrorDueToPropertyValue(propertyName: String, propertyValue: String, propertyLocation: LookupLocation, otherPropertyLocation: LookupLocation, str: String, args: Any*): Nothing

final macro def schemaDefinitionUnless(testThatWillThrowIfFalse: Boolean, str: String, args: Any*): Unit

macro def schemaDefinitionWarningUnless(warnID: WarnID, testThatWillWarnIfFalse: Boolean, str: String, args: Any*): Unit

macro def schemaDefinitionWarningWhen(warnID: WarnID, testThatWillWarnIfTrue: Boolean, str: String, args: Any*): Unit

final macro def schemaDefinitionWhen(testThatWillThrowIfTrue: Boolean, str: String, args: Any*): Unit

lazy val schemaFileLocation: SchemaFileLocation

TODO: get more precise line and column information for pointing at sub-regions of large DPath expressions

def setContextsForChildren(context: OOLAGHost = this): Unit

def setLogWriter(lw: LogWriter): Unit

def setLoggingLevel(level: Type): Unit

final def setOOLAGContext(oolagContextArg: OOLAGHost): Unit

val step: String

final lazy val stepElements: Seq[DPathElementCompileInfo]

lazy val stepQName: StepQName

def subset(testThatWillThrowIfFalse: Boolean, msg: String, args: Any*): Unit

def subsetError(msg: String, args: Any*): Nothing

def suggestedPossiblePrefixes(ns: NS): Seq[String]

Used when there is no match as part of error diagnostic message.

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

lazy val targetType: Kind

The target type is defined for simple types.

def targetTypeForSubexpression(subexp: Expression): ArrayIndex.type

def toString(): String

final def toss(th: Throwable): Nothing

lazy val tunable: DaffodilTunables

lazy val unqualifiedPathStepPolicy: UnqualifiedPathStepPolicy

def valueReferencedElementInfos: Set[DPathElementCompileInfo]

def verifyQNames(cis: Seq[DPathElementCompileInfo]): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warn(th: Diagnostic): Unit

final def warnings: Seq[Diagnostic]

final lazy val wholeExpression: Expression

final lazy val wholeExpressionText: String

macro def withLoggingLevel[S](newLevel: Type)(body: ⇒ S): Unit