avail/avail.descriptor.representation/AbstractDescriptor

AbstractDescriptor

AbstractDescriptor is the base descriptor type. An AvailObject contains a descriptor, to which it delegates nearly all of its behavior. That allows interesting operations like effective type mutation (within a language that does not support it directly, such as Java). It also allows multiple representations of equivalent objects, such as more than one representation for the tuple <1,2,3>. It can be represented as an AvailObject using either an ObjectTupleDescriptor, a ByteTupleDescriptor, a NybbleTupleDescriptor, or a TreeTupleDescriptor. It could even be an IndirectionDescriptor if there is another object that already represents this tuple.

In particular, AbstractDescriptor is abstract and has two children, the class Descriptor and the class IndirectionDescriptor, the latter of which has no classes. When a new operation is added in an ordinary descriptor class (below Descriptor), it should be added with an @Override annotation. A quick fix on that error allows an implementation to be generated in AbstractDescriptor, which should be converted manually to an abstract method. That will make both Descriptor and IndirectionDescriptor (and all subclasses of Descriptor except the one in which the new method first appeared) to indicate an error, in that they need to implement this method. A quick fix can add it to Descriptor, after which it can be tweaked to indicate a runtime error. Another quick fix adds it to IndirectionDescriptor, and copying nearby implementations leads it to invoke the non "o_" method in AvailObject. This will show up as an error, and one more quick fix can generate the corresponding method in AvailObject whose implementation, like methods near it, extracts the AvailObject.descriptor and invokes upon it the original message (that started with "o_"), passing this as the first argument. Code generation will eventually make this relatively onerous task more tractable and less error prone.

Author

Mark van Gulik

Todd L Smith

Parameters

mutability

The Mutability of the new descriptor.

typeTag

The TypeTag to embed in the new descriptor.

objectSlotsEnumClass

The Java Class which is a subclass of ObjectSlotsEnum and defines this object's object slots layout, or null if there are no object slots.

integerSlotsEnumClass

The Java Class which is a subclass of IntegerSlotsEnum and defines this object's object slots layout, or null if there are no integer slots.

Types

Companion

object Companion

DebuggerObjectSlots

enum DebuggerObjectSlots : Enum<AbstractDescriptor.DebuggerObjectSlots> , ObjectSlotsEnum

An ObjectSlotsEnum that can be passed as a dummy, with explicit ordinal and name when constructing debugger views of objects.

Functions

checkWriteForField

fun checkWriteForField(e: AbstractSlotsEnum)

Ensure that the specified field is writable.

create

inline fun create(indexedSlotCount: Int = 0, init: AvailObject.() -> Unit = { }): AvailObject

Create a new object whose descriptor is the receiver, and which has the specified number of indexed (variable) slots.

inline fun create( indexedObjectSlots: Int, indexedIntSlots: Int, init: AvailObject.() -> Unit = { }): AvailObject

Create a new object whose descriptor is the receiver, and which has the specified number of indexed (variable) slots for objects and ints.

createImmutable

inline fun createImmutable(indexedSlotCount: Int = 0, init: AvailObject.() -> Unit): AvailObject

Create a new object whose descriptor is the receiver, and which has the specified number of indexed (variable) slots.

createShared

inline fun createShared(indexedSlotCount: Int = 0, init: AvailObject.() -> Unit): AvailObject

Create a new object whose descriptor is the receiver, and which has the specified number of indexed (variable) slots.

hasVariableIntegerSlots

fun hasVariableIntegerSlots(): Boolean

Can an object using this descriptor have more than the minimum number of integer slots?

hasVariableObjectSlots

fun hasVariableObjectSlots(): Boolean

Can an object using this descriptor have more than the minimum number of object slots?

immutable

abstract fun immutable(): AbstractDescriptor

Answer the immutable version of this descriptor.

maximumIndent

open fun maximumIndent(): Int

Answer how many levels of printing to allow before elision.

mutable

abstract fun mutable(): AbstractDescriptor

Answer the mutable version of this descriptor.

o_AcceptsArgTypesFromFunctionType

abstract fun o_AcceptsArgTypesFromFunctionType(self: AvailObject, functionType: A_Type): Boolean

Answer whether the argument types supported by the specified function type are acceptable argument types for invoking a function whose type is self.

o_AcceptsListOfArgTypes

abstract fun o_AcceptsListOfArgTypes(self: AvailObject, argTypes: List<A_Type>): Boolean

Answer whether these are acceptable argument types for invoking a function whose type is self.

o_AcceptsListOfArgValues

abstract fun o_AcceptsListOfArgValues(self: AvailObject, argValues: List<A_BasicObject>): Boolean

Answer whether these are acceptable arguments for invoking a function whose type is self.

o_AcceptsTupleOfArgTypes

abstract fun o_AcceptsTupleOfArgTypes(self: AvailObject, argTypes: A_Tuple): Boolean

Answer whether these are acceptable argument types for invoking a function that is an instance of self. There may be more entries in the tuple than are required by the function type.

o_AcceptsTupleOfArguments

abstract fun o_AcceptsTupleOfArguments(self: AvailObject, arguments: A_Tuple): Boolean

Answer whether these are acceptable arguments for invoking a function that is an instance of self. There may be more entries in the tuple than are required by the function type.

o_AddBundle

abstract fun o_AddBundle(self: AvailObject, bundle: A_Bundle)

o_AddConstantBinding

abstract fun o_AddConstantBinding( self: AvailObject, name: A_String, constantBinding: A_Variable)

o_AddDefinitionParsingPlan

abstract fun o_AddDefinitionParsingPlan(self: AvailObject, plan: A_DefinitionParsingPlan)

o_AddDependentChunk

abstract fun o_AddDependentChunk(self: AvailObject, chunk: L2Chunk)

Record the fact that the given L2Chunk depends on the object not changing in some way peculiar to the kind of object. Most typically, this is applied to A_Methods, triggering invalidation if A_Definitions are added to or removed from the method, but at some point we may also support slowly-changing variables.

o_AddGrammaticalRestriction

abstract fun o_AddGrammaticalRestriction(self: AvailObject, grammaticalRestriction: A_GrammaticalRestriction)

o_AddImportedName

abstract fun o_AddImportedName(self: AvailObject, trueName: A_Atom)

o_AddImportedNames

abstract fun o_AddImportedNames(self: AvailObject, trueNames: A_Set)

o_AddLexer

abstract fun o_AddLexer(self: AvailObject, lexer: A_Lexer)

o_AddPlanInProgress

abstract fun o_AddPlanInProgress(self: AvailObject, planInProgress: A_ParsingPlanInProgress)

o_AddPrivateName

abstract fun o_AddPrivateName(self: AvailObject, trueName: A_Atom)

o_AddPrivateNames

abstract fun o_AddPrivateNames(self: AvailObject, trueNames: A_Set)

o_AddSeal

abstract fun o_AddSeal( self: AvailObject, methodName: A_Atom, argumentTypes: A_Tuple)

o_AddSealedArgumentsType

abstract fun o_AddSealedArgumentsType(self: AvailObject, typeTuple: A_Tuple)

o_AddSemanticRestriction

abstract fun o_AddSemanticRestriction(self: AvailObject, restriction: A_SemanticRestriction)

o_AddToDoubleCanDestroy

abstract fun o_AddToDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_AddToFloatCanDestroy

abstract fun o_AddToFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_AddToInfinityCanDestroy

abstract fun o_AddToInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Add the operands and answer the result.

o_AddToIntegerCanDestroy

abstract fun o_AddToIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Add the operands and answer the result.

o_AddUnloadFunction

abstract fun o_AddUnloadFunction(self: AvailObject, unloadFunction: A_Function)

o_AddVariableBinding

abstract fun o_AddVariableBinding( self: AvailObject, name: A_String, variableBinding: A_Variable)

o_AddWriteReactor

abstract fun o_AddWriteReactor( self: AvailObject, key: A_Atom, reactor: VariableDescriptor.VariableAccessReactor)

o_AdjustPcAndStackp

abstract fun o_AdjustPcAndStackp( self: AvailObject, pc: Int, stackp: Int)

o_AllAncestors

abstract fun o_AllAncestors(self: AvailObject): A_Set

o_AllParsingPlansInProgress

abstract fun o_AllParsingPlansInProgress(self: AvailObject): A_Map

o_ApparentSendName

abstract fun o_ApparentSendName(self: AvailObject): A_Atom

o_AppendCanDestroy

abstract fun o_AppendCanDestroy( self: AvailObject, newElement: A_BasicObject, canDestroy: Boolean): A_Tuple

o_ApplyModuleHeader

abstract fun o_ApplyModuleHeader( self: AvailObject, loader: AvailLoader, moduleHeader: ModuleHeader): String?

o_ApplyStylesThen

abstract fun o_ApplyStylesThen( self: AvailObject, context: CompilationContext, visitedSet: MutableSet<A_Phrase>, then: () -> Unit)

o_ArgsTupleType

abstract fun o_ArgsTupleType(self: AvailObject): A_Type

o_ArgumentRestrictionSets

abstract fun o_ArgumentRestrictionSets(self: AvailObject): A_Tuple

o_ArgumentsListNode

abstract fun o_ArgumentsListNode(self: AvailObject): A_Phrase

o_ArgumentsTuple

abstract fun o_ArgumentsTuple(self: AvailObject): A_Tuple

o_AsBigInteger

abstract fun o_AsBigInteger(self: AvailObject): BigInteger

o_AsNativeString

abstract fun o_AsNativeString(self: AvailObject): String

Construct a Java string from the given Avail string.

o_AsSet

abstract fun o_AsSet(self: AvailObject): A_Set

Construct a Java set from the given tuple.

o_AsTuple

abstract fun o_AsTuple(self: AvailObject): A_Tuple

Construct a tuple from the given set. Element ordering in the tuple will be arbitrary and unstable.

o_AtomicAddToMap

abstract fun o_AtomicAddToMap( self: AvailObject, key: A_BasicObject, value: A_BasicObject)

o_AtomicRemoveFromMap

abstract fun o_AtomicRemoveFromMap(self: AvailObject, key: A_BasicObject)

o_AtomName

abstract fun o_AtomName(self: AvailObject): A_String

o_AvailLoader

abstract fun o_AvailLoader(self: AvailObject): AvailLoader?

o_BinElementAt

abstract fun o_BinElementAt(self: AvailObject, index: Int): AvailObject

o_BinElementsAreAllInstancesOfKind

abstract fun o_BinElementsAreAllInstancesOfKind(self: AvailObject, kind: A_Type): Boolean

o_BinHasElementWithHash

abstract fun o_BinHasElementWithHash( self: AvailObject, elementObject: A_BasicObject, elementObjectHash: Int): Boolean

o_BinUnionKind

abstract fun o_BinUnionKind(self: AvailObject): A_Type

o_BitSet

abstract fun o_BitSet( self: AvailObject, bitPosition: Int, value: Boolean, canDestroy: Boolean): A_Number

o_BitShift

abstract fun o_BitShift( self: AvailObject, shiftFactor: A_Number, canDestroy: Boolean): A_Number

o_BitShiftLeftTruncatingToBits

abstract fun o_BitShiftLeftTruncatingToBits( self: AvailObject, shiftFactor: A_Number, truncationBits: A_Number, canDestroy: Boolean): A_Number

o_BitsPerEntry

abstract fun o_BitsPerEntry(self: AvailObject): Int

For this tuple, estimate how many bits of memory per element are consumed by its current representation. This is used to determine which of two representations is more efficient, in the case that equal tuples have been compared, and either one can be converted into an indirection to the other.

o_BitTest

abstract fun o_BitTest(self: AvailObject, bitPosition: Int): Boolean

o_BitwiseAnd

abstract fun o_BitwiseAnd( self: AvailObject, anInteger: A_Number, canDestroy: Boolean): A_Number

o_BitwiseOr

abstract fun o_BitwiseOr( self: AvailObject, anInteger: A_Number, canDestroy: Boolean): A_Number

o_BitwiseXor

abstract fun o_BitwiseXor( self: AvailObject, anInteger: A_Number, canDestroy: Boolean): A_Number

