avail/avail.dispatch/ExtractObjectFieldDecisionStep

ExtractObjectFieldDecisionStep

class ExtractObjectFieldDecisionStep<Element : A_BasicObject, Result : A_BasicObject>( argumentPositionToTest: Int, field: A_Atom, fieldIndex: Int, childNode: InternalLookupTree<Element, Result>) : DecisionStep<Element, Result>

This is a DecisionStep which extracts one field from an argument or extra, and adds it to the list of extras, for subsequent dispatching. This new value should have a useful subsequent dispatching power, otherwise there would be no point in extracting it.

The InternalLookupTree containing this step will have exactly one child.

Constructors

fun <Element : A_BasicObject, Result : A_BasicObject> ExtractObjectFieldDecisionStep( argumentPositionToTest: Int, field: A_Atom, fieldIndex: Int, childNode: InternalLookupTree<Element, Result>)

Construct the new instance.

Functions

addChildrenTo

open override fun addChildrenTo( list: MutableList<Pair<LookupTree<Element, Result>, List<L2SemanticValue>>>, semanticValues: List<L2SemanticValue>, extraSemanticValues: List<L2SemanticValue>)

Add the children LookupTrees, coupled with the available L2SemanticValues at that point, to the given list.

describe

open override fun describe( node: InternalLookupTree<Element, Result>, indent: Int, builder: StringBuilder)

Output a description of this step on the given builder. Do not expand any subtrees that are still lazy.

extractArgument

fun extractArgument(argValues: List<A_BasicObject>, extraValues: List<A_BasicObject>): AvailObject

extractArgumentType

fun extractArgumentType(argTypes: A_Tuple, extraValues: List<A_Type>): AvailObject

fun extractArgumentType(argTypes: List<A_Type>, extraValues: List<A_Type>): AvailObject

extractValue

fun extractValue(probeValue: A_BasicObject, extraValues: List<A_BasicObject>): AvailObject

generateEdgesFor

open override fun generateEdgesFor( semanticArguments: List<L2SemanticValue>, extraSemanticArguments: List<L2SemanticValue>, callSiteHelper: L1Translator.CallSiteHelper): List<Triple<L2BasicBlock, LookupTree<A_Definition, A_Tuple>, List<L2SemanticValue>>>

Generate suitable branch instructions via the CallSiteHelper, and answer a list of Triples that coordinate each target L2BasicBlock with the LookupTree responsible for generating code in that block, plus the list of extra L2SemanticValues that will be present at that block.

lookupStepByTypes

open override fun <AdaptorMemento> lookupStepByTypes( argTypes: A_Tuple, extraValues: List<A_Type>, adaptor: LookupTreeAdaptor<Element, Result, AdaptorMemento>, memento: AdaptorMemento): LookupTree<Element, Result>

Perform one step of looking up the most-specific Result that matches the provided tuple of argument types. Answer another LookupTree with which to continue the search.

open override fun <AdaptorMemento> lookupStepByTypes( argTypes: List<A_Type>, extraValues: List<A_Type>, adaptor: LookupTreeAdaptor<Element, Result, AdaptorMemento>, memento: AdaptorMemento): LookupTree<Element, Result>

Perform one step of looking up the most-specific Result that matches the provided list of argument types. Answer another LookupTree with which to continue the search.

lookupStepByValue

open override fun <AdaptorMemento> lookupStepByValue( probeValue: A_BasicObject, extraValues: List<A_BasicObject>, adaptor: LookupTreeAdaptor<Element, Result, AdaptorMemento>, memento: AdaptorMemento): LookupTree<Element, Result>

Perform one step of looking up the most-specific Result that matches the provided value. Answer another LookupTree with which to continue the search.

lookupStepByValues

open override fun <AdaptorMemento> lookupStepByValues( argValues: List<A_BasicObject>, extraValues: List<A_BasicObject>, adaptor: LookupTreeAdaptor<Element, Result, AdaptorMemento>, memento: AdaptorMemento): LookupTree<Element, Result>

Perform one step of looking up the most-specific Result that matches the provided list of arguments. Answer another LookupTree with which to continue the search.

simplyAddChildrenTo

open override fun simplyAddChildrenTo(list: MutableList<LookupTree<Element, Result>>)

Add the children LookupTrees to the given list. This can be used for scanning the tree for some condition, without recursion.

sourceSemanticValue

fun sourceSemanticValue(semanticValues: List<L2SemanticValue>, extraSemanticValues: List<L2SemanticValue>): L2SemanticValue

Extract the L2SemanticValue that is providing the value operated on by this step.

updateExtraValuesByTypes

open override fun updateExtraValuesByTypes(argTypes: A_Tuple, extraValues: List<A_Type>): List<A_Type>

open override fun updateExtraValuesByTypes(types: List<A_Type>, extraValues: List<A_Type>): List<A_Type>

Given an optional list of values used to supplement the lookup, answer the updated list of values that takes this step into account. The given and resulting lists must not be modified by subsequent steps.

updateExtraValuesByValue

open override fun updateExtraValuesByValue(probeValue: A_BasicObject, extraValues: List<Element>): List<Element>

updateExtraValuesByValues

open override fun updateExtraValuesByValues(argValues: List<A_BasicObject>, extraValues: List<Element>): List<Element>

updateSignatureExtrasExtractor

open override fun <Memento> updateSignatureExtrasExtractor( adaptor: LookupTreeAdaptor<Element, Result, Memento>, extrasTypeExtractor: (Element) -> Pair<A_Type?, List<A_Type>>, numArgs: Int): (Element) -> Pair<A_Type?, List<A_Type>>

Given a function that produces a list of types from an Element due to an ancestor tree node, produce a new function for producing a lists of types that takes this DecisionStep into account. The function also optionally produces the type signature of the element, for reuse by subsequent wrapped functions.

Properties

argumentPositionToTest

val argumentPositionToTest: Int

The argument position to test. If the index is within bounds for the arguments, use the indicated argument, otherwise index the extraValues as though they were concatenated to the end of the arguments.