o_BodyBlock

abstract fun o_BodyBlock(self: AvailObject): A_Function

o_BodySignature

abstract fun o_BodySignature(self: AvailObject): A_Type

o_BuildFilteredBundleTree

abstract fun o_BuildFilteredBundleTree(self: AvailObject): A_BundleTree

o_Bundle

abstract fun o_Bundle(self: AvailObject): A_Bundle

o_BundleAddMacro

abstract fun o_BundleAddMacro( self: AvailObject, macro: A_Macro, ignoreSeals: Boolean)

o_BundleMethod

abstract fun o_BundleMethod(self: AvailObject): A_Method

o_BundleOrCreate

abstract fun o_BundleOrCreate(self: AvailObject): A_Bundle

o_BundleOrNil

abstract fun o_BundleOrNil(self: AvailObject): A_Bundle

o_Bundles

abstract fun o_Bundles(self: AvailObject): A_Set

o_ByteArray

abstract fun o_ByteArray(self: AvailObject): ByteArray

o_ByteBuffer

abstract fun o_ByteBuffer(self: AvailObject): ByteBuffer

o_Caller

abstract fun o_Caller(self: AvailObject): A_Continuation

o_CaptureInDebugger

abstract fun o_CaptureInDebugger(self: AvailObject, debugger: AvailDebuggerModel)

o_ChildAt

abstract fun o_ChildAt(self: AvailObject, childIndex: Int): A_Tuple

o_ChildCount

abstract fun o_ChildCount(self: AvailObject): Int

o_ChildrenDo

abstract fun o_ChildrenDo(self: AvailObject, action: (A_Phrase) -> Unit)

Visit my child phrases with aBlock.

o_ChildrenMap

abstract fun o_ChildrenMap(self: AvailObject, transformer: (A_Phrase) -> A_Phrase)

Map my children through the (destructive) transformation specified by aBlock.

o_ChooseBundle

abstract fun o_ChooseBundle(self: AvailObject, currentModule: A_Module): A_Bundle

o_ClearGeneralFlag

abstract fun o_ClearGeneralFlag(self: AvailObject, flag: FiberDescriptor.GeneralFlag)

o_ClearLexingState

abstract fun o_ClearLexingState(self: AvailObject)

o_ClearTraceFlag

abstract fun o_ClearTraceFlag(self: AvailObject, flag: FiberDescriptor.TraceFlag)

o_ClearValue

abstract fun o_ClearValue(self: AvailObject)

o_Code

abstract fun o_Code(self: AvailObject): A_RawFunction

o_CodePoint

abstract fun o_CodePoint(self: AvailObject): Int

o_CompareAndSwapValues

abstract fun o_CompareAndSwapValues( self: AvailObject, reference: A_BasicObject, newValue: A_BasicObject): Boolean

o_CompareAndSwapValuesNoCheck

abstract fun o_CompareAndSwapValuesNoCheck( self: AvailObject, reference: A_BasicObject, newValue: A_BasicObject): Boolean

o_CompareFromToWithAnyTupleStartingAt

abstract fun o_CompareFromToWithAnyTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given tuple. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithByteArrayTupleStartingAt

abstract fun o_CompareFromToWithByteArrayTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteArrayTuple: A_Tuple, startIndex2: Int): Boolean

o_CompareFromToWithByteBufferTupleStartingAt

abstract fun o_CompareFromToWithByteBufferTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteBufferTuple: A_Tuple, startIndex2: Int): Boolean

o_CompareFromToWithByteStringStartingAt

abstract fun o_CompareFromToWithByteStringStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteString: A_String, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given byte string. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithByteTupleStartingAt

abstract fun o_CompareFromToWithByteTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aByteTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given byte tuple. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithIntegerIntervalTupleStartingAt

abstract fun o_CompareFromToWithIntegerIntervalTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anIntegerIntervalTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given integer interval tuple. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithIntTupleStartingAt

abstract fun o_CompareFromToWithIntTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anIntTuple: A_Tuple, startIndex2: Int): Boolean

o_CompareFromToWithNybbleTupleStartingAt

abstract fun o_CompareFromToWithNybbleTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aNybbleTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given nybble tuple. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithObjectTupleStartingAt

abstract fun o_CompareFromToWithObjectTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anObjectTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given object tuple. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithRepeatedElementTupleStartingAt

abstract fun o_CompareFromToWithRepeatedElementTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aRepeatedElementTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given repeated element tuple. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithSmallIntegerIntervalTupleStartingAt

abstract fun o_CompareFromToWithSmallIntegerIntervalTupleStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aSmallIntegerIntervalTuple: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given small integer interval tuple. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithStartingAt

abstract fun o_CompareFromToWithStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, anotherObject: A_Tuple, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of another object. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_CompareFromToWithTwoByteStringStartingAt

abstract fun o_CompareFromToWithTwoByteStringStartingAt( self: AvailObject, startIndex1: Int, endIndex1: Int, aTwoByteString: A_String, startIndex2: Int): Boolean

Compare a subrange of the receiver with a subrange of the given two-byte string. The size of the subrange of both objects is determined by the index range supplied for the receiver.

o_ComputeHashFromTo

abstract fun o_ComputeHashFromTo( self: AvailObject, start: Int, end: Int): Int

o_ComputeInstanceTag

abstract fun o_ComputeInstanceTag(self: AvailObject): TypeTag

o_ComputeSuperkind

abstract fun o_ComputeSuperkind(self: AvailObject): A_Type

o_ComputeTypeTag

abstract fun o_ComputeTypeTag(self: AvailObject): TypeTag

Compute this object's TypeTag, having failed to extract it from the descriptor directly in AvailObjectRepresentation.typeTag.

o_ConcatenateTuplesCanDestroy

abstract fun o_ConcatenateTuplesCanDestroy(self: AvailObject, canDestroy: Boolean): A_Tuple

o_ConcatenateWith

abstract fun o_ConcatenateWith( self: AvailObject, otherTuple: A_Tuple, canDestroy: Boolean): A_Tuple

o_ConstantBindings

abstract fun o_ConstantBindings(self: AvailObject): A_Map

o_ConstantTypeAt

abstract fun o_ConstantTypeAt(self: AvailObject, index: Int): A_Type

o_ContentType

abstract fun o_ContentType(self: AvailObject): A_Type

o_Continuation

abstract fun o_Continuation(self: AvailObject): A_Continuation

o_CopyAsMutableIntTuple

abstract fun o_CopyAsMutableIntTuple(self: AvailObject): A_Tuple

o_CopyAsMutableLongTuple

abstract fun o_CopyAsMutableLongTuple(self: AvailObject): A_Tuple

o_CopyAsMutableObjectTuple

abstract fun o_CopyAsMutableObjectTuple(self: AvailObject): A_Tuple

o_CopyConcatenating

abstract fun o_CopyConcatenating(self: AvailObject, newListPhrase: A_Phrase): A_Phrase

o_CopyMutablePhrase

abstract fun o_CopyMutablePhrase(self: AvailObject): A_Phrase

o_CopyTupleFromToCanDestroy

abstract fun o_CopyTupleFromToCanDestroy( self: AvailObject, start: Int, end: Int, canDestroy: Boolean): A_Tuple

o_CopyWith

abstract fun o_CopyWith(self: AvailObject, newPhrase: A_Phrase): A_Phrase

o_CouldEverBeInvokedWith

abstract fun o_CouldEverBeInvokedWith(self: AvailObject, argRestrictions: List<TypeRestriction>): Boolean

o_CountdownToReoptimize

abstract fun o_CountdownToReoptimize(self: AvailObject, value: Long)

o_CreateLexicalScanner

abstract fun o_CreateLexicalScanner(self: AvailObject): LexicalScanner

o_CurrentLexer

abstract fun o_CurrentLexer(self: AvailObject): A_Lexer

o_CurrentLineNumber

abstract fun o_CurrentLineNumber(self: AvailObject, topFrame: Boolean): Int

o_DebugLog

abstract fun o_DebugLog(self: AvailObject): StringBuilder

Answer a fiber's internal debug log.

o_Declaration

abstract fun o_Declaration(self: AvailObject): A_Phrase

o_DeclarationKind

abstract fun o_DeclarationKind(self: AvailObject): DeclarationPhraseDescriptor.DeclarationKind

o_DeclarationNames

abstract fun o_DeclarationNames(self: AvailObject): A_Tuple

o_DeclaredExceptions

abstract fun o_DeclaredExceptions(self: AvailObject): A_Set

o_DeclaredType

abstract fun o_DeclaredType(self: AvailObject): A_Type

o_DecreaseCountdownToReoptimizeFromPoll

abstract fun o_DecreaseCountdownToReoptimizeFromPoll(self: AvailObject, delta: Long)

o_DecrementCountdownToReoptimize

abstract fun o_DecrementCountdownToReoptimize(self: AvailObject, continuation: (Boolean) -> Unit): Boolean

o_DefaultType

abstract fun o_DefaultType(self: AvailObject): A_Type

o_Definition

abstract fun o_Definition(self: AvailObject): A_Definition

o_DefinitionBundle

abstract fun o_DefinitionBundle(self: AvailObject): A_Bundle

o_DefinitionMethod

abstract fun o_DefinitionMethod(self: AvailObject): A_Method

o_DefinitionModule

abstract fun o_DefinitionModule(self: AvailObject): A_Module

o_DefinitionModuleName

abstract fun o_DefinitionModuleName(self: AvailObject): A_String

o_DefinitionParsingPlans

abstract fun o_DefinitionParsingPlans(self: AvailObject): A_Map

o_DefinitionsAtOrBelow

abstract fun o_DefinitionsAtOrBelow(self: AvailObject, argRestrictions: List<TypeRestriction>): List<A_Definition>

o_DefinitionsTuple

abstract fun o_DefinitionsTuple(self: AvailObject): A_Tuple

o_DeoptimizeForDebugger

abstract fun o_DeoptimizeForDebugger(self: AvailObject)

o_DescribeForDebugger

open fun o_DescribeForDebugger(self: AvailObject): Array<AvailObjectFieldHelper>

Describe the object for the IntelliJ debugger.

o_DivideCanDestroy

abstract fun o_DivideCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Divide the operands and answer the result.

o_DivideIntoDoubleCanDestroy

abstract fun o_DivideIntoDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_DivideIntoFloatCanDestroy

abstract fun o_DivideIntoFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_DivideIntoInfinityCanDestroy

abstract fun o_DivideIntoInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Divide an infinity with the given sign by the object and answer the result.

o_DivideIntoIntegerCanDestroy

abstract fun o_DivideIntoIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Divide the operands and answer the result.

o_EmitAllValuesOn

abstract fun o_EmitAllValuesOn(self: AvailObject, codeGenerator: AvailCodeGenerator)

o_EmitEffectOn

abstract fun o_EmitEffectOn(self: AvailObject, codeGenerator: AvailCodeGenerator)

o_EmitValueOn

abstract fun o_EmitValueOn(self: AvailObject, codeGenerator: AvailCodeGenerator)

o_EnsureMutable

abstract fun o_EnsureMutable(self: AvailObject): A_Continuation

o_EntryPoints

abstract fun o_EntryPoints(self: AvailObject): A_Map

o_EnumerationIncludesInstance

abstract fun o_EnumerationIncludesInstance(self: AvailObject, potentialInstance: AvailObject): Boolean

o_Equals

abstract fun o_Equals(self: AvailObject, another: A_BasicObject): Boolean

Answer whether the arguments, both objects, are equal in value.

o_EqualsAnyTuple

abstract fun o_EqualsAnyTuple(self: AvailObject, aTuple: A_Tuple): Boolean

Answer whether the arguments, an object and a tuple, are equal in value.

o_EqualsByteArrayTuple

abstract fun o_EqualsByteArrayTuple(self: AvailObject, aByteArrayTuple: A_Tuple): Boolean

o_EqualsByteBufferTuple

abstract fun o_EqualsByteBufferTuple(self: AvailObject, aByteBufferTuple: A_Tuple): Boolean

o_EqualsByteString

abstract fun o_EqualsByteString(self: AvailObject, aByteString: A_String): Boolean

Answer whether the arguments, an object and a byte string, are equal in value.

o_EqualsByteTuple

abstract fun o_EqualsByteTuple(self: AvailObject, aByteTuple: A_Tuple): Boolean

Answer whether the arguments, an object, and a byte tuple, are equal in value.

o_EqualsCharacterWithCodePoint

abstract fun o_EqualsCharacterWithCodePoint(self: AvailObject, aCodePoint: Int): Boolean

Answer whether the receiver, an object, is a character with a code point equal to the integer argument.

o_EqualsCompiledCode

abstract fun o_EqualsCompiledCode(self: AvailObject, aCompiledCode: A_RawFunction): Boolean

Answer whether the arguments, an object and a compiled code, are equal.

o_EqualsCompiledCodeType

abstract fun o_EqualsCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): Boolean

o_EqualsContinuation

abstract fun o_EqualsContinuation(self: AvailObject, aContinuation: A_Continuation): Boolean

o_EqualsContinuationType

abstract fun o_EqualsContinuationType(self: AvailObject, aContinuationType: A_Type): Boolean

o_EqualsDouble

abstract fun o_EqualsDouble(self: AvailObject, aDouble: Double): Boolean

o_EqualsEnumerationType

abstract fun o_EqualsEnumerationType(self: AvailObject, another: A_BasicObject): Boolean

o_EqualsEnumerationWithSet

abstract fun o_EqualsEnumerationWithSet(self: AvailObject, aSet: A_Set): Boolean

o_EqualsEqualityRawPojo

abstract fun o_EqualsEqualityRawPojo( self: AvailObject, otherEqualityRawPojo: AvailObject, otherJavaObject: Any?): Boolean

o_EqualsFiberType

abstract fun o_EqualsFiberType(self: AvailObject, aFiberType: A_Type): Boolean

Answer whether the arguments, an object and a fiber type, are equal in value.

o_EqualsFloat

abstract fun o_EqualsFloat(self: AvailObject, aFloat: Float): Boolean

o_EqualsFunction

abstract fun o_EqualsFunction(self: AvailObject, aFunction: A_Function): Boolean

Answer whether the arguments, an object and a function, are equal in value.

o_EqualsFunctionType

abstract fun o_EqualsFunctionType(self: AvailObject, aFunctionType: A_Type): Boolean

Answer whether the arguments, an object and a function type, are equal.

o_EqualsInfinity

abstract fun o_EqualsInfinity(self: AvailObject, sign: AbstractNumberDescriptor.Sign): Boolean

Answer whether the receiver is an infinity with the specified Sign.

o_EqualsInstanceTypeFor

abstract fun o_EqualsInstanceTypeFor(self: AvailObject, anObject: AvailObject): Boolean

o_EqualsInt

abstract fun o_EqualsInt(self: AvailObject, theInt: Int): Boolean

o_EqualsInteger

abstract fun o_EqualsInteger(self: AvailObject, anAvailInteger: AvailObject): Boolean

o_EqualsIntegerIntervalTuple

abstract fun o_EqualsIntegerIntervalTuple(self: AvailObject, anIntegerIntervalTuple: A_Tuple): Boolean

o_EqualsIntegerRangeType

abstract fun o_EqualsIntegerRangeType(self: AvailObject, another: A_Type): Boolean

o_EqualsIntTuple

abstract fun o_EqualsIntTuple(self: AvailObject, anIntTuple: A_Tuple): Boolean

o_EqualsListNodeType

abstract fun o_EqualsListNodeType(self: AvailObject, aListNodeType: A_Type): Boolean

o_EqualsLiteralTokenType

abstract fun o_EqualsLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): Boolean

o_EqualsLongTuple

abstract fun o_EqualsLongTuple(self: AvailObject, aLongTuple: A_Tuple): Boolean

o_EqualsMap

abstract fun o_EqualsMap(self: AvailObject, aMap: A_Map): Boolean

o_EqualsMapType

abstract fun o_EqualsMapType(self: AvailObject, aMapType: A_Type): Boolean

o_EqualsNybbleTuple

abstract fun o_EqualsNybbleTuple(self: AvailObject, aTuple: A_Tuple): Boolean

o_EqualsObject

abstract fun o_EqualsObject(self: AvailObject, anObject: AvailObject): Boolean

o_EqualsObjectTuple

abstract fun o_EqualsObjectTuple(self: AvailObject, aTuple: A_Tuple): Boolean

o_EqualsObjectType

abstract fun o_EqualsObjectType(self: AvailObject, anObjectType: AvailObject): Boolean

o_EqualsPhrase

abstract fun o_EqualsPhrase(self: AvailObject, aPhrase: A_Phrase): Boolean

o_EqualsPhraseType

abstract fun o_EqualsPhraseType(self: AvailObject, aPhraseType: A_Type): Boolean

o_EqualsPojo

abstract fun o_EqualsPojo(self: AvailObject, aPojo: AvailObject): Boolean

o_EqualsPojoBottomType

abstract fun o_EqualsPojoBottomType(self: AvailObject): Boolean

o_EqualsPojoField

abstract fun o_EqualsPojoField( self: AvailObject, field: AvailObject, receiver: AvailObject): Boolean

o_EqualsPojoType

abstract fun o_EqualsPojoType(self: AvailObject, aPojoType: AvailObject): Boolean

o_EqualsPrimitiveType

abstract fun o_EqualsPrimitiveType(self: AvailObject, aPrimitiveType: A_Type): Boolean

o_EqualsRawPojoFor

abstract fun o_EqualsRawPojoFor( self: AvailObject, otherRawPojo: AvailObject, otherJavaObject: Any?): Boolean

o_EqualsRepeatedElementTuple

abstract fun o_EqualsRepeatedElementTuple(self: AvailObject, aRepeatedElementTuple: A_Tuple): Boolean

o_EqualsReverseTuple

abstract fun o_EqualsReverseTuple(self: AvailObject, aTuple: A_Tuple): Boolean

o_EqualsSet

abstract fun o_EqualsSet(self: AvailObject, aSet: A_Set): Boolean

o_EqualsSetType

abstract fun o_EqualsSetType(self: AvailObject, aSetType: A_Type): Boolean

o_EqualsSmallIntegerIntervalTuple

abstract fun o_EqualsSmallIntegerIntervalTuple(self: AvailObject, aSmallIntegerIntervalTuple: A_Tuple): Boolean

o_EqualsToken

abstract fun o_EqualsToken(self: AvailObject, aToken: A_Token): Boolean

o_EqualsTokenType

abstract fun o_EqualsTokenType(self: AvailObject, aTokenType: A_Type): Boolean

o_EqualsTupleType

abstract fun o_EqualsTupleType(self: AvailObject, aTupleType: A_Type): Boolean

o_EqualsTwoByteString

abstract fun o_EqualsTwoByteString(self: AvailObject, aString: A_String): Boolean

o_EqualsVariableType

abstract fun o_EqualsVariableType(self: AvailObject, aType: A_Type): Boolean

o_ExecutionState

abstract fun o_ExecutionState(self: AvailObject): FiberDescriptor.ExecutionState

o_Expand

abstract fun o_Expand(self: AvailObject, module: A_Module)

o_ExportedNames

abstract fun o_ExportedNames(self: AvailObject): A_Set

o_Expression

abstract fun o_Expression(self: AvailObject): A_Phrase

o_ExpressionAt

abstract fun o_ExpressionAt(self: AvailObject, index: Int): A_Phrase

o_ExpressionsSize

abstract fun o_ExpressionsSize(self: AvailObject): Int

o_ExpressionsTuple

abstract fun o_ExpressionsTuple(self: AvailObject): A_Tuple

o_ExtractBoolean

abstract fun o_ExtractBoolean(self: AvailObject): Boolean

o_ExtractDouble

abstract fun o_ExtractDouble(self: AvailObject): Double

o_ExtractDumpedLongAt

abstract fun o_ExtractDumpedLongAt(self: AvailObject, index: Int): Long

o_ExtractDumpedObjectAt

abstract fun o_ExtractDumpedObjectAt(self: AvailObject, index: Int): AvailObject

o_ExtractFloat

abstract fun o_ExtractFloat(self: AvailObject): Float

o_ExtractInt

abstract fun o_ExtractInt(self: AvailObject): Int

o_ExtractLong

abstract fun o_ExtractLong(self: AvailObject): Long

Extract a 64-bit signed Java long from the specified Avail integer.

o_ExtractNybble

abstract fun o_ExtractNybble(self: AvailObject): Byte

o_ExtractNybbleFromTupleAt

abstract fun o_ExtractNybbleFromTupleAt(self: AvailObject, index: Int): Byte

o_ExtractSignedByte

abstract fun o_ExtractSignedByte(self: AvailObject): Byte

o_ExtractSignedShort

abstract fun o_ExtractSignedShort(self: AvailObject): Short

o_ExtractUnsignedByte

abstract fun o_ExtractUnsignedByte(self: AvailObject): Short

o_ExtractUnsignedShort

abstract fun o_ExtractUnsignedShort(self: AvailObject): Int

o_FailureContinuation

abstract fun o_FailureContinuation(self: AvailObject): (Throwable) -> Unit

o_FetchAndAddValue

abstract fun o_FetchAndAddValue(self: AvailObject, addend: A_Number): A_Number

o_FiberGlobals

abstract fun o_FiberGlobals(self: AvailObject): A_Map

o_FiberHelper

abstract fun o_FiberHelper(self: AvailObject): FiberDescriptor.FiberHelper

o_FiberName

abstract fun o_FiberName(self: AvailObject): A_String

o_FiberNameSupplier

abstract fun o_FiberNameSupplier(self: AvailObject, supplier: () -> A_String)

o_FiberResult

abstract fun o_FiberResult(self: AvailObject): AvailObject

o_FiberResultType

abstract fun o_FiberResultType(self: AvailObject): A_Type

o_FieldAt

abstract fun o_FieldAt(self: AvailObject, field: A_Atom): AvailObject

o_FieldAtIndex

abstract fun o_FieldAtIndex(self: AvailObject, index: Int): AvailObject

o_FieldAtOrNull

abstract fun o_FieldAtOrNull(self: AvailObject, field: A_Atom): AvailObject?

o_FieldAtPuttingCanDestroy

abstract fun o_FieldAtPuttingCanDestroy( self: AvailObject, field: A_Atom, value: A_BasicObject, canDestroy: Boolean): A_BasicObject

o_FieldMap

abstract fun o_FieldMap(self: AvailObject): A_Map

o_FieldTuple

abstract fun o_FieldTuple(self: AvailObject): A_Tuple

o_FieldTypeAt

abstract fun o_FieldTypeAt(self: AvailObject, field: A_Atom): A_Type

o_FieldTypeAtIndex

abstract fun o_FieldTypeAtIndex(self: AvailObject, index: Int): A_Type

o_FieldTypeAtOrNull

abstract fun o_FieldTypeAtOrNull(self: AvailObject, field: A_Atom): A_Type?

o_FieldTypeMap

abstract fun o_FieldTypeMap(self: AvailObject): A_Map

o_FieldTypeTuple

abstract fun o_FieldTypeTuple(self: AvailObject): A_Tuple

o_FilterByTypes

abstract fun o_FilterByTypes(self: AvailObject, argTypes: List<A_Type>): List<A_Definition>

o_FirstIndexOf

abstract fun o_FirstIndexOf( self: AvailObject, value: A_BasicObject, startIndex: Int, endIndex: Int): Int

o_FlattenStatementsInto

abstract fun o_FlattenStatementsInto(self: AvailObject, accumulatedStatements: MutableList<A_Phrase>)

o_ForEach

abstract fun o_ForEach(self: AvailObject, action: (AvailObject, AvailObject) -> Unit)

o_ForEachInMapBin

abstract fun o_ForEachInMapBin(self: AvailObject, action: (AvailObject, AvailObject) -> Unit)

o_FrameAt

abstract fun o_FrameAt(self: AvailObject, index: Int): AvailObject

o_FrameAtPut

abstract fun o_FrameAtPut( self: AvailObject, index: Int, value: AvailObject): AvailObject

o_Function

abstract fun o_Function(self: AvailObject): A_Function

o_FunctionType

abstract fun o_FunctionType(self: AvailObject): A_Type

o_GeneralFlag

abstract fun o_GeneralFlag(self: AvailObject, flag: FiberDescriptor.GeneralFlag): Boolean

o_GenerateInModule

abstract fun o_GenerateInModule(self: AvailObject, module: A_Module): A_RawFunction

o_GeneratingLexer

abstract fun o_GeneratingLexer(self: AvailObject): A_Lexer

o_GeneratingPhrase

abstract fun o_GeneratingPhrase(self: AvailObject): A_Phrase

o_GetAndClearInterruptRequestFlag

abstract fun o_GetAndClearInterruptRequestFlag(self: AvailObject, flag: FiberDescriptor.InterruptRequestFlag): Boolean

o_GetAndClearReificationWaiters

abstract fun o_GetAndClearReificationWaiters(self: AvailObject): List<(A_Continuation) -> Unit>

o_GetAndSetSynchronizationFlag

abstract fun o_GetAndSetSynchronizationFlag( self: AvailObject, flag: FiberDescriptor.SynchronizationFlag, value: Boolean): Boolean

o_GetAndSetTupleOfBlockPhrases

abstract fun o_GetAndSetTupleOfBlockPhrases(self: AvailObject, newValue: AvailObject): AvailObject

o_GetAndSetValue

abstract fun o_GetAndSetValue(self: AvailObject, newValue: A_BasicObject): AvailObject

o_GetAtomProperty

abstract fun o_GetAtomProperty(self: AvailObject, key: A_Atom): AvailObject

o_GetValue

abstract fun o_GetValue(self: AvailObject): AvailObject

o_GetValueClearing

abstract fun o_GetValueClearing(self: AvailObject): AvailObject

o_GetValueForDebugger

abstract fun o_GetValueForDebugger(self: AvailObject): AvailObject

o_GlobalModule

abstract fun o_GlobalModule(self: AvailObject): A_Module

o_GlobalName

abstract fun o_GlobalName(self: AvailObject): A_String

o_GrammaticalRestrictions

abstract fun o_GrammaticalRestrictions(self: AvailObject): A_Set

o_HasAncestor

abstract fun o_HasAncestor(self: AvailObject, potentialAncestor: A_Module): Boolean

o_HasBackwardJump

abstract fun o_HasBackwardJump(self: AvailObject): Boolean

o_HasElement

abstract fun o_HasElement(self: AvailObject, elementObject: A_BasicObject): Boolean

Answer whether the receiver contains the specified element.

o_HasGrammaticalRestrictions

abstract fun o_HasGrammaticalRestrictions(self: AvailObject): Boolean

o_Hash

abstract fun o_Hash(self: AvailObject): Int

o_HashFromTo

abstract fun o_HashFromTo( self: AvailObject, startIndex: Int, endIndex: Int): Int

o_HashOrZero

abstract fun o_HashOrZero(self: AvailObject): Int

o_HasObjectInstance

abstract fun o_HasObjectInstance(self: AvailObject, potentialInstance: AvailObject): Boolean

o_HasSuperCast

abstract fun o_HasSuperCast(self: AvailObject): Boolean

o_HasValue

abstract fun o_HasValue(self: AvailObject): Boolean

o_HeritableFiberGlobals

abstract fun o_HeritableFiberGlobals(self: AvailObject): A_Map

o_HighlightPc

abstract fun o_HighlightPc(self: AvailObject, topFrame: Boolean): Int

o_ImportedNames

abstract fun o_ImportedNames(self: AvailObject): A_Map

o_IncludesDefinition

abstract fun o_IncludesDefinition(self: AvailObject, definition: A_Definition): Boolean

o_InitializationExpression

abstract fun o_InitializationExpression(self: AvailObject): AvailObject

o_Instance

abstract fun o_Instance(self: AvailObject): AvailObject

o_InstanceCount

abstract fun o_InstanceCount(self: AvailObject): A_Number

o_Instances

abstract fun o_Instances(self: AvailObject): A_Set

o_InstanceTag

abstract fun o_InstanceTag(self: AvailObject): TypeTag

o_InterruptRequestFlag

abstract fun o_InterruptRequestFlag(self: AvailObject, flag: FiberDescriptor.InterruptRequestFlag): Boolean

o_IntroduceNewName

abstract fun o_IntroduceNewName(self: AvailObject, trueName: A_Atom)

o_IsAbstract

abstract fun o_IsAbstract(self: AvailObject): Boolean

o_IsAbstractDefinition

abstract fun o_IsAbstractDefinition(self: AvailObject): Boolean

o_IsAtom

abstract fun o_IsAtom(self: AvailObject): Boolean

Is the specified AvailObject an Avail atom?

o_IsAtomSpecial

abstract fun o_IsAtomSpecial(self: AvailObject): Boolean

o_IsBackwardJump

abstract fun o_IsBackwardJump(self: AvailObject): Boolean

o_IsBetterRepresentationThan

abstract fun o_IsBetterRepresentationThan(self: AvailObject, anotherObject: A_BasicObject): Boolean

Given two objects that are known to be equal, is the first one in a better form (more compact, more efficient, older generation) than the second one?

o_IsBinSubsetOf

abstract fun o_IsBinSubsetOf(self: AvailObject, potentialSuperset: A_Set): Boolean

o_IsBoolean

abstract fun o_IsBoolean(self: AvailObject): Boolean

Is the specified AvailObject an Avail boolean?

o_IsBottom

abstract fun o_IsBottom(self: AvailObject): Boolean

o_IsByteArrayTuple

abstract fun o_IsByteArrayTuple(self: AvailObject): Boolean

o_IsByteBufferTuple

abstract fun o_IsByteBufferTuple(self: AvailObject): Boolean

o_IsByteString

abstract fun o_IsByteString(self: AvailObject): Boolean

o_IsByteTuple

abstract fun o_IsByteTuple(self: AvailObject): Boolean

Is the specified AvailObject an Avail byte tuple?

o_IsCharacter

abstract fun o_IsCharacter(self: AvailObject): Boolean

Is the specified AvailObject an Avail character?

o_IsDouble

abstract fun o_IsDouble(self: AvailObject): Boolean

o_IsEnumeration

abstract fun o_IsEnumeration(self: AvailObject): Boolean

o_IsExtendedInteger

abstract fun o_IsExtendedInteger(self: AvailObject): Boolean

Is the specified AvailObject an Avail extended integer?

o_IsFinite

abstract fun o_IsFinite(self: AvailObject): Boolean

o_IsFloat

abstract fun o_IsFloat(self: AvailObject): Boolean

o_IsForwardDefinition

abstract fun o_IsForwardDefinition(self: AvailObject): Boolean

o_IsFunction

abstract fun o_IsFunction(self: AvailObject): Boolean

Is the specified AvailObject an Avail function?

o_IsGlobal

abstract fun o_IsGlobal(self: AvailObject): Boolean

o_IsHashedMapBin

abstract fun o_IsHashedMapBin(self: AvailObject): Boolean

o_IsInCurrentModule

abstract fun o_IsInCurrentModule(self: AvailObject, currentModule: A_Module): Boolean

o_IsInitializedWriteOnceVariable

abstract fun o_IsInitializedWriteOnceVariable(self: AvailObject): Boolean

o_IsInstanceMeta

abstract fun o_IsInstanceMeta(self: AvailObject): Boolean

o_IsInstanceOf

abstract fun o_IsInstanceOf(self: AvailObject, aType: A_Type): Boolean

o_IsInstanceOfKind

abstract fun o_IsInstanceOfKind(self: AvailObject, aType: A_Type): Boolean

o_IsInt

abstract fun o_IsInt(self: AvailObject): Boolean

o_IsIntegerIntervalTuple

abstract fun o_IsIntegerIntervalTuple(self: AvailObject): Boolean

o_IsIntegerRangeType

abstract fun o_IsIntegerRangeType(self: AvailObject): Boolean

o_IsIntTuple

abstract fun o_IsIntTuple(self: AvailObject): Boolean

o_IsLastUse

abstract fun o_IsLastUse(self: AvailObject): Boolean

abstract fun o_IsLastUse(self: AvailObject, isLastUse: Boolean)

o_IsLiteralToken

abstract fun o_IsLiteralToken(self: AvailObject): Boolean

o_IsLiteralTokenType

abstract fun o_IsLiteralTokenType(self: AvailObject): Boolean

o_IsLong

abstract fun o_IsLong(self: AvailObject): Boolean

o_IsLongTuple

abstract fun o_IsLongTuple(self: AvailObject): Boolean

o_IsMacroSubstitutionNode

abstract fun o_IsMacroSubstitutionNode(self: AvailObject): Boolean

o_IsMap

abstract fun o_IsMap(self: AvailObject): Boolean

Is the specified AvailObject an Avail map?

o_IsMapType

abstract fun o_IsMapType(self: AvailObject): Boolean

o_IsMethodDefinition

abstract fun o_IsMethodDefinition(self: AvailObject): Boolean

o_IsMethodEmpty

abstract fun o_IsMethodEmpty(self: AvailObject): Boolean

o_IsNumericallyIntegral

abstract fun o_IsNumericallyIntegral(self: AvailObject): Boolean

o_IsNybble

abstract fun o_IsNybble(self: AvailObject): Boolean

Is the specified AvailObject an Avail nybble?

o_IsPojo

abstract fun o_IsPojo(self: AvailObject): Boolean

o_IsPojoArrayType

abstract fun o_IsPojoArrayType(self: AvailObject): Boolean

o_IsPojoFusedType

abstract fun o_IsPojoFusedType(self: AvailObject): Boolean

o_IsPojoSelfType

abstract fun o_IsPojoSelfType(self: AvailObject): Boolean

o_IsPojoType

abstract fun o_IsPojoType(self: AvailObject): Boolean

o_IsPositive

abstract fun o_IsPositive(self: AvailObject): Boolean

o_IsRawPojo

abstract fun o_IsRawPojo(self: AvailObject): Boolean

o_IsRepeatedElementTuple

abstract fun o_IsRepeatedElementTuple(self: AvailObject): Boolean

o_IsSet

abstract fun o_IsSet(self: AvailObject): Boolean

Is the specified AvailObject an Avail set?

o_IsSetBin

abstract fun o_IsSetBin(self: AvailObject): Boolean

o_IsSetType

abstract fun o_IsSetType(self: AvailObject): Boolean

o_IsSignedByte

abstract fun o_IsSignedByte(self: AvailObject): Boolean

o_IsSignedShort

abstract fun o_IsSignedShort(self: AvailObject): Boolean

o_IsSmallIntegerIntervalTuple

abstract fun o_IsSmallIntegerIntervalTuple(self: AvailObject): Boolean

o_IsSourceOfCycle

abstract fun o_IsSourceOfCycle(self: AvailObject): Boolean

abstract fun o_IsSourceOfCycle(self: AvailObject, isSourceOfCycle: Boolean)

o_IsString

abstract fun o_IsString(self: AvailObject): Boolean

Is the specified AvailObject an Avail string?

o_IsSubsetOf

abstract fun o_IsSubsetOf(self: AvailObject, another: A_Set): Boolean

o_IsSubtypeOf

abstract fun o_IsSubtypeOf(self: AvailObject, aType: A_Type): Boolean

o_IssuingModule

abstract fun o_IssuingModule(self: AvailObject): A_Module

o_IsSupertypeOfCompiledCodeType

abstract fun o_IsSupertypeOfCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): Boolean

o_IsSupertypeOfContinuationType

abstract fun o_IsSupertypeOfContinuationType(self: AvailObject, aContinuationType: A_Type): Boolean

o_IsSupertypeOfEnumerationType

abstract fun o_IsSupertypeOfEnumerationType(self: AvailObject, anEnumerationType: A_Type): Boolean

o_IsSupertypeOfFiberType

abstract fun o_IsSupertypeOfFiberType(self: AvailObject, aType: A_Type): Boolean

o_IsSupertypeOfFunctionType

abstract fun o_IsSupertypeOfFunctionType(self: AvailObject, aFunctionType: A_Type): Boolean

o_IsSupertypeOfIntegerRangeType

abstract fun o_IsSupertypeOfIntegerRangeType(self: AvailObject, anIntegerRangeType: A_Type): Boolean

o_IsSupertypeOfListNodeType

abstract fun o_IsSupertypeOfListNodeType(self: AvailObject, aListNodeType: A_Type): Boolean

o_IsSupertypeOfLiteralTokenType

abstract fun o_IsSupertypeOfLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): Boolean

o_IsSupertypeOfMapType

abstract fun o_IsSupertypeOfMapType(self: AvailObject, aMapType: AvailObject): Boolean

o_IsSupertypeOfObjectType

abstract fun o_IsSupertypeOfObjectType(self: AvailObject, anObjectType: AvailObject): Boolean

o_IsSupertypeOfPhraseType

abstract fun o_IsSupertypeOfPhraseType(self: AvailObject, aPhraseType: A_Type): Boolean

o_IsSupertypeOfPojoBottomType

abstract fun o_IsSupertypeOfPojoBottomType(self: AvailObject, aPojoType: A_Type): Boolean

o_IsSupertypeOfPojoType

abstract fun o_IsSupertypeOfPojoType(self: AvailObject, aPojoType: A_Type): Boolean

o_IsSupertypeOfPrimitiveTypeEnum

abstract fun o_IsSupertypeOfPrimitiveTypeEnum(self: AvailObject, primitiveTypeEnum: PrimitiveTypeDescriptor.Types): Boolean

o_IsSupertypeOfSetType

abstract fun o_IsSupertypeOfSetType(self: AvailObject, aSetType: A_Type): Boolean

o_IsSupertypeOfTokenType

abstract fun o_IsSupertypeOfTokenType(self: AvailObject, aTokenType: A_Type): Boolean

o_IsSupertypeOfTupleType

abstract fun o_IsSupertypeOfTupleType(self: AvailObject, aTupleType: A_Type): Boolean

o_IsSupertypeOfVariableType

abstract fun o_IsSupertypeOfVariableType(self: AvailObject, aVariableType: A_Type): Boolean

o_IsTokenType

abstract fun o_IsTokenType(self: AvailObject): Boolean

o_IsTop

abstract fun o_IsTop(self: AvailObject): Boolean

o_IsTuple

abstract fun o_IsTuple(self: AvailObject): Boolean

Is the specified AvailObject an Avail tuple?

o_IsTupleType

abstract fun o_IsTupleType(self: AvailObject): Boolean

o_IsTwoByteString

abstract fun o_IsTwoByteString(self: AvailObject): Boolean

o_IsType

abstract fun o_IsType(self: AvailObject): Boolean

o_IsUnsignedByte

abstract fun o_IsUnsignedByte(self: AvailObject): Boolean

Is the specified AvailObject an Avail unsigned byte?

o_IsUnsignedShort

abstract fun o_IsUnsignedShort(self: AvailObject): Boolean

o_IsVacuousType

abstract fun o_IsVacuousType(self: AvailObject): Boolean

o_Iterator

abstract fun o_Iterator(self: AvailObject): Iterator<AvailObject>

Answer an iterator suitable for traversing the elements of the object with a Java foreach construct.

o_JavaAncestors

abstract fun o_JavaAncestors(self: AvailObject): AvailObject

o_JavaClass

abstract fun o_JavaClass(self: AvailObject): AvailObject

o_JavaObject

abstract fun <T : Any> o_JavaObject(self: AvailObject): T?

Answer a pojo's java object. The type is not statically checkable in Java, but at least making it generic avoids an explicit cast expression at each call site.

o_JoiningFibers

abstract fun o_JoiningFibers(self: AvailObject): A_Set

o_KeysAsSet

abstract fun o_KeysAsSet(self: AvailObject): A_Set

o_KeyType

abstract fun o_KeyType(self: AvailObject): A_Type

o_Kind

abstract fun o_Kind(self: AvailObject): A_Type

o_LastExpression

abstract fun o_LastExpression(self: AvailObject): A_Phrase

o_LastIndexOf

abstract fun o_LastIndexOf( self: AvailObject, value: A_BasicObject, startIndex: Int, endIndex: Int): Int

o_LatestBackwardJump

abstract fun o_LatestBackwardJump(self: AvailObject): A_BundleTree

o_LazyActions

abstract fun o_LazyActions(self: AvailObject): A_Map

o_LazyComplete

abstract fun o_LazyComplete(self: AvailObject): A_Map

o_LazyIncomplete

abstract fun o_LazyIncomplete(self: AvailObject): A_Map

o_LazyIncompleteCaseInsensitive

abstract fun o_LazyIncompleteCaseInsensitive(self: AvailObject): A_Map

o_LazyPrefilterMap

abstract fun o_LazyPrefilterMap(self: AvailObject): A_Map

o_LazyTypeFilterTree

abstract fun o_LazyTypeFilterTree(self: AvailObject): LookupTree<A_Tuple, A_BundleTree>?

o_LevelTwoChunk

abstract fun o_LevelTwoChunk(self: AvailObject): L2Chunk

o_LevelTwoOffset

abstract fun o_LevelTwoOffset(self: AvailObject): Int

o_Lexer

abstract fun o_Lexer(self: AvailObject): A_Lexer

o_LexerApplicability

abstract fun o_LexerApplicability(self: AvailObject, codePoint: Int): Boolean?

o_LexerBodyFunction

abstract fun o_LexerBodyFunction(self: AvailObject): A_Function

o_LexerFilterFunction

abstract fun o_LexerFilterFunction(self: AvailObject): A_Function

o_LexerMethod

abstract fun o_LexerMethod(self: AvailObject): A_Method

o_LineNumber

abstract fun o_LineNumber(self: AvailObject): Int

o_LineNumberEncodedDeltas

abstract fun o_LineNumberEncodedDeltas(self: AvailObject): A_Tuple

o_List

abstract fun o_List(self: AvailObject): A_Phrase

o_Literal

abstract fun o_Literal(self: AvailObject): AvailObject

o_LiteralAt

abstract fun o_LiteralAt(self: AvailObject, index: Int): AvailObject

o_LiteralObject

abstract fun o_LiteralObject(self: AvailObject): A_BasicObject

o_LiteralType

abstract fun o_LiteralType(self: AvailObject): A_Type

o_LocalTypeAt

abstract fun o_LocalTypeAt(self: AvailObject, index: Int): A_Type

o_Lock

abstract fun <T> o_Lock(self: AvailObject, body: () -> T): T

o_LookupByTypesFromTuple

abstract fun o_LookupByTypesFromTuple(self: AvailObject, argumentTypeTuple: A_Tuple): A_Definition

o_LookupByValuesFromList

abstract fun o_LookupByValuesFromList(self: AvailObject, argumentList: List<A_BasicObject>): A_Definition

o_LookupMacroByPhraseTuple

abstract fun o_LookupMacroByPhraseTuple(self: AvailObject, argumentPhraseTuple: A_Tuple): A_Tuple

o_LowerBound

abstract fun o_LowerBound(self: AvailObject): A_Number

o_LowerCaseString

abstract fun o_LowerCaseString(self: AvailObject): A_String

o_LowerInclusive

abstract fun o_LowerInclusive(self: AvailObject): Boolean

o_MacroOriginalSendNode

abstract fun o_MacroOriginalSendNode(self: AvailObject): A_Phrase

o_MacrosTuple

abstract fun o_MacrosTuple(self: AvailObject): A_Tuple

o_MakeImmutableInternal

open fun o_MakeImmutableInternal( self: AvailObject, queueToProcess: MutableList<AvailObject>, fixups: MutableList<() -> Unit>)

Given that the receiver is marked immutable, but its slots have not yet been made immutable, scan them now. For each slot found to be mutable, mark it immutable and add it to the supplied list.

o_MakeSharedInternal

open fun o_MakeSharedInternal( self: AvailObject, queueToProcess: MutableList<AvailObject>, fixups: MutableList<() -> Unit>)

Given that the receiver is marked shared, but its slots have not yet been shared, scan them now. For each slot found to be unshared, mark it and add it to the supplied list.

o_MakeSubobjectsImmutable

abstract fun o_MakeSubobjectsImmutable(self: AvailObject): AvailObject

o_MakeSubobjectsShared

abstract fun o_MakeSubobjectsShared(self: AvailObject): AvailObject

o_ManifestEntries

abstract fun o_ManifestEntries(self: AvailObject): List<ModuleManifestEntry>

o_MapAtOrNull

abstract fun o_MapAtOrNull(self: AvailObject, keyObject: A_BasicObject): AvailObject?

o_MapAtPuttingCanDestroy

abstract fun o_MapAtPuttingCanDestroy( self: AvailObject, keyObject: A_BasicObject, newValueObject: A_BasicObject, canDestroy: Boolean): A_Map

o_MapAtReplacingCanDestroy

abstract fun o_MapAtReplacingCanDestroy( self: AvailObject, key: A_BasicObject, notFoundValue: A_BasicObject, canDestroy: Boolean, transformer: (AvailObject, AvailObject) -> A_BasicObject): A_Map

o_MapBinAtHash

abstract fun o_MapBinAtHash( self: AvailObject, key: A_BasicObject, keyHash: Int): AvailObject?

o_MapBinAtHashPutLevelCanDestroy

abstract fun o_MapBinAtHashPutLevelCanDestroy( self: AvailObject, key: A_BasicObject, keyHash: Int, value: A_BasicObject, myLevel: Int, canDestroy: Boolean): A_MapBin

o_MapBinAtHashReplacingLevelCanDestroy

abstract fun o_MapBinAtHashReplacingLevelCanDestroy( self: AvailObject, key: AvailObject, keyHash: Int, notFoundValue: AvailObject, myLevel: Int, canDestroy: Boolean, transformer: (AvailObject, AvailObject) -> A_BasicObject): A_MapBin

o_MapBinIterator

abstract fun o_MapBinIterator(self: AvailObject): MapDescriptor.MapIterator

o_MapBinKeysHash

abstract fun o_MapBinKeysHash(self: AvailObject): Int

o_MapBinKeyUnionKind

abstract fun o_MapBinKeyUnionKind(self: AvailObject): A_Type

o_MapBinRemoveKeyHashCanDestroy

abstract fun o_MapBinRemoveKeyHashCanDestroy( self: AvailObject, key: A_BasicObject, keyHash: Int, canDestroy: Boolean): A_MapBin

o_MapBinSize

abstract fun o_MapBinSize(self: AvailObject): Int

o_MapBinValuesHash

abstract fun o_MapBinValuesHash(self: AvailObject): Int

o_MapBinValueUnionKind

abstract fun o_MapBinValueUnionKind(self: AvailObject): A_Type

o_MapIterable

abstract fun o_MapIterable(self: AvailObject): Iterable<MapDescriptor.Entry>

o_MapSize

abstract fun o_MapSize(self: AvailObject): Int

o_MapWithoutKeyCanDestroy

abstract fun o_MapWithoutKeyCanDestroy( self: AvailObject, keyObject: A_BasicObject, canDestroy: Boolean): A_Map

o_MarkerValue

abstract fun o_MarkerValue(self: AvailObject): A_BasicObject

o_MarshalToJava

abstract fun o_MarshalToJava(self: AvailObject, classHint: Class<*>?): Any?

o_MaxStackDepth

abstract fun o_MaxStackDepth(self: AvailObject): Int

o_MembershipChanged

abstract fun o_MembershipChanged(self: AvailObject)

o_Message

abstract fun o_Message(self: AvailObject): A_Atom

o_MessagePart

abstract fun o_MessagePart(self: AvailObject, index: Int): A_String

o_MessageParts

abstract fun o_MessageParts(self: AvailObject): A_Tuple

o_MessageSplitter

abstract fun o_MessageSplitter(self: AvailObject): MessageSplitter

o_MethodAddBundle

abstract fun o_MethodAddBundle(self: AvailObject, bundle: A_Bundle)

o_MethodAddDefinition

abstract fun o_MethodAddDefinition(self: AvailObject, definition: A_Definition)

Add a definition to the receiver. Causes dependent chunks to be invalidated.

o_MethodDefinitions

abstract fun o_MethodDefinitions(self: AvailObject): A_Set

o_MethodName

abstract fun o_MethodName(self: AvailObject): A_String

o_MethodRemoveBundle

abstract fun o_MethodRemoveBundle(self: AvailObject, bundle: A_Bundle)

o_MethodStylers

abstract fun o_MethodStylers(self: AvailObject): A_Set

o_MinusCanDestroy

abstract fun o_MinusCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Difference the operands and answer the result.

o_Module

abstract fun o_Module(self: AvailObject): A_Module

o_ModuleAddDefinition

abstract fun o_ModuleAddDefinition(self: AvailObject, definition: A_Definition)

o_ModuleAddGrammaticalRestriction

abstract fun o_ModuleAddGrammaticalRestriction(self: AvailObject, grammaticalRestriction: A_GrammaticalRestriction)

Add a grammatical restriction to the receiver.

o_ModuleAddMacro

abstract fun o_ModuleAddMacro(self: AvailObject, macro: A_Macro)

o_ModuleAddSemanticRestriction

abstract fun o_ModuleAddSemanticRestriction(self: AvailObject, semanticRestriction: A_SemanticRestriction)

o_ModuleAddStyler

abstract fun o_ModuleAddStyler(self: AvailObject, styler: A_Styler)

o_ModuleName

abstract fun o_ModuleName(self: AvailObject): A_String

o_ModuleNameNative

abstract fun o_ModuleNameNative(self: AvailObject): String

o_ModuleState

abstract fun o_ModuleState(self: AvailObject): ModuleDescriptor.State

o_ModuleStylers

abstract fun o_ModuleStylers(self: AvailObject): A_Set

o_MultiplyByDoubleCanDestroy

abstract fun o_MultiplyByDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_MultiplyByFloatCanDestroy

abstract fun o_MultiplyByFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_MultiplyByInfinityCanDestroy

abstract fun o_MultiplyByInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Multiply the operands and answer the result.

o_MultiplyByIntegerCanDestroy

abstract fun o_MultiplyByIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Multiply the operands and answer the result.

o_NameForDebugger

abstract fun o_NameForDebugger(self: AvailObject): String

o_NameHighlightingPc

abstract fun o_NameHighlightingPc(self: AvailObject): String

o_NeededVariables

abstract fun o_NeededVariables(self: AvailObject): A_Tuple

abstract fun o_NeededVariables(self: AvailObject, neededVariables: A_Tuple)

o_NewNames

abstract fun o_NewNames(self: AvailObject): A_Map

o_NextLexingState

abstract fun o_NextLexingState(self: AvailObject): LexingState

o_NextLexingStatePojo

abstract fun o_NextLexingStatePojo(self: AvailObject): AvailObject

o_NumArgs

abstract fun o_NumArgs(self: AvailObject): Int

Answer how many arguments my instances expect. This is applicable to both methods and compiled code.

o_NumConstants

abstract fun o_NumConstants(self: AvailObject): Int

o_NumericCompare

abstract fun o_NumericCompare(self: AvailObject, another: A_Number): AbstractNumberDescriptor.Order

o_NumericCompareToDouble

abstract fun o_NumericCompareToDouble(self: AvailObject, aDouble: Double): AbstractNumberDescriptor.Order

o_NumericCompareToInfinity

abstract fun o_NumericCompareToInfinity(self: AvailObject, sign: AbstractNumberDescriptor.Sign): AbstractNumberDescriptor.Order

o_NumericCompareToInteger

abstract fun o_NumericCompareToInteger(self: AvailObject, anInteger: AvailObject): AbstractNumberDescriptor.Order

o_NumLiterals

abstract fun o_NumLiterals(self: AvailObject): Int

o_NumLocals

abstract fun o_NumLocals(self: AvailObject): Int

o_NumNybbles

abstract fun o_NumNybbles(self: AvailObject): Int

o_NumOuters

abstract fun o_NumOuters(self: AvailObject): Int

o_NumOuterVars

abstract fun o_NumOuterVars(self: AvailObject): Int

o_NumSlots

abstract fun o_NumSlots(self: AvailObject): Int

o_Nybbles

abstract fun o_Nybbles(self: AvailObject): A_Tuple

o_ObjectTypeVariant

abstract fun o_ObjectTypeVariant(self: AvailObject): ObjectLayoutVariant

o_ObjectVariant

abstract fun o_ObjectVariant(self: AvailObject): ObjectLayoutVariant

o_OptionallyNilOuterVar

abstract fun o_OptionallyNilOuterVar(self: AvailObject, index: Int): Boolean

o_OriginatingPhrase

abstract fun o_OriginatingPhrase(self: AvailObject): A_Phrase

o_OriginatingPhraseAtIndex

abstract fun o_OriginatingPhraseAtIndex(self: AvailObject, index: Int): A_Phrase

o_OriginatingPhraseIndex

abstract fun o_OriginatingPhraseIndex(self: AvailObject): Int

o_OuterTypeAt

abstract fun o_OuterTypeAt(self: AvailObject, index: Int): A_Type

o_OuterVarAt

abstract fun o_OuterVarAt(self: AvailObject, index: Int): AvailObject

o_OuterVarAtPut

abstract fun o_OuterVarAtPut( self: AvailObject, index: Int, value: AvailObject)

o_OutputPhrase

abstract fun o_OutputPhrase(self: AvailObject): A_Phrase

o_PackedDeclarationNames

abstract fun o_PackedDeclarationNames(self: AvailObject): A_String

o_ParallelStream

abstract fun o_ParallelStream(self: AvailObject): Stream<AvailObject>

o_Parent

abstract fun o_Parent(self: AvailObject): A_BasicObject

o_ParsingInstructions

abstract fun o_ParsingInstructions(self: AvailObject): A_Tuple

o_ParsingPc

abstract fun o_ParsingPc(self: AvailObject): Int

o_ParsingPlan

abstract fun o_ParsingPlan(self: AvailObject): A_DefinitionParsingPlan

o_ParsingSignature

abstract fun o_ParsingSignature(self: AvailObject): A_Type

o_Pc

abstract fun o_Pc(self: AvailObject): Int

o_Permutation

abstract fun o_Permutation(self: AvailObject): A_Tuple

o_PhraseExpressionType

abstract fun o_PhraseExpressionType(self: AvailObject): A_Type

o_PhraseKind

abstract fun o_PhraseKind(self: AvailObject): PhraseTypeDescriptor.PhraseKind

o_PhraseKindIsUnder

abstract fun o_PhraseKindIsUnder(self: AvailObject, expectedPhraseKind: PhraseTypeDescriptor.PhraseKind): Boolean

o_PhrasePathRecord

abstract fun o_PhrasePathRecord(self: AvailObject): Repository.PhrasePathRecord

o_PhraseTypeExpressionType

abstract fun o_PhraseTypeExpressionType(self: AvailObject): A_Type

o_PlusCanDestroy

abstract fun o_PlusCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Add the operands and answer the result.

o_PojoSelfType

abstract fun o_PojoSelfType(self: AvailObject): A_Type

o_PrefixFunctions

abstract fun o_PrefixFunctions(self: AvailObject): A_Tuple

o_Primitive

abstract fun o_Primitive(self: AvailObject): Primitive?

o_Priority

abstract fun o_Priority(self: AvailObject): Int

o_PrivateNames

abstract fun o_PrivateNames(self: AvailObject): A_Map

o_RangeIncludesLong

abstract fun o_RangeIncludesLong(self: AvailObject, aLong: Long): Boolean

o_RawByteForCharacterAt

abstract fun o_RawByteForCharacterAt(self: AvailObject, index: Int): Short

o_RawPojo

abstract fun o_RawPojo(self: AvailObject): AvailObject

o_RawSignedIntegerAt

abstract fun o_RawSignedIntegerAt(self: AvailObject, index: Int): Int

o_RawSignedIntegerAtPut

abstract fun o_RawSignedIntegerAtPut( self: AvailObject, index: Int, value: Int)

o_RawUnsignedIntegerAt

abstract fun o_RawUnsignedIntegerAt(self: AvailObject, index: Int): Long

o_RawUnsignedIntegerAtPut

abstract fun o_RawUnsignedIntegerAtPut( self: AvailObject, index: Int, value: Int)

o_ReadType

abstract fun o_ReadType(self: AvailObject): A_Type

o_RecordBlockPhrase

abstract fun o_RecordBlockPhrase(self: AvailObject, blockPhrase: A_Phrase): Int

o_RecordVariableAccess

abstract fun o_RecordVariableAccess( self: AvailObject, variable: A_Variable, wasRead: Boolean)

o_RegisterDump

abstract fun o_RegisterDump(self: AvailObject): AvailObject

o_ReleaseFromDebugger

abstract fun o_ReleaseFromDebugger(self: AvailObject)

o_RemoveDefinition

abstract fun o_RemoveDefinition(self: AvailObject, definition: A_Definition)

o_RemoveDependentChunk

abstract fun o_RemoveDependentChunk(self: AvailObject, chunk: L2Chunk)

o_RemoveFrom

abstract fun o_RemoveFrom( self: AvailObject, loader: AvailLoader, afterRemoval: () -> Unit)

o_RemoveGrammaticalRestriction

abstract fun o_RemoveGrammaticalRestriction(self: AvailObject, obsoleteRestriction: A_GrammaticalRestriction)

o_RemoveMacro

abstract fun o_RemoveMacro(self: AvailObject, macro: A_Macro)

o_RemovePlanForSendable

abstract fun o_RemovePlanForSendable(self: AvailObject, sendable: A_Sendable)

o_RemovePlanInProgress

abstract fun o_RemovePlanInProgress(self: AvailObject, planInProgress: A_ParsingPlanInProgress)

o_RemoveSealedArgumentsType

abstract fun o_RemoveSealedArgumentsType(self: AvailObject, typeTuple: A_Tuple)

o_RemoveSemanticRestriction

abstract fun o_RemoveSemanticRestriction(self: AvailObject, restriction: A_SemanticRestriction)

o_RemoveWriteReactor

abstract fun o_RemoveWriteReactor(self: AvailObject, key: A_Atom)

o_ReplaceFirstChild

abstract fun o_ReplaceFirstChild(self: AvailObject, newFirst: A_Tuple): A_Tuple

o_ReplacingCaller

abstract fun o_ReplacingCaller(self: AvailObject, newCaller: A_Continuation): A_Continuation

o_RepresentationCostOfTupleType

abstract fun o_RepresentationCostOfTupleType(self: AvailObject): Int

Given two objects that are known to be equal, the second of which is in the form of a tuple type, is the first one in a better form than the second one?

o_ResolveForward

abstract fun o_ResolveForward(self: AvailObject, forwardDefinition: A_BasicObject)

o_RestrictedBundle

abstract fun o_RestrictedBundle(self: AvailObject): A_Bundle

o_ResultContinuation

abstract fun o_ResultContinuation(self: AvailObject): (AvailObject) -> Unit

o_ResultType

abstract fun o_ResultType(self: AvailObject): A_Type

o_ReturneeCheckStat

abstract fun o_ReturneeCheckStat(self: AvailObject): Statistic

o_ReturnerCheckStat

abstract fun o_ReturnerCheckStat(self: AvailObject): Statistic

o_ReturnType

abstract fun o_ReturnType(self: AvailObject): A_Type

o_ReturnTypeIfPrimitiveFails

abstract fun o_ReturnTypeIfPrimitiveFails(self: AvailObject): A_Type

o_SealedArgumentsTypesTuple

abstract fun o_SealedArgumentsTypesTuple(self: AvailObject): A_Tuple

o_SemanticRestrictions

abstract fun o_SemanticRestrictions(self: AvailObject): A_Set

Return the method's tuple of functions that statically restrict call sites by argument type.

o_Sequence

abstract fun o_Sequence(self: AvailObject): A_Phrase

o_SerializedObjects

abstract fun o_SerializedObjects(self: AvailObject, serializedObjects: A_Tuple)

o_SerializerOperation

abstract fun o_SerializerOperation(self: AvailObject): SerializerOperation

o_SetAtomBundle

abstract fun o_SetAtomBundle(self: AvailObject, bundle: A_Bundle)

o_SetAtomProperty

abstract fun o_SetAtomProperty( self: AvailObject, key: A_Atom, value: A_BasicObject)

o_SetAvailLoader

abstract fun o_SetAvailLoader(self: AvailObject, loader: AvailLoader?)

o_SetBinAddingElementHashLevelCanDestroy

abstract fun o_SetBinAddingElementHashLevelCanDestroy( self: AvailObject, elementObject: A_BasicObject, elementObjectHash: Int, myLevel: Int, canDestroy: Boolean): A_SetBin

o_SetBinHash

abstract fun o_SetBinHash(self: AvailObject): Int

o_SetBinIterator

abstract fun o_SetBinIterator(self: AvailObject): SetDescriptor.SetIterator

o_SetBinSize

abstract fun o_SetBinSize(self: AvailObject): Int

o_SetBinUnion

abstract fun o_SetBinUnion( self: AvailObject, otherBin: A_SetBin, level: Int): A_SetBin

o_SetBinUnionWithHashedBin

abstract fun o_SetBinUnionWithHashedBin( self: AvailObject, hashedBin: AvailObject, level: Int): A_SetBin

o_SetBinUnionWithLinearBin

abstract fun o_SetBinUnionWithLinearBin( self: AvailObject, linearBin: AvailObject, level: Int): A_SetBin

o_SetContinuation

abstract fun o_SetContinuation(self: AvailObject, value: A_Continuation)

o_SetCurrentModule

abstract fun o_SetCurrentModule(self: AvailObject, currentModule: A_Module)

o_SetElementsAreAllInstancesOfKind

abstract fun o_SetElementsAreAllInstancesOfKind(self: AvailObject, kind: AvailObject): Boolean

o_SetExecutionState

abstract fun o_SetExecutionState(self: AvailObject, value: FiberDescriptor.ExecutionState)

o_SetFiberGlobals

abstract fun o_SetFiberGlobals(self: AvailObject, globals: A_Map)

o_SetFiberResult

abstract fun o_SetFiberResult(self: AvailObject, result: A_BasicObject)

o_SetGeneralFlag

abstract fun o_SetGeneralFlag(self: AvailObject, flag: FiberDescriptor.GeneralFlag)

o_SetHashOrZero

abstract fun o_SetHashOrZero(self: AvailObject, value: Int)

o_SetHeritableFiberGlobals

abstract fun o_SetHeritableFiberGlobals(self: AvailObject, globals: A_Map)

o_SetInterruptRequestFlag

abstract fun o_SetInterruptRequestFlag(self: AvailObject, flag: FiberDescriptor.InterruptRequestFlag)

o_SetIntersectionCanDestroy

abstract fun o_SetIntersectionCanDestroy( self: AvailObject, otherSet: A_Set, canDestroy: Boolean): A_Set

o_SetIntersects

abstract fun o_SetIntersects(self: AvailObject, otherSet: A_Set): Boolean

o_SetJoiningFibers

abstract fun o_SetJoiningFibers(self: AvailObject, joiners: A_Set)

o_SetLexer

abstract fun o_SetLexer(self: AvailObject, lexer: A_Lexer)

o_SetLexerApplicability

abstract fun o_SetLexerApplicability( self: AvailObject, codePoint: Int, applicability: Boolean)

o_SetManifestEntriesIndex

abstract fun o_SetManifestEntriesIndex(self: AvailObject, recordNumber: Long)

o_SetMethodName

abstract fun o_SetMethodName(self: AvailObject, methodName: A_String)

o_SetMinusCanDestroy

abstract fun o_SetMinusCanDestroy( self: AvailObject, otherSet: A_Set, canDestroy: Boolean): A_Set

o_SetModuleState

abstract fun o_SetModuleState(self: AvailObject, newState: ModuleDescriptor.State)

o_SetNextLexingStateFromPrior

abstract fun o_SetNextLexingStateFromPrior(self: AvailObject, priorLexingState: LexingState)

o_SetOriginatingPhraseIndex

abstract fun o_SetOriginatingPhraseIndex(self: AvailObject, index: Int)

o_SetPhrasePathRecordIndex

abstract fun o_SetPhrasePathRecordIndex(self: AvailObject, recordNumber: Long)

o_SetPriority

abstract fun o_SetPriority(self: AvailObject, value: Int)

o_SetSize

abstract fun o_SetSize(self: AvailObject): Int

o_SetStartingChunkAndReoptimizationCountdown

abstract fun o_SetStartingChunkAndReoptimizationCountdown( self: AvailObject, chunk: L2Chunk, countdown: Long)

o_SetStylingRecordIndex

abstract fun o_SetStylingRecordIndex(self: AvailObject, recordNumber: Long)

o_SetSuccessAndFailure

abstract fun o_SetSuccessAndFailure( self: AvailObject, onSuccess: (AvailObject) -> Unit, onFailure: (Throwable) -> Unit)

o_SetSuspendingFunction

abstract fun o_SetSuspendingFunction(self: AvailObject, suspendingFunction: A_Function)

o_SetTextInterface

abstract fun o_SetTextInterface(self: AvailObject, textInterface: TextInterface)

o_SetTraceFlag

abstract fun o_SetTraceFlag(self: AvailObject, flag: FiberDescriptor.TraceFlag)

o_SetUnionCanDestroy

abstract fun o_SetUnionCanDestroy( self: AvailObject, otherSet: A_Set, canDestroy: Boolean): A_Set

o_SetValue

abstract fun o_SetValue(self: AvailObject, newValue: A_BasicObject)

o_SetValueNoCheck

abstract fun o_SetValueNoCheck(self: AvailObject, newValue: A_BasicObject)

o_SetValueWasStablyComputed

abstract fun o_SetValueWasStablyComputed(self: AvailObject, wasStablyComputed: Boolean)

o_SetWakeupTask

abstract fun o_SetWakeupTask(self: AvailObject, task: TimerTask?)

o_SetWithElementCanDestroy

abstract fun o_SetWithElementCanDestroy( self: AvailObject, newElementObject: A_BasicObject, canDestroy: Boolean): A_Set

o_SetWithoutElementCanDestroy

abstract fun o_SetWithoutElementCanDestroy( self: AvailObject, elementObjectToExclude: A_BasicObject, canDestroy: Boolean): A_Set

o_ShortModuleNameNative

abstract fun o_ShortModuleNameNative(self: AvailObject): String

o_ShowValueInNameForDebugger

open fun o_ShowValueInNameForDebugger(self: AvailObject): Boolean

o_SizeRange

abstract fun o_SizeRange(self: AvailObject): A_Type

o_Spliterator

abstract fun o_Spliterator(self: AvailObject): Spliterator<AvailObject>

o_StackAt

abstract fun o_StackAt(self: AvailObject, slotIndex: Int): AvailObject

o_Stackp

abstract fun o_Stackp(self: AvailObject): Int

o_Start

abstract fun o_Start(self: AvailObject): Int

o_StartingChunk

abstract fun o_StartingChunk(self: AvailObject): L2Chunk

o_StartingLineNumber

abstract fun o_StartingLineNumber(self: AvailObject): Int

o_Statements

abstract fun o_Statements(self: AvailObject): A_Tuple

o_StatementsDo

abstract fun o_StatementsDo(self: AvailObject, continuation: (A_Phrase) -> Unit)

o_StatementsTuple

abstract fun o_StatementsTuple(self: AvailObject): A_Tuple

o_Stream

abstract fun o_Stream(self: AvailObject): Stream<AvailObject>

o_String

abstract fun o_String(self: AvailObject): A_String

o_StripMacro

abstract fun o_StripMacro(self: AvailObject): A_Phrase

o_StylerMethod

abstract fun o_StylerMethod(self: AvailObject): A_Method

o_StylingRecord

abstract fun o_StylingRecord(self: AvailObject): Repository.StylingRecord

o_SubexpressionsTupleType

abstract fun o_SubexpressionsTupleType(self: AvailObject): A_Type

o_SubtractFromDoubleCanDestroy

abstract fun o_SubtractFromDoubleCanDestroy( self: AvailObject, doubleObject: A_Number, canDestroy: Boolean): A_Number

o_SubtractFromFloatCanDestroy

abstract fun o_SubtractFromFloatCanDestroy( self: AvailObject, floatObject: A_Number, canDestroy: Boolean): A_Number

o_SubtractFromInfinityCanDestroy

abstract fun o_SubtractFromInfinityCanDestroy( self: AvailObject, sign: AbstractNumberDescriptor.Sign, canDestroy: Boolean): A_Number

Difference the operands and answer the result.

o_SubtractFromIntegerCanDestroy

abstract fun o_SubtractFromIntegerCanDestroy( self: AvailObject, anInteger: AvailObject, canDestroy: Boolean): A_Number

Difference the operands and answer the result.

o_SuperUnionType

abstract fun o_SuperUnionType(self: AvailObject): A_Type

o_SuspendingFunction

abstract fun o_SuspendingFunction(self: AvailObject): A_Function

o_SynthesizeCurrentLexingState

abstract fun o_SynthesizeCurrentLexingState(self: AvailObject): LexingState

o_TallyInvocation

abstract fun o_TallyInvocation(self: AvailObject)

o_TestingTree

abstract fun o_TestingTree(self: AvailObject): LookupTree<A_Definition, A_Tuple>

o_TextInterface

abstract fun o_TextInterface(self: AvailObject): TextInterface

o_TimesCanDestroy

abstract fun o_TimesCanDestroy( self: AvailObject, aNumber: A_Number, canDestroy: Boolean): A_Number

Multiply the operands and answer the result.

o_Token

abstract fun o_Token(self: AvailObject): A_Token

o_TokenIndicesInName

abstract fun o_TokenIndicesInName(self: AvailObject): A_Tuple

o_Tokens

abstract fun o_Tokens(self: AvailObject): A_Tuple

o_TokenType

abstract fun o_TokenType(self: AvailObject): TokenDescriptor.TokenType

o_TotalInvocations

abstract fun o_TotalInvocations(self: AvailObject): Long

o_TraceFlag

abstract fun o_TraceFlag(self: AvailObject, flag: FiberDescriptor.TraceFlag): Boolean

o_TransferIntoByteBuffer

abstract fun o_TransferIntoByteBuffer( self: AvailObject, startIndex: Int, endIndex: Int, outputByteBuffer: ByteBuffer)

o_Traversed

abstract fun o_Traversed(self: AvailObject): AvailObject

o_TraversedWhileMakingImmutable

abstract fun o_TraversedWhileMakingImmutable(self: AvailObject): AvailObject

o_TraversedWhileMakingShared

abstract fun o_TraversedWhileMakingShared(self: AvailObject): AvailObject

o_TreeTupleLevel

abstract fun o_TreeTupleLevel(self: AvailObject): Int

o_TrimExcessInts

abstract fun o_TrimExcessInts(self: AvailObject)

o_TrimType

abstract fun o_TrimType(self: AvailObject, typeToRemove: A_Type): A_Type

o_TrueNamesForStringName

abstract fun o_TrueNamesForStringName(self: AvailObject, stringName: A_String): A_Set

o_TupleAt

abstract fun o_TupleAt(self: AvailObject, index: Int): AvailObject

o_TupleAtPuttingCanDestroy

abstract fun o_TupleAtPuttingCanDestroy( self: AvailObject, index: Int, newValueObject: A_BasicObject, canDestroy: Boolean): A_Tuple

o_TupleCodePointAt

abstract fun o_TupleCodePointAt(self: AvailObject, index: Int): Int

o_TupleElementsInRangeAreInstancesOf

abstract fun o_TupleElementsInRangeAreInstancesOf( self: AvailObject, startIndex: Int, endIndex: Int, type: A_Type): Boolean

o_TupleIntAt

abstract fun o_TupleIntAt(self: AvailObject, index: Int): Int

o_TupleLongAt

abstract fun o_TupleLongAt(self: AvailObject, index: Int): Long

o_TupleOfTypesFromTo

abstract fun o_TupleOfTypesFromTo( self: AvailObject, startIndex: Int, endIndex: Int): A_Tuple

o_TupleReverse

abstract fun o_TupleReverse(self: AvailObject): A_Tuple

o_TupleSize

abstract fun o_TupleSize(self: AvailObject): Int

o_TypeAtIndex

abstract fun o_TypeAtIndex(self: AvailObject, index: Int): A_Type

o_TypeExpression

abstract fun o_TypeExpression(self: AvailObject): A_Phrase

o_TypeIntersection

abstract fun o_TypeIntersection(self: AvailObject, another: A_Type): A_Type

o_TypeIntersectionOfCompiledCodeType

abstract fun o_TypeIntersectionOfCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): A_Type

o_TypeIntersectionOfContinuationType

abstract fun o_TypeIntersectionOfContinuationType(self: AvailObject, aContinuationType: A_Type): A_Type

o_TypeIntersectionOfFiberType

abstract fun o_TypeIntersectionOfFiberType(self: AvailObject, aFiberType: A_Type): A_Type

o_TypeIntersectionOfFunctionType

abstract fun o_TypeIntersectionOfFunctionType(self: AvailObject, aFunctionType: A_Type): A_Type

o_TypeIntersectionOfIntegerRangeType

abstract fun o_TypeIntersectionOfIntegerRangeType(self: AvailObject, anIntegerRangeType: A_Type): A_Type

o_TypeIntersectionOfListNodeType

abstract fun o_TypeIntersectionOfListNodeType(self: AvailObject, aListNodeType: A_Type): A_Type

o_TypeIntersectionOfLiteralTokenType

abstract fun o_TypeIntersectionOfLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): A_Type

o_TypeIntersectionOfMapType

abstract fun o_TypeIntersectionOfMapType(self: AvailObject, aMapType: A_Type): A_Type

o_TypeIntersectionOfObjectType

abstract fun o_TypeIntersectionOfObjectType(self: AvailObject, anObjectType: AvailObject): A_Type

o_TypeIntersectionOfPhraseType

abstract fun o_TypeIntersectionOfPhraseType(self: AvailObject, aPhraseType: A_Type): A_Type

o_TypeIntersectionOfPojoFusedType

abstract fun o_TypeIntersectionOfPojoFusedType(self: AvailObject, aFusedPojoType: A_Type): A_Type

o_TypeIntersectionOfPojoType

abstract fun o_TypeIntersectionOfPojoType(self: AvailObject, aPojoType: A_Type): A_Type

o_TypeIntersectionOfPojoUnfusedType

abstract fun o_TypeIntersectionOfPojoUnfusedType(self: AvailObject, anUnfusedPojoType: A_Type): A_Type

o_TypeIntersectionOfPrimitiveTypeEnum

abstract fun o_TypeIntersectionOfPrimitiveTypeEnum(self: AvailObject, primitiveTypeEnum: PrimitiveTypeDescriptor.Types): A_Type

o_TypeIntersectionOfSetType

abstract fun o_TypeIntersectionOfSetType(self: AvailObject, aSetType: A_Type): A_Type

o_TypeIntersectionOfTokenType

abstract fun o_TypeIntersectionOfTokenType(self: AvailObject, aTokenType: A_Type): A_Type

o_TypeIntersectionOfTupleType

abstract fun o_TypeIntersectionOfTupleType(self: AvailObject, aTupleType: A_Type): A_Type

o_TypeIntersectionOfVariableType

abstract fun o_TypeIntersectionOfVariableType(self: AvailObject, aVariableType: A_Type): A_Type

o_TypeTuple

abstract fun o_TypeTuple(self: AvailObject): A_Tuple

o_TypeUnion

abstract fun o_TypeUnion(self: AvailObject, another: A_Type): A_Type

o_TypeUnionOfCompiledCodeType

abstract fun o_TypeUnionOfCompiledCodeType(self: AvailObject, aCompiledCodeType: A_Type): A_Type

o_TypeUnionOfContinuationType

abstract fun o_TypeUnionOfContinuationType(self: AvailObject, aContinuationType: A_Type): A_Type

o_TypeUnionOfFiberType

abstract fun o_TypeUnionOfFiberType(self: AvailObject, aFiberType: A_Type): A_Type

o_TypeUnionOfFunctionType

abstract fun o_TypeUnionOfFunctionType(self: AvailObject, aFunctionType: A_Type): A_Type

o_TypeUnionOfIntegerRangeType

abstract fun o_TypeUnionOfIntegerRangeType(self: AvailObject, anIntegerRangeType: A_Type): A_Type

o_TypeUnionOfListNodeType

abstract fun o_TypeUnionOfListNodeType(self: AvailObject, aListNodeType: A_Type): A_Type

o_TypeUnionOfLiteralTokenType

abstract fun o_TypeUnionOfLiteralTokenType(self: AvailObject, aLiteralTokenType: A_Type): A_Type

o_TypeUnionOfMapType

abstract fun o_TypeUnionOfMapType(self: AvailObject, aMapType: A_Type): A_Type

o_TypeUnionOfObjectType

abstract fun o_TypeUnionOfObjectType(self: AvailObject, anObjectType: AvailObject): A_Type

o_TypeUnionOfPhraseType

abstract fun o_TypeUnionOfPhraseType(self: AvailObject, aPhraseType: A_Type): A_Type

o_TypeUnionOfPojoFusedType

abstract fun o_TypeUnionOfPojoFusedType(self: AvailObject, aFusedPojoType: A_Type): A_Type

o_TypeUnionOfPojoType

abstract fun o_TypeUnionOfPojoType(self: AvailObject, aPojoType: A_Type): A_Type

o_TypeUnionOfPojoUnfusedType

abstract fun o_TypeUnionOfPojoUnfusedType(self: AvailObject, anUnfusedPojoType: A_Type): A_Type

o_TypeUnionOfPrimitiveTypeEnum

abstract fun o_TypeUnionOfPrimitiveTypeEnum(self: AvailObject, primitiveTypeEnum: PrimitiveTypeDescriptor.Types): A_Type

o_TypeUnionOfSetType

abstract fun o_TypeUnionOfSetType(self: AvailObject, aSetType: A_Type): A_Type

o_TypeUnionOfTokenType

abstract fun o_TypeUnionOfTokenType(self: AvailObject, aTokenType: A_Type): A_Type

o_TypeUnionOfTupleType

abstract fun o_TypeUnionOfTupleType(self: AvailObject, aTupleType: A_Type): A_Type

o_TypeUnionOfVariableType

abstract fun o_TypeUnionOfVariableType(self: AvailObject, aVariableType: A_Type): A_Type

o_TypeVariables

abstract fun o_TypeVariables(self: AvailObject): A_Map

o_UnionOfTypesAtThrough

abstract fun o_UnionOfTypesAtThrough( self: AvailObject, startIndex: Int, endIndex: Int): A_Type

o_UniqueId

abstract fun o_UniqueId(self: AvailObject): Long

o_UpdateForNewGrammaticalRestriction

abstract fun o_UpdateForNewGrammaticalRestriction( self: AvailObject, planInProgress: A_ParsingPlanInProgress, treesToVisit: Deque<Pair<A_BundleTree, A_ParsingPlanInProgress>>)

o_UpdateStylers

abstract fun o_UpdateStylers(self: AvailObject, updater: A_Set.() -> A_Set)

o_UpperBound

abstract fun o_UpperBound(self: AvailObject): A_Number

o_UpperInclusive

abstract fun o_UpperInclusive(self: AvailObject): Boolean

o_ValidateLocally

abstract fun o_ValidateLocally(self: AvailObject)

o_ValidWriteReactorFunctions

abstract fun o_ValidWriteReactorFunctions(self: AvailObject): A_Set

o_Value

abstract fun o_Value(self: AvailObject): AvailObject

o_ValuesAsTuple

abstract fun o_ValuesAsTuple(self: AvailObject): A_Tuple

o_ValueType

abstract fun o_ValueType(self: AvailObject): A_Type

o_ValueWasStablyComputed

abstract fun o_ValueWasStablyComputed(self: AvailObject): Boolean

o_Variable

abstract fun o_Variable(self: AvailObject): A_Phrase

o_VariableBindings

abstract fun o_VariableBindings(self: AvailObject): A_Map

o_VariableMapHasKey

abstract fun o_VariableMapHasKey(self: AvailObject, key: A_BasicObject): Boolean

o_VariablesReadBeforeWritten

abstract fun o_VariablesReadBeforeWritten(self: AvailObject): A_Set

o_VariablesWritten

abstract fun o_VariablesWritten(self: AvailObject): A_Set

o_Versions

abstract fun o_Versions(self: AvailObject): A_Set

o_VisibleNames

abstract fun o_VisibleNames(self: AvailObject): A_Set

o_WakeupTask

abstract fun o_WakeupTask(self: AvailObject): TimerTask?

o_WhenContinuationIsAvailableDo

abstract fun o_WhenContinuationIsAvailableDo(self: AvailObject, whenReified: (A_Continuation) -> Unit)

o_WhichPowerOfTwo

abstract fun o_WhichPowerOfTwo(self: AvailObject): Int

o_WriteSummaryTo

abstract fun o_WriteSummaryTo(self: AvailObject, writer: JSONWriter)

o_WriteTo

abstract fun o_WriteTo(self: AvailObject, writer: JSONWriter)

o_WriteType

abstract fun o_WriteType(self: AvailObject): A_Type

printObjectOnAvoidingIndent

open fun printObjectOnAvoidingIndent( self: AvailObject, builder: StringBuilder, recursionMap: IdentityHashMap<A_BasicObject, Void>, indent: Int)

Print the object to the StringBuilder. By default show it as the descriptor's name and a line-by-line list of fields. If the indent is beyond the maximumIndent, indicate it's too deep without recursing. If the object is in the specified recursion list, indicate a recursive print and return.

shared

abstract fun shared(): AbstractDescriptor

Answer the shared version of this descriptor.

toString

open override fun toString(): String

unsupportedOperation

fun unsupportedOperation(): Nothing

Throw an AvailUnsupportedOperationException suitable to be thrown by the sender.

Properties

allocationStat

val allocationStat: Statistic

A Statistic that records the number and size of each allocation.

debugIntegerSlots

val debugIntegerSlots: Array<Array<IntegerSlotsEnum>?>

Used for quickly checking integer fields when AvailObjectRepresentation.shouldCheckSlots is enabled.

debugObjectSlots

val debugObjectSlots: Array<Array<ObjectSlotsEnum>?>

Used for quickly checking object fields when AvailObjectRepresentation.shouldCheckSlots is enabled.

isMutable

val isMutable: Boolean

Are objects using this descriptor mutable?

isShared

val isShared: Boolean

Are objects using this descriptor shared?

mutability

val mutability: Mutability

The mutability of my instances.

numberOfFixedIntegerSlots

val numberOfFixedIntegerSlots: Int

The minimum number of integer slots an AvailObject can have if it uses this descriptor. Does not include indexed slots possibly at the end. Populated automatically by the constructor.

numberOfFixedObjectSlots

val numberOfFixedObjectSlots: Int

The minimum number of object slots an AvailObject can have if it uses this descriptor. Does not include indexed slots possibly at the end. Populated automatically by the constructor.

typeTag

val typeTag: TypeTag

Every descriptor has this field, and clients can access it directly to quickly determine the basic type of any value having that descriptor. This is purely an optimization for fast type checking and dispatching.

unsupported

val unsupported: Nothing

This read-only property can be used in place of unsupportedOperation. Using the getter produces almost the same diagnostic stack trace when executed, but is a much shorter expression.

Inheritors

Descriptor

IndirectionDescriptor