Uses of Class
org.ek9lang.compiler.ir.instructions.IRInstr

Packages that use IRInstr

Package	Description
org.ek9lang.compiler.backend.jvm	JVM Bytecode Generation - Transforms EK9 IR into JVM bytecode.
org.ek9lang.compiler.common	Common parts of processing that can be reused across various phases.
org.ek9lang.compiler.ir.data	IR Data Structures - Metadata and detail classes for IR instructions.
org.ek9lang.compiler.ir.instructions	IR Instruction Classes - The instruction set for EK9 intermediate representation.
org.ek9lang.compiler.ir.support	IR Support Utilities - Helper classes for IR generation and processing.
org.ek9lang.compiler.phase7	K - Intermediate Representation Generation.
org.ek9lang.compiler.phase7.calls
org.ek9lang.compiler.phase7.generation
org.ek9lang.compiler.phase7.generator
org.ek9lang.compiler.phase7.support
org.ek9lang.compiler.phase7.synthesis	Synthetic operator and method generation for EK9.
org.ek9lang.compiler.phase7.synthesis.support	Support classes for synthetic operator IR generation.
org.ek9lang.compiler.phase9	M - Intermediate Representation Analysis and Optimization.

Uses of IRInstr in org.ek9lang.compiler.backend.jvm

Methods in org.ek9lang.compiler.backend.jvm that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	LoopCaseData.body()	Returns the value of the body record component.
List<IRInstr>	LoopCaseData.bodySetup()	Returns the value of the bodySetup record component.
List<IRInstr>	LoopCaseData.conditionTemplate()	Returns the value of the conditionTemplate record component.
List<IRInstr>	LoopCaseData.increment()	Returns the value of the increment record component.

Methods in org.ek9lang.compiler.backend.jvm with parameters of type IRInstr

Modifier and Type	Method	Description
void	OutputVisitor.visit(IRInstr irInstr)	Dispatch IRInstr to typed visit methods.

Method parameters in org.ek9lang.compiler.backend.jvm with type arguments of type IRInstr

Modifier and Type	Method	Description
protected void	AbstractControlFlowAsmGenerator.processBodyEvaluation(List<IRInstr> bodyEvaluation)	Process body evaluation instructions via recursive visiting.
protected void	AbstractControlFlowAsmGenerator.processConditionEvaluation(List<IRInstr> conditionEvaluation)	Process condition evaluation instructions via recursive visiting.
protected void	AbstractControlFlowAsmGenerator.processInstructions(List<IRInstr> instructions)	Process list of IR instructions via recursive delegation to OutputVisitor.

Constructor parameters in org.ek9lang.compiler.backend.jvm with type arguments of type IRInstr

Modifier	Constructor	Description
(package private)	LoopCaseData(org.objectweb.asm.Label loopStart, List<IRInstr> conditionTemplate, String conditionPrimitive, List<IRInstr> bodySetup, ForRangePolymorphicInstr.ValueGuard valueGuard, List<IRInstr> body, ForRangePolymorphicInstr.EndCheck endCheck, List<IRInstr> increment, ForRangePolymorphicInstr.ProgressCheck progressCheck, org.objectweb.asm.Label endLabel, String loopScopeId, BytecodeGenerationContext.DispatchCase dispatchCase)	Creates an instance of a LoopCaseData record class.

Uses of IRInstr in org.ek9lang.compiler.common

Methods in org.ek9lang.compiler.common with parameters of type IRInstr

Modifier and Type	Method	Description
default void	INodeVisitor.visit(IRInstr irInstruction)
void	NodePrinter.visit(IRInstr irInstruction)

Uses of IRInstr in org.ek9lang.compiler.ir.data

Methods in org.ek9lang.compiler.ir.data that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	ConditionCaseDetails.bodyEvaluation()	Returns the value of the bodyEvaluation record component.
List<IRInstr>	ConditionCaseDetails.conditionEvaluation()	Returns the value of the conditionEvaluation record component.
List<IRInstr>	ControlFlowChainDetails.defaultBodyEvaluation()	Get default body evaluation instructions.
List<IRInstr>	DefaultCaseDetails.defaultBodyEvaluation()	Returns the value of the defaultBodyEvaluation record component.
List<IRInstr>	ControlFlowChainDetails.evaluationVariableSetup()	Get evaluation variable setup instructions.
List<IRInstr>	EvaluationVariableDetails.evaluationVariableSetup()	Returns the value of the evaluationVariableSetup record component.
List<IRInstr>	ControlFlowChainDetails.finallyBlockEvaluation()	Returns the value of the finallyBlockEvaluation record component.
List<IRInstr>	ControlFlowChainDetails.guardEntryCheck()	Get guard entry check instructions (for WHILE/DO-WHILE loops).
List<IRInstr>	GuardVariableDetails.guardEntryCheck()	Returns the value of the guardEntryCheck record component.
List<IRInstr>	ControlFlowChainDetails.guardScopeSetup()	Get guard scope setup instructions.
List<IRInstr>	GuardVariableDetails.guardScopeSetup()	Returns the value of the guardScopeSetup record component.
List<IRInstr>	ConditionCaseDetails.guardUpdates()	Returns the value of the guardUpdates record component.
List<IRInstr>	ReturnVariableDetails.returnVariableDeclaration()	Returns the value of the returnVariableDeclaration record component.
List<IRInstr>	ReturnVariableDetails.returnVariableInitialisation()	Returns the value of the returnVariableInitialisation record component.
List<IRInstr>	ControlFlowChainDetails.returnVariableSetup()	Get return variable setup instructions.
List<IRInstr>	ReturnVariableDetails.returnVariableSetup()	Instructions to set up the return variable: the declaration, then the initialisation.
List<IRInstr>	ControlFlowChainDetails.tryBodyEvaluation()	Get try body evaluation instructions.
List<IRInstr>	TryBlockDetails.tryBodyEvaluation()	Returns the value of the tryBodyEvaluation record component.

Method parameters in org.ek9lang.compiler.ir.data with type arguments of type IRInstr

Modifier and Type	Method	Description
static ConditionCaseDetails	ConditionCaseDetails.createExceptionHandler(String catchScopeId, String exceptionType, String exceptionVariable, String catchBodyScopeId, List<IRInstr> catchBodyEvaluation, String catchBodyResult)	Create a condition case for exception handlers (try/catch blocks).
static ConditionCaseDetails	ConditionCaseDetails.createExpression(String caseScopeId, List<IRInstr> conditionEvaluation, String conditionResult, String primitiveCondition, List<IRInstr> bodyEvaluation, String bodyResult)	Create a condition case for general boolean expressions (if statements).
static ConditionCaseDetails	ConditionCaseDetails.createLiteral(String caseScopeId, List<IRInstr> conditionEvaluation, String conditionResult, String primitiveCondition, List<IRInstr> bodyEvaluation, String bodyResult)	Create a condition case for literal value comparison (switch literal cases).
static ConditionCaseDetails	ConditionCaseDetails.createNullCheck(String caseScopeId, List<IRInstr> conditionEvaluation, String conditionResult, String primitiveCondition, List<IRInstr> bodyEvaluation, String bodyResult)	Create a condition case for the Question operator null check.
static ControlFlowChainDetails	ControlFlowChainDetails.createSwitchWithGuards(String result, GuardVariableDetails guardDetails, String evaluationVariable, String evaluationVariableType, String returnVariable, String returnVariableType, List<IRInstr> returnVariableSetup, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId)	Create details for a switch statement with guard variable support.
static ReturnVariableDetails	ReturnVariableDetails.withParts(String returnVariable, String returnVariableType, List<IRInstr> returnVariableDeclaration, List<IRInstr> returnVariableInitialisation)	Create return variable details whose setup is known as its two halves - THE structured split a try expression relocates by (FLOW-14a): never re-derive it by scanning the setup's opcodes.
static DefaultCaseDetails	DefaultCaseDetails.withResult(List<IRInstr> defaultBodyEvaluation, String defaultResult)	Create default case details with instructions and result.
static EvaluationVariableDetails	EvaluationVariableDetails.withSetup(String evaluationVariable, String evaluationVariableType, List<IRInstr> evaluationVariableSetup)	Create evaluation variable details with setup instructions.
static ReturnVariableDetails	ReturnVariableDetails.withSetup(String returnVariable, String returnVariableType, List<IRInstr> returnVariableSetup)	Create return variable details with setup instructions that are not split into declaration and initialisation (the whole setup is the initialisation).

Constructor parameters in org.ek9lang.compiler.ir.data with type arguments of type IRInstr

Modifier	Constructor	Description
	ConditionCaseDetails(String caseScopeId, String caseType, List<IRInstr> guardUpdates, String bodyScopeId, String enumConstant, int enumOrdinal, List<IRInstr> conditionEvaluation, String conditionResult, String primitiveCondition, List<IRInstr> bodyEvaluation, String bodyResult, String exceptionType, String exceptionVariable)	Creates an instance of a ConditionCaseDetails record class.
	DefaultCaseDetails(List<IRInstr> defaultBodyEvaluation, String defaultResult)	Creates an instance of a DefaultCaseDetails record class.
	EvaluationVariableDetails(String evaluationVariable, String evaluationVariableType, List<IRInstr> evaluationVariableSetup)	Creates an instance of a EvaluationVariableDetails record class.
	ReturnVariableDetails(String returnVariable, String returnVariableType, List<IRInstr> returnVariableSetup)	Return variable details whose setup is not split (the whole setup is the initialisation) - the record's shape before FLOW-14a, kept so a construction written against it still compiles; prefer ReturnVariableDetails.withSetup(String, String, List).
	ReturnVariableDetails(String returnVariable, String returnVariableType, List<IRInstr> returnVariableDeclaration, List<IRInstr> returnVariableInitialisation)	Creates an instance of a ReturnVariableDetails record class.
	TryBlockDetails(String tryScopeId, List<IRInstr> tryBodyEvaluation, String tryBodyResult, String resourceScopeId)	Creates an instance of a TryBlockDetails record class.

Uses of IRInstr in org.ek9lang.compiler.ir.instructions

Subclasses of IRInstr in org.ek9lang.compiler.ir.instructions

Modifier and Type	Class	Description
final class	AspectProxyInstr	High-level IR instruction for creating an aspect-woven proxy.
final class	AssertThrowsInstr	IR instruction for test-only assertion constructs that wrap expressions in try-catch.
final class	BranchInstr	Specialized IR instruction for control flow operations (BRANCH, BRANCH_TRUE, BRANCH_FALSE, ASSERT, RETURN).
final class	CallInstr	Specialized IR instruction for method calls (CALL, CALL_VIRTUAL, CALL_STATIC, CALL_DISPATCHER).
final class	CancelPointInstr	CANCEL_POINT: a point where an async task the pipeline no longer needs stops (EK9_BACKEND_IR_CONTRACTS.md Contract 24).
final class	CastInstr	IR instruction for explicit type casting.
final class	ControlFlowChainInstr	Unified IR instruction for all EK9 control flow constructs.
final class	CoverageFinalizeInstr	Specialized IR instruction for coverage finalization (COVERAGE_FINALIZE).
final class	CoverageProbeInstr	Specialized IR instruction for coverage probe recording (COVERAGE_PROBE).
final class	CoverageRegisterInstr	Specialized IR instruction for coverage module registration (COVERAGE_REGISTER).
final class	DictLiteralInstr	IR instruction for dict literal construction with pre-sized allocation.
final class	DispatchTableInstr	High-level IR instruction for a precomputed dispatch table.
final class	EnumIteratorImplInstr	High-level IR instruction for generating enum iterator implementation.
final class	ForRangePolymorphicInstr	Specialized IR instruction for EK9 polymorphic for-range loops.
final class	InputClassProbeInstr	Specialised IR instruction for the input-variation numerator (INPUT_CLASS_PROBE).
final class	LabelInstr	Specialized IR instruction for control flow labels (LABEL).
final class	ListLiteralInstr	IR instruction for list literal construction with pre-sized allocation.
final class	LiteralInstr	IR instruction for loading literal/constant values.
final class	LogicalOperationInstr	IR instruction for logical operations (AND/OR) with short-circuit capability.
final class	MemoryInstr	Specialized IR instruction for memory operations (LOAD, STORE, ALLOCA, REFERENCE).
final class	OwnershipInstr	The ownership form of the IR (EK9_IR_OWNERSHIP_MODEL.md §10): OWN, DROP, DROP_AT_EXIT, SLOT_DECLARE, SLOT_ASSIGN, FIELD_ASSIGN.
final class	PrimitiveLiteralInstr	IR instruction for loading primitive literal values (int, boolean, java.lang.String).
final class	ProfilingEntryInstr	Specialized IR instruction for profiling function entry (PROFILING_ENTRY).
final class	ProfilingExitInstr	Specialized IR instruction for profiling function exit (PROFILING_EXIT).
final class	ProgramEntryPointInstr	IR instruction containing all discovered programs and their metadata.
final class	PublishInstr	PUBLISH value, reason[, holder]: from here on the value, and everything it reaches, is shared with runtime threads for as long as the program runs (EK9_NATIVE_CYCLE_COLLECTOR_DESIGN.md §13.11, S2 and S2b; re-investigation F1).
final class	SafePointInstr	SAFE_POINT: a point where the native cycle collector may run (EK9_NATIVE_CYCLE_COLLECTOR_DESIGN.md §14).
final class	SanitizeInstr	IR instruction for sanitizing string values to prevent injection attacks.
final class	ScopeInstr	Specialized IR instruction for scope management (SCOPE_ENTER, SCOPE_EXIT, SCOPE_REGISTER).
final class	StringInterpolationInstr	IR instruction for string interpolation.
final class	ThrowInstr	Specialized IR instruction for throwing exceptions (THROW).

Classes in org.ek9lang.compiler.ir.instructions that implement interfaces with type arguments of type IRInstr

Modifier and Type	Class	Description
final class	ExecutedInstructionsIn	THE flattening of the instructions a back end EXECUTES in an instruction list: every instruction, depth-first through every nested list a back end runs - a chain's condition cases (guardUpdates, conditionEvaluation, bodyEvaluation), its default, try body and finally, and a for-range loop's initialisation, continue condition, direction/condition/setup/guard/increment/progress lists and body (the walk IRConstruct.allBodyInstructions() describes).
final class	ExecutedInstructionsOf	THE executed instructions of one operation (one callable), flattened as ExecutedInstructionsIn describes - the per-callable unit an IR analysis reads.

Methods in org.ek9lang.compiler.ir.instructions that return IRInstr

Modifier and Type	Method	Description
IRInstr	IRInstr.addOperand(String operand)	Add operand to this instruction.
IRInstr	IRInstr.addOperands(String... operands)	Add multiple operands to this instruction.
static IRInstr	LogicalOperationInstr.andOperation(LogicalDetails logicalDetails)	Create logical AND operation.
IRInstr	BasicBlockInstr.getLastInstruction()	Get the last instruction in this block (usually control flow).
static IRInstr	LogicalOperationInstr.orOperation(LogicalDetails logicalDetails)	Create logical OR operation.
IRInstr	AssertThrowsInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	CompositeInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)	A copy with every nested list replaced by rewrite of it - exactly the lists CompositeInstr.nestedLists() reports, in that order; this when no list changed.
IRInstr	ControlFlowChainInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	DictLiteralInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	ForRangePolymorphicInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	ListLiteralInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	LogicalOperationInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	StringInterpolationInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)

Methods in org.ek9lang.compiler.ir.instructions that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	IRConstruct.allBodyInstructions()	THE single IR-tree traversal for this construct: every instruction in every operation body, flattened depth-first through every nested instruction list the back-end executes.
List<IRInstr>	ExecutedInstructionsIn.apply(List<IRInstr> instructions)
List<IRInstr>	ExecutedInstructionsOf.apply(OperationInstr operation)
List<IRInstr>	ForRangePolymorphicInstr.AscendingCase.directionCheck()	Returns the value of the directionCheck record component.
List<IRInstr>	ForRangePolymorphicInstr.DescendingCase.directionCheck()	Returns the value of the directionCheck record component.
List<IRInstr>	ForRangePolymorphicInstr.EqualCase.directionCheck()	Returns the value of the directionCheck record component.
List<IRInstr>	ForRangePolymorphicInstr.ContinueCondition.evaluation()	Returns the value of the evaluation record component.
List<IRInstr>	ForRangePolymorphicInstr.ProgressCheck.evaluation()	Returns the value of the evaluation record component.
List<IRInstr>	ForRangePolymorphicInstr.ValueGuard.evaluation()	Returns the value of the evaluation record component.
List<IRInstr>	ForRangePolymorphicInstr.getBodyInstructions()
List<IRInstr>	ControlFlowChainInstr.getDefaultBodyEvaluation()	Get the default/else case evaluation instructions.
List<IRInstr>	ControlFlowChainInstr.getEvaluationVariableSetup()	The instructions that evaluate this chain's control/evaluation variable (a guard's switch v <- ...).
List<IRInstr>	AssertThrowsInstr.getExpressionBodyInstructions()	Get the expression body instructions to evaluate within the try block.
List<IRInstr>	ControlFlowChainInstr.getFinallyBlockEvaluation()
List<IRInstr>	ForRangePolymorphicInstr.getInitializationInstructions()
List<IRInstr>	BasicBlockInstr.getInstructions()
List<IRInstr>	LogicalOperationInstr.getLeftEvaluationInstructions()	Get the left operand evaluation instructions.
List<IRInstr>	BasicBlockInstr.getMemoryManagementInstructions()	Get all memory management instructions in this block.
List<IRInstr>	BasicBlockInstr.getMethodCalls()	Get all method call instructions in this block.
List<IRInstr>	LogicalOperationInstr.getResultComputationInstructions()	Get the result computation instructions.
List<IRInstr>	ControlFlowChainInstr.getReturnVariableSetup()	The instructions that declare/initialise this chain's RETURN variable (the <- rtn <- ... of an expression-form try/switch/if).
List<IRInstr>	LogicalOperationInstr.getRightEvaluationInstructions()	Get the right operand evaluation instructions.
List<IRInstr>	DictLiteralInstr.getSetupInstructions()	Get the setup instructions (key/value evaluation + memory management).
List<IRInstr>	ListLiteralInstr.getSetupInstructions()	Get the setup instructions (element evaluation + memory management).
List<IRInstr>	StringInterpolationInstr.getSetupInstructions()	Get the setup instructions ($ operator calls for non-String expressions).
List<IRInstr>	CompositeInstr.NestedList.instructions()	Returns the value of the instructions record component.
List<IRInstr>	ForRangePolymorphicInstr.AscendingCase.loopBodySetup()	Returns the value of the loopBodySetup record component.
List<IRInstr>	ForRangePolymorphicInstr.DescendingCase.loopBodySetup()	Returns the value of the loopBodySetup record component.
List<IRInstr>	ForRangePolymorphicInstr.EqualCase.loopBodySetup()	Returns the value of the loopBodySetup record component.
List<IRInstr>	ForRangePolymorphicInstr.AscendingCase.loopConditionTemplate()	Returns the value of the loopConditionTemplate record component.
List<IRInstr>	ForRangePolymorphicInstr.DescendingCase.loopConditionTemplate()	Returns the value of the loopConditionTemplate record component.
List<IRInstr>	ForRangePolymorphicInstr.AscendingCase.loopIncrement()	Returns the value of the loopIncrement record component.
List<IRInstr>	ForRangePolymorphicInstr.DescendingCase.loopIncrement()	Returns the value of the loopIncrement record component.
(package private) List<IRInstr>	PresentNestedLists.rewritten(List<IRInstr> list, UnaryOperator<List<IRInstr>> rewrite)	Null-safe application of a list rewrite: an absent list stays absent.

Methods in org.ek9lang.compiler.ir.instructions with parameters of type IRInstr

Modifier and Type	Method	Description
BasicBlockInstr	BasicBlockInstr.addInstruction(IRInstr instruction)	Add instruction to this basic block.
BasicBlockInstr	BasicBlockInstr.addInstructions(IRInstr... instructions)	Add multiple instructions to this basic block.
BasicBlockInstr	BasicBlockInstr.prependInstruction(IRInstr instruction)	Prepend instruction to the beginning of this basic block.

Method parameters in org.ek9lang.compiler.ir.instructions with type arguments of type IRInstr

Modifier and Type	Method	Description
BasicBlockInstr	BasicBlockInstr.addInstructions(List<IRInstr> instructions)	Add multiple instructions from a list.
(package private) void	SetupBlockRendering.appendSetupBlock(StringBuilder sb, String label, List<IRInstr> setupInstructions, String scopeId)	Append a nested setup block, if there is any setup to show.
List<IRInstr>	ExecutedInstructionsIn.apply(List<IRInstr> instructions)
static AssertThrowsInstr	AssertThrowsInstr.assertDoesNotThrow(List<IRInstr> bodyInstructions, String message, String scopeId, DebugInfo debugInfo)	Create ASSERT_DOES_NOT_THROW instruction.
static AssertThrowsInstr	AssertThrowsInstr.assertPanic(String result, List<IRInstr> bodyInstructions, String message, String scopeId, DebugInfo debugInfo)	Create ASSERT_PANIC instruction.
static AssertThrowsInstr	AssertThrowsInstr.assertThrows(String result, String expectedType, List<IRInstr> bodyInstructions, String message, String scopeId, DebugInfo debugInfo)	Create ASSERT_THROWS instruction.
static DictLiteralInstr	DictLiteralInstr.create(String result, List<IRInstr> setupInstructions, DictLiteralDetails details, String scopeId, DebugInfo debugInfo)	Create a dict literal instruction.
static ListLiteralInstr	ListLiteralInstr.create(String result, List<IRInstr> setupInstructions, ListLiteralDetails details, String scopeId, DebugInfo debugInfo)	Create a list literal instruction.
static ForRangePolymorphicInstr	ForRangePolymorphicInstr.forRangePolymorphic(List<IRInstr> initializationInstructions, ForRangePolymorphicInstr.DispatchCases dispatchCases, ForRangePolymorphicInstr.LoopMetadata metadata, List<IRInstr> bodyInstructions, ForRangePolymorphicInstr.ScopeMetadata scopeMetadata, ForRangePolymorphicInstr.ContinueCondition continueCondition, DebugInfo debugInfo)	Create a polymorphic for-range loop instruction whose iterations are also bounded by a ForRangePolymorphicInstr.ContinueCondition (a stream's head: decision 10, rule B).
static ForRangePolymorphicInstr	ForRangePolymorphicInstr.forRangePolymorphic(List<IRInstr> initializationInstructions, ForRangePolymorphicInstr.DispatchCases dispatchCases, ForRangePolymorphicInstr.LoopMetadata metadata, List<IRInstr> bodyInstructions, ForRangePolymorphicInstr.ScopeMetadata scopeMetadata, DebugInfo debugInfo)	Create a polymorphic for-range loop instruction.
static StringInterpolationInstr	StringInterpolationInstr.interpolate(String result, List<IRInstr> setupInstructions, List<StringInterpolationPart> parts, String scopeId, DebugInfo debugInfo)	Create a string interpolation instruction.
(package private) List<IRInstr>	PresentNestedLists.rewritten(List<IRInstr> list, UnaryOperator<List<IRInstr>> rewrite)	Null-safe application of a list rewrite: an absent list stays absent.
(package private) List<IRInstr>	PresentNestedLists.rewritten(List<IRInstr> list, UnaryOperator<List<IRInstr>> rewrite)	Null-safe application of a list rewrite: an absent list stays absent.
IRInstr	AssertThrowsInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	CompositeInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)	A copy with every nested list replaced by rewrite of it - exactly the lists CompositeInstr.nestedLists() reports, in that order; this when no list changed.
IRInstr	ControlFlowChainInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	DictLiteralInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	ForRangePolymorphicInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	ListLiteralInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	LogicalOperationInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)
IRInstr	StringInterpolationInstr.withNestedLists(UnaryOperator<List<IRInstr>> rewrite)

Constructor parameters in org.ek9lang.compiler.ir.instructions with type arguments of type IRInstr

Modifier	Constructor	Description
	AscendingCase(List<IRInstr> directionCheck, String directionPrimitive, List<IRInstr> loopConditionTemplate, String loopConditionPrimitive, List<IRInstr> loopBodySetup, ForRangePolymorphicInstr.ValueGuard valueGuard, ForRangePolymorphicInstr.EndCheck endCheck, List<IRInstr> loopIncrement, ForRangePolymorphicInstr.ProgressCheck progressCheck)	Creates an instance of a AscendingCase record class.
	ContinueCondition(List<IRInstr> evaluation, String primitive)	Creates an instance of a ContinueCondition record class.
	DescendingCase(List<IRInstr> directionCheck, String directionPrimitive, List<IRInstr> loopConditionTemplate, String loopConditionPrimitive, List<IRInstr> loopBodySetup, ForRangePolymorphicInstr.ValueGuard valueGuard, ForRangePolymorphicInstr.EndCheck endCheck, List<IRInstr> loopIncrement, ForRangePolymorphicInstr.ProgressCheck progressCheck)	Creates an instance of a DescendingCase record class.
	EqualCase(List<IRInstr> directionCheck, String directionPrimitive, List<IRInstr> loopBodySetup, ForRangePolymorphicInstr.ValueGuard valueGuard, boolean singleIteration)	Creates an instance of a EqualCase record class.
	NestedList(String role, List<IRInstr> instructions, CompositeInstr.Activation activation)	Creates an instance of a NestedList record class.
	ProgressCheck(List<IRInstr> evaluation, String primitive)	Creates an instance of a ProgressCheck record class.
	ValueGuard(List<IRInstr> evaluation, String primitive)	Creates an instance of a ValueGuard record class.

Uses of IRInstr in org.ek9lang.compiler.ir.support

Methods in org.ek9lang.compiler.ir.support that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	IRRewriter.rewrite(List<IRInstr> instructions, Function<IRInstr, List<IRInstr>> rewrite)	Rewrite an instruction list; the same list when nothing in it (at any depth) changed.
List<IRInstr>	IRRewriter.rewriteLists(List<IRInstr> instructions, UnaryOperator<List<IRInstr>> listRewrite)	Rewrite a list and every list nested in it, bottom-up; listRewrite returns its argument unchanged (the same list) when it changes nothing.

Methods in org.ek9lang.compiler.ir.support with parameters of type IRInstr

Modifier and Type	Method	Description
void	IRStructureWalk.Visitor.instruction(IRInstr instruction)	Each instruction, before any of its nested lists.
static ValueKind	ValueKind.madeBy(IRInstr instruction)	The kind of the value instruction makes; null when it makes none, or states none (a STORE, and a CAST, which forwards its operand's kind - V-D).

Method parameters in org.ek9lang.compiler.ir.support with type arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	IRRewriter.rewrite(List<IRInstr> instructions, Function<IRInstr, List<IRInstr>> rewrite)	Rewrite an instruction list; the same list when nothing in it (at any depth) changed.
List<IRInstr>	IRRewriter.rewrite(List<IRInstr> instructions, Function<IRInstr, List<IRInstr>> rewrite)	Rewrite an instruction list; the same list when nothing in it (at any depth) changed.
List<IRInstr>	IRRewriter.rewrite(List<IRInstr> instructions, Function<IRInstr, List<IRInstr>> rewrite)	Rewrite an instruction list; the same list when nothing in it (at any depth) changed.
void	IRRewriter.rewrite(OperationInstr operation, Function<IRInstr, List<IRInstr>> rewrite)	Rewrite an operation's body in place (the operation takes the rebuilt body, or keeps its own when nothing changed).
void	IRRewriter.rewrite(OperationInstr operation, Function<IRInstr, List<IRInstr>> rewrite)	Rewrite an operation's body in place (the operation takes the rebuilt body, or keeps its own when nothing changed).
List<IRInstr>	IRRewriter.rewriteLists(List<IRInstr> instructions, UnaryOperator<List<IRInstr>> listRewrite)	Rewrite a list and every list nested in it, bottom-up; listRewrite returns its argument unchanged (the same list) when it changes nothing.
List<IRInstr>	IRRewriter.rewriteLists(List<IRInstr> instructions, UnaryOperator<List<IRInstr>> listRewrite)	Rewrite a list and every list nested in it, bottom-up; listRewrite returns its argument unchanged (the same list) when it changes nothing.
void	IRRewriter.rewriteLists(OperationInstr operation, UnaryOperator<List<IRInstr>> listRewrite)	Rewrite an operation's body list by list: every nested list first (bottom-up), then the list that holds it.
void	IRStructureWalk.walk(List<IRInstr> instructions, IRStructureWalk.Visitor visitor)	Walk an instruction list and everything nested in it.

Uses of IRInstr in org.ek9lang.compiler.phase7

Methods in org.ek9lang.compiler.phase7 that return types with arguments of type IRInstr

Modifier and Type	Method	Description
protected List<IRInstr>	AggregateDfnGenerator.beforeInstanceInit(OperationInstr operation)	What a constructor does between its construction call and its _i_init, while its body is built: nothing, but for a dynamic class's capture constructor (DynamicClassDfnGenerator), which stores the captured values there.
protected List<IRInstr>	DynamicClassDfnGenerator.beforeInstanceInit(OperationInstr operation)	The capture stores, in THE capture constructor only.
protected List<IRInstr>	AbstractDfnGenerator.processPropertiesForInstanceInit(EK9Parser.AggregatePartsContext ctx)	Process all properties for instance initialization - THE shared PropertyInitialisers.

Method parameters in org.ek9lang.compiler.phase7 with type arguments of type IRInstr

Modifier and Type	Method	Description
(package private) void	Scenario2WrapperHelper.borrow(List<IRInstr> instructions, String value, String scopeId, DebugInfo debugInfo)	A value this scope does not own - a LOAD of a field or parameter, or a CAST alias of a value owned elsewhere - borrowed for the scope: OwnershipStatements.borrowInScope(String, String, DebugInfo).
(package private) String	Scenario2WrapperHelper.castBorrowed(List<IRInstr> instructions, String value, String typeName, String scopeId, DebugInfo debugInfo)	A value this scope does not own, CAST to typeName and the cast borrowed for the scope (a parameter given as Any).
(package private) String	Scenario2WrapperHelper.castWhenThisWrapper(List<IRInstr> instructions, String operandName, String notThisWrapperLabel, String scopeId, DebugInfo debugInfo)	THE test of an operand declared Any for being exactly THIS wrapper, and its cast when it is - shared by wrapper equality (Scenario2EqualityGenerator) and every other operator the generic declares as taking Any (Scenario2AggregateWrapperGenerator, D60: DictEntry <=> Any).
(package private) String	ConstrainedTypeInstrs.constructorCall(List<IRInstr> instructions, String typeName, List<String> parameterTypes, List<String> arguments, CallMetaDataDetails metaData, DebugInfo debugInfo)	THE constructor call on a type made here: CALL typeName.<init>(arguments) - its +1 result's owner is the caller's to state.
(package private) String	ConstrainedTypeInstrs.copyBaseValue(List<IRInstr> instructions, String sourceVar, DebugInfo debugInfo)	Produce the constrained type's own copy of a base-type value, on both boundaries - storing a constructor argument (copy-in) and returning a promoted value (copy-out) - so a later in-place change to the caller's value does not reach the constrained value and bypass its constraint.
(package private) BasicBlockInstr	ConstrainedTypeInstrs.createBasicBlock(List<IRInstr> instructions)
(package private) BasicBlockInstr	Scenario2WrapperHelper.createBasicBlock(List<IRInstr> instructions)
(package private) void	ConstraintLowering.emitConstraintCheck(List<IRInstr> instructions, String subjectVar, String scopeId, DebugInfo debugInfo)	Emit the constraint check on subjectVar (a base-type value).
(package private) void	ConstraintLowering.emitViabilityCheck(List<IRInstr> instructions, String subjectVar, String scopeId, DebugInfo debugInfo)	Evaluate whether subjectVar is a USABLE value for this constrained type - it is set AND satisfies the constraint - and store that Boolean as the first _viable.
(package private) String	Scenario2WrapperHelper.emitVirtualCall(List<IRInstr> instructions, String targetVar, String targetType, ISymbol targetTypeSymbol, String methodName, List<String> paramTypes, String returnType, List<String> argNames, DebugInfo debugInfo)	A virtual method call whose result (+1) the caller states the owner of itself - it casts it (Scenario2WrapperHelper.ownedCast(List, String, String, String, DebugInfo)) or moves it.
(package private) String	Scenario2WrapperHelper.extractPrimitiveBoolean(List<IRInstr> instructions, String booleanVar, DebugInfo debugInfo)	Extract primitive boolean from Boolean object via _true() method.
(package private) String	Scenario2WrapperHelper.generateConstructorCall(List<IRInstr> instructions, ISymbol type, boolean externallyLinked, String typeName, List<String> paramTypes, List<String> argNames, DebugInfo debugInfo)	A constructor call whose new value (+1) the caller states the owner of itself (it moves it).
(package private) String	Scenario2WrapperHelper.generateConstructorCallInstructions(List<IRInstr> instructions, ISymbol type, String typeName, List<String> paramTypes, List<String> argNames, String scopeId, DebugInfo debugInfo)	Generate a constructor call on a type: the new value (+1) is owned by the scope, dropped at its exit.
(package private) String	Scenario2WrapperHelper.generateProducerVirtualCall(List<IRInstr> instructions, String targetVar, String targetType, ISymbol targetTypeSymbol, String methodName, List<String> paramTypes, String returnType, List<String> argNames, String scopeId, DebugInfo debugInfo)	Generate a virtual method call whose result is a +1 PRODUCER — a value-method or operator that hands back a freshly-owned object (e.g.
(package private) String	Scenario2WrapperHelper.generateUnsetBoolean(List<IRInstr> instructions, String scopeId, DebugInfo debugInfo)	Generate an unset Boolean constructor call.
(package private) String	ConstrainedTypeInstrs.isSetOf(List<IRInstr> instructions, String subjectVar, String scopeId, DebugInfo debugInfo)	subject._isSet() on a BASE value, through THE ? call (IsSetCallDetailsCreator): its +1 Boolean is dropped at scopeId's exit (registered only - as a branch condition it is not kept).
(package private) String	ConstrainedTypeInstrs.loadDelegate(List<IRInstr> instructions, String objectVar, String scopeId, DebugInfo debugInfo)	The delegate of objectVar (a value of this constrained type), borrowed for the scope: THE delegate load (DelegateLoad).
(package private) String	Scenario2WrapperHelper.loadDelegate(List<IRInstr> instructions, String wrapperVar, String scopeId, DebugInfo debugInfo)	The delegate of wrapperVar, a value of THIS wrapper's type, borrowed for the scope.
(package private) String	Scenario2WrapperHelper.loadDelegate(List<IRInstr> instructions, String scopeId, DebugInfo debugInfo)	This wrapper's own delegate (this.delegate), borrowed for the scope.
(package private) String	Scenario2WrapperHelper.loadDelegateOf(List<IRInstr> instructions, String wrapperVar, String wrapperType, String delegateFieldType, String scopeId, DebugInfo debugInfo)	THE delegate load of the Scenario-2 wrappers: a wrapper value's delegate field, borrowed for the scope (DelegateLoad, shared with the constrained types).
(package private) void	Scenario2WrapperHelper.owned(List<IRInstr> instructions, String value, String scopeId, DebugInfo debugInfo)	A value just made (+1) that this scope owns and drops at its exit: OwnershipStatements.droppedAtExit(String, String, DebugInfo).
(package private) String	Scenario2WrapperHelper.ownedCast(List<IRInstr> instructions, String value, String typeName, String scopeId, DebugInfo debugInfo)	A value just made (+1), cast to typeName: the CAST takes the value's count (V-D) and the scope owns the cast, dropping it at exit - one count, one drop, whichever name holds the object.
protected void	AbstractDfnGenerator.processAsMethodOrOperator(OperationInstr operation, EK9Parser.OperationDetailsContext ctx, List<IRInstr> beforeInstanceInit)	AbstractDfnGenerator.processAsMethodOrOperator(OperationInstr, EK9Parser.OperationDetailsContext), with beforeInstanceInit - an explicit capture constructor's capture stores (CaptureStores) - just after the constructor's construction call, before its _i_init.
protected void	AbstractDfnGenerator.processSyntheticConstructor(OperationInstr operation, List<IRInstr> beforeInstanceInit)	AbstractDfnGenerator.processSyntheticConstructor(OperationInstr), with beforeInstanceInit - a dynamic function's or a dynamic class's capture stores (CaptureStores) - between the super call and _i_init.
(package private) void	Scenario2WrapperHelper.returnFresh(List<IRInstr> instructions, String value, DebugInfo debugInfo)	A value just made (+1), moved into the return variable (empty here): OwnershipStatements.returnFresh(String, String, DebugInfo) - the caller receives the producer's count.
(package private) void	Scenario2WrapperHelper.returnVirtualCall(List<IRInstr> instructions, String targetVar, String targetType, ISymbol targetTypeSymbol, String methodName, List<String> paramTypes, String returnType, List<String> argNames, String scopeId, DebugInfo debugInfo)	A virtual method call whose result (+1) is moved straight into the return variable: the method hands its caller exactly the count the callee handed it.
(package private) String	Scenario2WrapperHelper.rewrapRawDelegate(List<IRInstr> instructions, String rawVar, PossibleGenericSymbol wrapper, String scopeId, DebugInfo debugInfo)	THE wrap of a RAW delegate value back into its built-in parameterised wrapper (the inverse of Scenario2WrapperHelper.unwrapDelegate(List, String, PossibleGenericSymbol, String, DebugInfo)): wrapper(rawVar), the new wrapper owned by the scope.
(package private) void	ConstrainedTypeInstrs.storeDelegate(List<IRInstr> instructions, String value, DebugInfo debugInfo)	THE first store into this._delegate (in _i_init, or a constructor): the field takes its own reference to a value its scope owns - FIELD_ASSIGN [copy, init].
(package private) void	Scenario2WrapperHelper.storeDelegateField(List<IRInstr> instructions, String value, DebugInfo debugInfo)	The wrapper's delegate field, its first store in a constructor: the field takes its own reference to a value the constructor's scope still owns (FIELD_ASSIGN [copy, init]).
(package private) void	ConstrainedTypeInstrs.storeFirstViable(List<IRInstr> instructions, String value, DebugInfo debugInfo)	THE first store into this._viable (in _i_init): FIELD_ASSIGN [copy, init] of a value its scope owns.
(package private) void	Scenario2WrapperHelper.storeUnsetBooleanReturn(List<IRInstr> instructions, String scopeId, DebugInfo debugInfo)	An unset Boolean as the return value: made, and moved into the return variable (empty here).
(package private) void	ConstrainedTypeInstrs.storeViable(List<IRInstr> instructions, String scopeId, DebugInfo debugInfo)	THE store of this._viable = true: after a value has been accepted by the constraint check (a breach Panics before reaching here).
(package private) String	Scenario2WrapperHelper.unwrapDelegate(List<IRInstr> instructions, String wrapperVar, PossibleGenericSymbol parameterizedType, String scopeId, DebugInfo debugInfo)	Load the raw delegate out of a built-in parameterised wrapper value (List of Integer -> its List), for a base-type call that takes the raw type, borrowed for the scope.
(package private) String	ConstraintLowering.walkConstraint(EK9Parser.ConstrainTypeContext ctx, String subjectVar, List<IRInstr> instructions, String scopeId, DebugInfo debugInfo)	Lower the constrainType parse tree to IR over subjectVar, returning the temp holding the resulting Boolean.

Uses of IRInstr in org.ek9lang.compiler.phase7.calls

Methods in org.ek9lang.compiler.phase7.calls that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	CallDetailsBuilder.CallDetailsResult.allInstructions()	Returns the value of the allInstructions record component.

Constructor parameters in org.ek9lang.compiler.phase7.calls with type arguments of type IRInstr

Modifier	Constructor	Description
	CallDetailsResult(CallDetails callDetails, List<IRInstr> allInstructions)	Creates an instance of a CallDetailsResult record class.

Uses of IRInstr in org.ek9lang.compiler.phase7.generation

Methods in org.ek9lang.compiler.phase7.generation that return IRInstr

Modifier and Type	Method	Description
IRInstr	CoverageProbePlacer.createBranchFalseProbe(DebugInfo debugInfo)	Create a branch-false (else) probe instruction.
IRInstr	CoverageProbePlacer.createBranchTrueProbe(DebugInfo debugInfo)	Create a branch-true (if/then) probe instruction.
IRInstr	CoverageProbePlacer.createCatchBlockProbe(String exceptionType, DebugInfo debugInfo)	Create a catch block probe instruction.
IRInstr	CoverageProbePlacer.createCoverageFinalization(DebugInfo debugInfo)	Create a coverage finalization instruction.
IRInstr	CoverageProbePlacer.createFinallyBlockProbe(DebugInfo debugInfo)	Create a finally block probe instruction.
IRInstr	CoverageProbePlacer.createFunctionEntryProbe(DebugInfo debugInfo)	Create a function entry probe instruction.
IRInstr	CoverageProbePlacer.createLoopBodyProbe(DebugInfo debugInfo)	Create a loop body probe instruction.
IRInstr	CoverageProbePlacer.createModuleRegistration(DebugInfo debugInfo)	Create a module registration instruction.
IRInstr	CoverageProbePlacer.createProfilingEntryProbe(DebugInfo debugInfo)	Create a profiling entry probe instruction.
IRInstr	CoverageProbePlacer.createProfilingExitProbe(DebugInfo debugInfo)	Create a profiling exit probe instruction.
IRInstr	CoverageProbePlacer.createStatementProbe(DebugInfo debugInfo)	Create a statement probe instruction.
IRInstr	CoverageProbePlacer.createSwitchCaseProbe(String caseLabel, DebugInfo debugInfo)	Create a switch case probe instruction.

Methods in org.ek9lang.compiler.phase7.generation that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	InputClassProbeGenerator.apply(ISymbol operationSymbol, DebugInfo debugInfo, String scopeId)	Create an input-class probe for a public construct's entry (the dynamic numerator, §5).
List<IRInstr>	IRGenerationContext.extractInstructions()	Get current instruction list and clear it.
List<IRInstr>	IRInstructionBuilder.extractInstructions()	Extract all built instructions and clear the builder.

Methods in org.ek9lang.compiler.phase7.generation with parameters of type IRInstr

Modifier and Type	Method	Description
void	IRGenerationContext.addInstruction(IRInstr instruction)	Add instruction to current instruction list.
void	IRInstructionBuilder.addInstruction(IRInstr instruction)	Add a raw instruction to the current context.

Method parameters in org.ek9lang.compiler.phase7.generation with type arguments of type IRInstr

Modifier and Type	Method	Description
void	IRGenerationContext.addInstructions(List<IRInstr> instructions)	Add multiple instructions to current instruction list.
void	IRInstructionBuilder.addInstructions(List<IRInstr> instructions)	Add multiple raw instructions to the current context.

Uses of IRInstr in org.ek9lang.compiler.phase7.generator

Classes in org.ek9lang.compiler.phase7.generator that implement interfaces with type arguments of type IRInstr

Modifier and Type	Class	Description
(package private) class	AbstractShortCircuitGenerator	Both AND/OR are very similar in processing, the only real differences are: What operation to call and the op code to generate.
final class	AssertDoesNotThrowExprGenerator	IR Generation for the assertDoesNotThrow expression.
final class	AssertPanicExprGenerator	IR Generation for the assertPanic expression.
final class	AssertStmtGenerator	IR Generation for the assert statement.
final class	AssertThrowsExprGenerator	IR Generation for the assertThrows expression.
(package private) final class	AssignExpressionToSymbol	THE assignment of an assignmentExpression to a symbol (the expression is generated by generators.assignmentExprGenerator), in one of two AssignExpressionToSymbol.Modes - TWO per construct on the set, generators.assignToNewSymbol and generators.assignToExistingSymbol (IR tidy W3.9, EXPR-15), never one per assignment.
(package private) final class	AssignIfUnsetBlockGenerator	Assign-if-unset generator using unified CONTROL_FLOW_CHAIN approach.
(package private) final class	AssignmentExprInstrGenerator	Creates IR instructions for assignment expressions.
final class	AssignmentStmtGenerator	Process assignment statement: variable = expression Uses RELEASE-then-RETAIN pattern for memory-safe assignments.
final class	BinaryOperationGenerator	Generates IR instructions for binary operations (e.g., addition, subtraction, comparison, etc.).
final class	BlockStmtInstrGenerator	Creates IR instructions for block statements.
final class	CallInstrGenerator	Generates IR instructions for function/method calls.
final class	ControlFlowChainGenerator	Unified IR generator for EK9 control flow operators using CONTROL_FLOW_CHAIN.
final class	DictLiteralGenerator	Generates IR instructions for dict literal expressions.
final class	ExprInstrGenerator	Creates IR instructions for expressions.
final class	ForInGenerator	Generates IR for for-in loops and expressions: for item in collection.
final class	ForRangeGenerator	Generates IR for for-range loops and expressions using FOR_RANGE_POLYMORPHIC instruction.
final class	ForStatementGenerator	Coordinates for-statement IR generation by delegating to specialized generators.
final class	FunctionCallProcessor	Unified function call processor using CallDetailsBuilder for method resolution and promotion.
final class	FunctionCallProcessor	Unified function call processor using CallDetailsBuilder for method resolution and promotion.
final class	IfStatementGenerator	Generates IR for if/else statements using CONTROL_FLOW_CHAIN.
final class	InterpolatedStringGenerator	Generates IR instructions for interpolated string expressions.
final class	ListLiteralGenerator	Generates IR instructions for list literal expressions.
(package private) final class	LiteralGenerator	Deals with generating the correct IR Instructions for processing any form of literal.
final class	PrimaryReferenceGenerator	Generates IR instructions for primary references (THIS and SUPER keywords).
final class	PropertyInitialisers	THE instance initialisation of a type's properties, in declaration order - the body of its _i_init.
final class	QuestionBlockGenerator	Generates IR instructions for question operator (?) using unified SWITCH_CHAIN_BLOCK.
final class	RequireStmtGenerator	IR Generation for the require statement.
final class	StmtInstrGenerator	Creates IR instructions for statements.
final class	StreamStatementGenerator	Generates IR for stream statement pipelines: source | stages | > terminal.
final class	SwitchStatementGenerator	Generates IR for switch statements and expressions using CONTROL_FLOW_CHAIN.
final class	ThrowStatementGenerator	Generates IR for throw statements.
final class	TryCatchStatementGenerator	Generates IR for try/catch/finally constructs using CONTROL_FLOW_CHAIN.
final class	UnaryOperationGenerator	Generates IR instructions for unary operations (e.g., unary minus, increment, decrement, etc.).
final class	VariableDeclInstrGenerator	Creates IR instructions for variable declarations.
final class	VariableOnlyDeclInstrGenerator	Creates IR instructions for variable only declarations.
final class	WhileStatementGenerator	Generates IR for while and do-while loops and expressions using CONTROL_FLOW_CHAIN.

Methods in org.ek9lang.compiler.phase7.generator that return IRInstr

Modifier and Type	Method	Description
IRInstr	ResourceCloser.closeCall(ResourceCloser.Closing closing)	CALL variable._close() on the type that declares close.
IRInstr	FunctionProbes.Registered.coverageEntry()	Returns the value of the coverageEntry record component.
IRInstr	ApplicationClose.declare(ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)
IRInstr	ResourceCloser.declareFirstFailure(ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	SLOT_DECLARE firstFailure, org.ek9.lang::Exception, owner - null until a failure is recorded.
IRInstr	FunctionProbes.Registered.profilingEntry()	Returns the value of the profilingEntry record component.
IRInstr	FunctionProbes.Registered.profilingExit()	Returns the value of the profilingExit record component.

Methods in org.ek9lang.compiler.phase7.generator that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	DeclarationParts.all()	The whole declaration: the declaration, then the initialisation.
List<IRInstr>	AbstractShortCircuitGenerator.apply(ExprProcessingDetails details)
List<IRInstr>	AssertDoesNotThrowExprGenerator.apply(EK9Parser.AssertDoesNotThrowExpressionContext ctx)	Generate IR for assertDoesNotThrow expression.
List<IRInstr>	AssertPanicExprGenerator.apply(EK9Parser.AssertPanicExpressionContext ctx, String resultVar)	Generate IR for assertPanic expression.
List<IRInstr>	AssertStmtGenerator.apply(EK9Parser.AssertStatementContext ctx)
List<IRInstr>	AssertThrowsExprGenerator.apply(EK9Parser.AssertThrowsExpressionContext ctx, String resultVar)	Generate IR for assertThrows expression.
List<IRInstr>	AssignExpressionToSymbol.apply(ISymbol lhsSymbol, EK9Parser.AssignmentExpressionContext ctx)
List<IRInstr>	AssignIfUnsetBlockGenerator.apply(AssignIfUnsetDetails details)
List<IRInstr>	AssignmentExprInstrGenerator.apply(EK9Parser.AssignmentExpressionContext ctx, String rhsExprResult)	Generate IR instructions for an assignment expression into rhsExprResult.
List<IRInstr>	AssignmentStmtGenerator.apply(EK9Parser.AssignmentStatementContext ctx)
List<IRInstr>	BinaryOperationGenerator.apply(ExprProcessingDetails details)
List<IRInstr>	BlockStmtInstrGenerator.apply(EK9Parser.BlockStatementContext ctx)	Generate IR instructions for a block statement using stack-based scope management.
List<IRInstr>	CallInstrGenerator.apply(EK9Parser.CallContext ctx, VariableDetails resultDetails)
List<IRInstr>	ControlFlowChainGenerator.apply(ControlFlowChainDetails details)
List<IRInstr>	DictLiteralGenerator.apply(ExprProcessingDetails details)
List<IRInstr>	ExprInstrGenerator.apply(ExprProcessingDetails details)	Generate IR instructions for expression.
List<IRInstr>	ForInGenerator.apply(EK9Parser.ForStatementExpressionContext ctx)
List<IRInstr>	ForRangeGenerator.apply(EK9Parser.ForStatementExpressionContext ctx)	Main orchestration method for for-range loop IR generation.
List<IRInstr>	ForStatementGenerator.apply(EK9Parser.ForStatementExpressionContext ctx)	Main entry point for for-statement IR generation.
List<IRInstr>	FunctionCallProcessor.apply(CallProcessingDetails details, Function<ExprProcessingDetails, List<IRInstr>> exprProcessor)	Apply function call processing with an expression processor function.
List<IRInstr>	IfStatementGenerator.apply(EK9Parser.IfStatementContext ctx)
List<IRInstr>	InterpolatedStringGenerator.apply(ExprProcessingDetails details)
List<IRInstr>	ListLiteralGenerator.apply(ExprProcessingDetails details)
List<IRInstr>	LiteralGenerator.apply(LiteralProcessingDetails details)
List<IRInstr>	ObjectAccessInstrGenerator.apply(EK9Parser.ObjectAccessExpressionContext ctx, VariableDetails variableDetails)	Generate IR instructions for object access expression using resolved symbols.
List<IRInstr>	PrimaryReferenceGenerator.apply(PrimaryReferenceProcessingDetails details)
List<IRInstr>	PropertyInitialisers.apply(EK9Parser.AggregatePartsContext ctx)
List<IRInstr>	QuestionBlockGenerator.apply(ExprProcessingDetails details)
List<IRInstr>	RequireStmtGenerator.apply(EK9Parser.RequireStatementContext ctx)
List<IRInstr>	StatementOwnedCloseables.apply(org.antlr.v4.runtime.ParserRuleContext statementCtx, List<IRInstr> statement)	The statement's (or initialiser's) instructions, wrapped so it closes the closeable temporaries it created - or unchanged when it creates none.
List<IRInstr>	StmtInstrGenerator.apply(EK9Parser.StatementContext ctx)	Generate IR instructions for a statement using proper stack-based scope management.
List<IRInstr>	StreamStatementGenerator.apply(EK9Parser.StreamStatementContext ctx)
List<IRInstr>	SwitchStatementGenerator.apply(EK9Parser.SwitchStatementExpressionContext ctx)
List<IRInstr>	ThrowStatementGenerator.apply(EK9Parser.ThrowStatementContext ctx)
List<IRInstr>	TryCatchStatementGenerator.apply(EK9Parser.TryStatementExpressionContext ctx)
List<IRInstr>	UnaryOperationGenerator.apply(ExprProcessingDetails details)
List<IRInstr>	VariableDeclInstrGenerator.apply(EK9Parser.VariableDeclarationContext ctx)	Generate IR instructions for variable declaration with assignment using stack-based scope management.
List<IRInstr>	VariableOnlyDeclInstrGenerator.apply(EK9Parser.VariableOnlyDeclarationContext ctx)	Generate IR instructions for variable only declaration.
List<IRInstr>	WhileStatementGenerator.apply(EK9Parser.WhileStatementExpressionContext ctx)
List<IRInstr>	StreamStatementGenerator.applyExpression(EK9Parser.StreamExpressionContext ctx, String rhsExprResult)	Generate IR for stream expression form: result <- cat items | stages | collect as Type.
List<IRInstr>	AbstractAssertExprGenerator.AssertBodyResult.bodyInstructions()	Returns the value of the bodyInstructions record component.
(package private) List<IRInstr>	StreamEmissionEngine.buildWindowRefill(IteratorSetup iteratorSetup, boolean isRawIterator, String submitItemVar, ISymbol elementType, String asyncExecutorVar, String inFlightVar, String oneVar, ISymbol integerType, List<EK9Parser.StreamPartContext> preAsyncStages, List<StageState> preAsyncStageStates, List<StageState.Counter> postHeads, org.ek9lang.compiler.phase7.generator.StreamEmissionEngine.AsyncCap cap, DebugInfo debugInfo)	The windowed drain's REFILL step: if ([c1 < l1 AND ...] source.hasNext()) { bind submitItem = next(); [pre-async stages]; submit(submitItem); inFlight++ }.
List<IRInstr>	ResourceCloser.closeEach(List<ResourceCloser.Closing> closings, ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	ResourceCloser.closingRegion(List, List, ResourceCloser.FirstFailure, DebugInfo) with no body: every value that is present closed, last first, each in its own protected region, then the first close failure rethrown with the later ones suppressed onto it.
List<IRInstr>	CloseChain.closeOperator(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	The body of a type's close followed, on every path, by its generated chain.
List<IRInstr>	ResourceCloser.closeRecording(ResourceCloser.Closing closing, ResourceCloser.FirstFailure firstFailure)	ONE value, closed if present, in its own protected region that records an EK9 Exception into firstFailure (the first) or suppresses it onto that (any later) - for a caller that holds the values itself and must do more between two closes (the application takes each registered component out of the registry, closes it and drops it: ApplicationClose).
(package private) List<IRInstr>	StreamPipelineMachinery.closeSource(CallDetails closeCall, DebugInfo debugInfo)	THE close of a drained stream source (the async executor), in its pipeline's finally region.
List<IRInstr>	ResourceCloser.closingRegion(List<IRInstr> body, List<ResourceCloser.Closing> closings, ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	THE owned region: body, then - on the normal path, after an EK9 Exception, and while a Panic unwinds - every value in closings that is present is closed, last first, each in its own protected region; then the first EK9 Exception (the body's, else the first close's) is rethrown with the later close failures suppressed onto it.
List<IRInstr>	CloseChain.constructionFailure(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	A constructor's work after its construction call, with the chain run only if it fails.
List<IRInstr>	CloseChain.constructionFailureInOwnScope(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	CloseChain.constructionFailure(List, IAggregateSymbol, DebugInfo) in a scope of its own (SCOPE_ENTER/SCOPE_EXIT around it), so what the region registers has an entered scope to be released by: a generated constructor has no body scope, and a written one's region sits after its body scope has been left (or, after an explicit super(...), inside it).
List<IRInstr>	DeclarationParts.declaration()	Returns the value of the declaration record component.
List<IRInstr>	StatementOwnedCloseables.OwnedTemporaries.declarations()	Returns the value of the declarations record component.
(package private) List<IRInstr>	WrittenParameters.declarations(EK9Parser.ArgumentParamContext argumentParam, GeneratorSet generators)	The declarations of the written parameters, for OperationBodyPlan.parameters.
List<IRInstr>	OwnedDeclaration.declare(org.antlr.v4.runtime.ParserRuleContext owner, EK9Parser.VariableDeclarationContext variableDeclaration, EK9Parser.VariableOnlyDeclarationContext variableOnlyDeclaration)	Declare whichever of the two forms is present; nothing when neither is.
List<IRInstr>	RangeIterationHelper.CaseConstructorParams.directionCheck()	Returns the value of the directionCheck record component.
<T extends ICanCaptureVariables & ISymbol> List<IRInstr>	DynamicConstructEmitter.emit(T dynamicSymbol, Function<IRGenerationContext, IRConstruct> generate, EK9Parser.DynamicVariableCaptureContext captureCtx, DebugInfo debugInfo, String resultVariable, Function<List<ISymbol>, CallMetaDataDetails> metaData)	Emit the dynamic construct and the instructions that construct it.
List<IRInstr>	FunctionProbes.Registered.entryProbes()	The probes that open the body, in order: coverage entry, then profiling entry.
List<IRInstr>	LoopGuardHelper.evaluatePreFlowSetupOnly(EK9Parser.PreFlowStatementContext preFlowStmt)	Emit ONLY the preflow variable setup (declaration/assignment) with NO guard entry check.
List<IRInstr>	ResourceCloser.failureRegion(List<IRInstr> body, List<ResourceCloser.Closing> closings, ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	The closes of ResourceCloser.closingRegion(List, List, ResourceCloser.FirstFailure, DebugInfo), run only when body fails with an EK9 Exception - which is then rethrown with any close failure suppressed onto it.
List<IRInstr>	ResourceCloser.finallyRegion(List<IRInstr> body, Supplier<List<IRInstr>> finallyBuilder, DebugInfo debugInfo)	body, then finallyBuilder's instructions on EVERY exit - its normal end, an EK9 Exception, a Panic, a cancelled async task's Cancelled - with nothing caught: a TRY_CATCH_FINALLY with no catch, in its own chain scope.
protected List<IRInstr>	AbstractStreamStageGenerator.gate(List<IRInstr> conditionInstructions, String conditionVar, String primitiveVar, List<IRInstr> bodyWhenTrue, List<IRInstr> bodyWhenFalse, DebugInfo debugInfo)	THE conditional gate: run bodyWhenTrue when the condition holds, bodyWhenFalse otherwise.
List<IRInstr>	ControlFlowChainGenerator.generateAssignIfUnset(ISymbol lhsSymbol, List<IRInstr> assignmentEvaluation, String assignmentResult, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for assign-if-unset (:=?).
List<IRInstr>	ControlFlowChainGenerator.generateAssignIfUnsetTestForTemp(String variableName, ISymbol variableSymbol, String resultVariable, DebugInfo debugInfo)	The question operator on a temp that holds the current value of a :=? target: a null there is the never-written slot :=? exists to write, so it is NOT a strict-absent observation (StrictAbsent).
(package private) List<IRInstr>	RangeIterationHelper.generateBodySetup(String loopVariableName, RangeIterationHelper.InitializationData initData, DebugInfo debugInfo)	Generate body setup: loopVariable becomes a FRESH per-iteration value copied from the counter.
List<IRInstr>	ControlFlowChainGenerator.generateComparisonCoalescing(ExprProcessingDetails lhsDetails, ExprProcessingDetails rhsDetails, String comparisonOperator, String chainType)	Generate CONTROL_FLOW_CHAIN for Comparison Coalescing operators (<?, >?).
protected List<IRInstr>	AbstractStreamStageGenerator.generateCounterDelta(String counterVar, String oneVar, String op, ISymbol integerType, DebugInfo debugInfo)	Reassign counterVar = counterVar <op> oneVar ("_add" to increment, "_sub" to decrement) via the RELEASE/STORE/RETAIN reassignment pattern.
(package private) List<IRInstr>	StreamPipelineMachinery.generateDynamicStageLimit(EK9Parser.StreamPartContext stageCtx, String limitVar, ISymbol integerType, String scopeId, DebugInfo debugInfo)	Generate IR to evaluate a dynamic stage operand (function reference or call) and store the Integer result in the given limit variable.
List<IRInstr>	ControlFlowChainGenerator.generateElvisCoalescing(ExprProcessingDetails lhsDetails, ExprProcessingDetails rhsDetails)	Generate CONTROL_FLOW_CHAIN for Elvis Coalescing operator (:?).
List<IRInstr>	ControlFlowChainGenerator.generateExternalFieldAssignIfUnset(String isSetBoolean, List<IRInstr> assignmentBody, DebugInfo debugInfo)	Generate CONTROL_FLOW_CHAIN for assign-if-unset on external field.
(package private) List<IRInstr>	StreamPipelineMachinery.generatePipelineItemBinding(String iteratorVar, IAggregateSymbol iteratorType, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, boolean rawIterator)	Generate: pipelineItem = iterator.next() Follows ForInGenerator.generateLoopVariableBinding() pattern.
List<IRInstr>	ControlFlowChainGenerator.generateQuestionOperator(ExprProcessingDetails exprDetails)	Generate SWITCH_CHAIN_BLOCK for Question operator (?).
List<IRInstr>	ControlFlowChainGenerator.generateQuestionOperatorForTemp(String variableName, ISymbol variableSymbol, String resultVariable, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for Question operator applied to a temp variable.
List<IRInstr>	ControlFlowChainGenerator.generateQuestionOperatorForVariable(ISymbol variableSymbol, String resultVariable, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for Question operator applied to a variable.
protected List<IRInstr>	AbstractStreamStageGenerator.generateTerminalPipe(TerminalSetup terminalSetup, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo)	THE shared "pipe a value into a sink" step: sink._pipe(value) - used by the pipeline terminal and by tee's side terminal.
List<IRInstr>	ControlFlowChainGenerator.generateTernary(ExprProcessingDetails details)	Generate IR for ternary operator: condition <- thenValue : elseValue.
(package private) List<IRInstr>	AbstractVariableDeclGenerator.getDeclInstrs(org.antlr.v4.runtime.tree.ParseTree ctx, String owner)	The declaration of a variable owned by owner - the declaring scope for a local, the CALLER for the returning variable (OwnershipStatements.declaredSlot(String, String, String, DebugInfo)).
List<IRInstr>	DeclarationParts.initialisation()	Returns the value of the initialisation record component.
List<IRInstr>	StageWrapParams.innerBody()	Returns the value of the innerBody record component.
List<IRInstr>	BufferedStageParams.instructions()	Returns the value of the instructions record component.
List<IRInstr>	ConditionStatementPrelude.Evaluated.instructions()	Returns the value of the instructions record component.
List<IRInstr>	DrainCondition.instructions()	Returns the value of the instructions record component.
List<IRInstr>	FreshBooleanOperand.instructions()	Returns the value of the instructions record component.
List<IRInstr>	GuardedConditionEvaluator.ConditionEvaluation.instructions()	Returns the value of the instructions record component.
List<IRInstr>	RangeIterationHelper.InitializationData.instructions()	Returns the value of the instructions record component.
List<IRInstr>	StatementOwnedCloseables.OwnedEvaluation.instructions()	Returns the value of the instructions record component.
List<IRInstr>	StatementOwnedCloseables.OwnedTemporaries.instructions()	Returns the value of the instructions record component.
List<IRInstr>	SwitchCaseOrChainGenerator.ComparisonResult.instructions()	Returns the value of the instructions record component.
List<IRInstr>	InterpolatedStringGenerator.interpolate(EK9Parser.StringLitContext stringLitCtx, VariableDetails resultDetails)	THE interpolation entry point for callers that already hold a stringLit - use this, do not re-derive it.
List<IRInstr>	ResourceCloser.Closing.load()	Returns the value of the load record component.
List<IRInstr>	VariableOnlyDeclInstrGenerator.localDeclaration(EK9Parser.VariableOnlyDeclarationContext ctx)	A LOCAL declared without a value (x as T? as a block statement): the declaration, then its owner - the declaring scope owns the slot's CURRENT value, so whatever a later := / :=? leaves in it is released when that scope exits, normally and on unwind (A10, EK9_IR_OWNERSHIP_MODEL.md §6 and §12).
List<IRInstr>	RangeIterationHelper.CaseConstructorParams.loopBodySetup()	Returns the value of the loopBodySetup record component.
List<IRInstr>	RangeIterationHelper.CaseConstructorParams.loopConditionTemplate()	Returns the value of the loopConditionTemplate record component.
List<IRInstr>	RangeIterationHelper.CaseConstructorParams.loopIncrement()	Returns the value of the loopIncrement record component.
List<IRInstr>	GuardedScopeOrchestrator.orchestrate(org.antlr.v4.runtime.tree.ParseTree ctx, EK9Parser.PreFlowStatementContext preFlowStmt, EK9Parser.ReturningParamContext returningParam, Function<GuardedScopeOrchestrator.OrchestratorContext, List<IRInstr>> coreGenerator)	Orchestrate for constructs whose core produces List<IRInstr>.
List<IRInstr>	GuardedScopeOrchestrator.orchestrate(org.antlr.v4.runtime.tree.ParseTree ctx, EK9Parser.PreFlowStatementContext preFlowStmt, EK9Parser.ReturningParamContext returningParam, Function<GuardedScopeOrchestrator.OrchestratorContext, List<IRInstr>> coreGenerator, boolean coreManagesReturnSetup)	Orchestrate with control over return-variable setup placement.
List<IRInstr>	GuardedScopeOrchestrator.orchestrateChain(org.antlr.v4.runtime.tree.ParseTree ctx, EK9Parser.PreFlowStatementContext preFlowStmt, EK9Parser.ReturningParamContext returningParam, Function<GuardedScopeOrchestrator.OrchestratorContext, ControlFlowChainDetails> coreGenerator)	Orchestrate for constructs whose core produces ControlFlowChainDetails.
List<IRInstr>	ConditionAndPostLoop.postLoopInstructions()	Returns the value of the postLoopInstructions record component.
List<IRInstr>	StageWrapResult.postLoopInstructions()	Returns the value of the postLoopInstructions record component.
(package private) List<IRInstr>	GuardedConditionEvaluator.preFlowSetup(EK9Parser.PreFlowStatementContext preFlowStmt)	THE emission of a pre-flow's setup (FLOW-1): the declaration of v <- e() or the assignment of v := e() / v :=? e(), registered in the CURRENT stack scope.
List<IRInstr>	StageSetupResult.preLoopInstructions()	Returns the value of the preLoopInstructions record component.
protected List<IRInstr>	AbstractGenerator.processBlockStatements(EK9Parser.BlockContext ctx, Function<EK9Parser.BlockStatementContext, List<IRInstr>> blockStmtGenerator)	Process all block statements from a BlockContext by unwrapping to InstructionBlockContext.
protected List<IRInstr>	AbstractGenerator.processBlockStatements(EK9Parser.InstructionBlockContext ctx, Function<EK9Parser.BlockStatementContext, List<IRInstr>> blockStmtGenerator)	Process all block statements in an instruction block.
(package private) List<IRInstr>	BinaryOperationGenerator.processOperandExpression(EK9Parser.ExpressionContext operandExpr, VariableDetails operandDetails)	Process operand expression using exprGenerator from generators struct.
(package private) List<IRInstr>	UnaryOperationGenerator.processOperandExpression(EK9Parser.ExpressionContext operandExpr, VariableDetails operandDetails)	Process operand expression using exprGenerator from generators struct.
List<IRInstr>	ApplicationClose.rethrow(ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	After every registration has been closed and dropped: rethrow the first close failure, if any.
List<IRInstr>	ResourceCloser.rethrow(ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	After a caller's own sequence of ResourceCloser.closeRecording(ResourceCloser.Closing, ResourceCloser.FirstFailure): THROW firstFailure when one was recorded.
List<IRInstr>	CallStageWrapper.wrap(StageWrapParams params, String inVar, String outVar)
List<IRInstr>	FilterRejectStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType)
List<IRInstr>	FlattenStageWrapper.wrap(StageWrapParams params, String inVar, String outVar)
(package private) List<IRInstr>	FlattenStageWrapper.wrap(StageWrapParams params, String inVar, String outVar, List<StageState.Counter> downstreamHeads)	Wrap with the inner loop bounded by downstreamHeads: the heads after this flatten (up to the next drain).
(package private) List<IRInstr>	FlattenStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String inVar, String outVar, List<StageState.Counter> downstreamHeads)	Wrap with the downstream body GENERATED inside this flatten's per-element body scope: downstream is called once that scope is current, so whatever the downstream stages register (a head's comparison, a map's result) is owned by the inner loop's body and released every inner iteration - not by a scope entered once around the whole loop, which would release only the last element's (A11; EK9_IR_OWNERSHIP_MODEL.md §7).
List<IRInstr>	FunctionProbes.wrap(List<IRInstr> body, FunctionProbes.Registered probes, IRInstr beforeReturn)	A body generated without probes, instrumented afterwards: the entry probes first, then the body, with beforeReturn (if any) and then the profiling exit before every top-level RETURN.
(package private) List<IRInstr>	HeadSkipStageWrapper.wrap(StageWrapParams params, StageState stageState, String asyncExecutorVar)
List<IRInstr>	JoinStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)
(package private) List<IRInstr>	JoinStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap with the downstream body GENERATED inside the post-loop emit's own scope: downstream is called once that scope is current, so what the downstream stages register is owned by a scope open where they run.
List<IRInstr>	MapStageWrapper.wrap(StageWrapParams params, String inVar, String outVar)
List<IRInstr>	StreamElementStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType)	Wrap innerBody in this stage's gate or side effect.
List<IRInstr>	StreamPostLoopStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap innerBody such that it runs after the loop rather than during it.
List<IRInstr>	StreamStageWrapper.wrap(StageWrapParams params, String inVar, String outVar)	Wrap innerBody in this stage's transformation.
List<IRInstr>	TailStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)
(package private) List<IRInstr>	TailStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap with the downstream body GENERATED inside the drain loop's per-element body scope: downstream is called once that scope is current, so what the downstream stages register is owned by the drain's iteration, not by a scope entered once around the pipeline (A11; EK9_IR_OWNERSHIP_MODEL.md §7).
(package private) List<IRInstr>	TeeStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType, StageState teeState)	Wrap innerBody: pipe the item (or its mapped value) to the side target, then run the inner body.
(package private) List<IRInstr>	UniqStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType, StageState stageState)
List<IRInstr>	LoopGuardHelper.wrapBodyWithGuardEntryCheck(GuardVariableDetails guardDetails, List<IRInstr> bodyInstructions, String guardScopeId, DebugInfo debugInfo)	Wrap body instructions in an IF_ELSE_IF that checks the guard entry condition.
List<IRInstr>	LoopGuardHelper.wrapChainWithGuardEntryCheck(GuardVariableDetails guardDetails, ControlFlowChainDetails chainDetails, String guardScopeId, DebugInfo debugInfo)	Wrap a ControlFlowChainDetails (loop or try) in an IF_ELSE_IF that checks the guard entry condition.
List<IRInstr>	LoopGuardHelper.wrapExpressionFormWithGuardEntryCheck(GuardVariableDetails guardDetails, List<IRInstr> returnVariableSetup, List<IRInstr> bodyInstructionsWithoutRtn, String guardScopeId, DebugInfo debugInfo)	Wrap body instructions in an IF_ELSE_IF for EXPRESSION FORM with return variable.
List<IRInstr>	StageWrapResult.wrappedBody()	Returns the value of the wrappedBody record component.

Methods in org.ek9lang.compiler.phase7.generator with parameters of type IRInstr

Modifier and Type	Method	Description
protected void	AbstractStreamStageGenerator.addManagedCall(List<IRInstr> target, IRInstr callInstr, String resultVar, DebugInfo debugInfo)
protected void	AbstractStreamStageGenerator.publishCallResultAndContinue(List<IRInstr> target, String outVar, IRInstr callInstr, List<IRInstr> innerBody, DebugInfo debugInfo)	AbstractStreamStageGenerator.publishAndContinue(List, String, String, List, DebugInfo) for a stage value made by a call here (map, call): moved into the out-variable (AbstractStreamStageGenerator.rebindToCallResult(List, String, IRInstr, DebugInfo)), then the inner body.
protected void	AbstractStreamStageGenerator.rebindToCallResult(List<IRInstr> target, String slot, IRInstr callInstr, DebugInfo debugInfo)	THE move of a call's result, made here, into a slot: the call, then SLOT_ASSIGN slot, result [consume] - the slot takes the call's count, and nothing else owns the result (OwnershipStatements.reboundFresh(String, String, DebugInfo); the harness rule move-into-slot).
protected void	AbstractStreamStageGenerator.rebindToCastCallResult(List<IRInstr> target, String slot, IRInstr callInstr, String castTypeName, DebugInfo debugInfo)	THE move of a call's result, cast to the element type, into a slot: a raw source's next() hands back Any at +1, the CAST takes that count (V-D) and SLOT_ASSIGN slot, cast [consume] moves it in (OwnershipStatements.reboundFresh(String, String, DebugInfo); harness rule move-into-slot).
List<IRInstr>	FunctionProbes.wrap(List<IRInstr> body, FunctionProbes.Registered probes, IRInstr beforeReturn)	A body generated without probes, instrumented afterwards: the entry probes first, then the body, with beforeReturn (if any) and then the profiling exit before every top-level RETURN.

Method parameters in org.ek9lang.compiler.phase7.generator with type arguments of type IRInstr

Modifier and Type	Method	Description
void	OperationDfnGenerator.accept(OperationInstr operation, EK9Parser.OperationDetailsContext ctx, List<IRInstr> beforeInstanceInit)	OperationDfnGenerator.accept(OperationInstr, EK9Parser.OperationDetailsContext), with beforeInstanceInit - THE capture stores of a dynamic class's explicit capture constructor (CaptureStores, support/IsCaptureConstructor) - placed while the body is built: just after the constructor's super(...) call, implicit or explicit, or first when it has none or delegates with this(...) - so before every _i_init it runs and outside the partial-construction region (D10).
void	OperationDfnGenerator.acceptInMethodFrame(OperationInstr operation, EK9Parser.OperationDetailsContext ctx, List<IRInstr> beforeInstanceInit)	OperationDfnGenerator.acceptInMethodFrame(OperationInstr, EK9Parser.OperationDetailsContext) for a dynamic class's explicit capture constructor, with its capture stores (OperationDfnGenerator.accept(OperationInstr, EK9Parser.OperationDetailsContext, List)).
protected void	AbstractGenerator.addCoverageProbe(org.antlr.v4.runtime.tree.ParseTree ctx, List<IRInstr> instructions, Function<DebugInfo, IRInstr> probeFactory)	Add a coverage probe instruction if coverage instrumentation is enabled.
protected void	AbstractGenerator.addCoverageProbe(org.antlr.v4.runtime.tree.ParseTree ctx, List<IRInstr> instructions, Function<DebugInfo, IRInstr> probeFactory)	Add a coverage probe instruction if coverage instrumentation is enabled.
protected void	AbstractStreamStageGenerator.addManagedCall(List<IRInstr> target, IRInstr callInstr, String resultVar, DebugInfo debugInfo)
(package private) String	StreamDemand.appendBoundedCondition(List<IRInstr> conditionEvaluation, List<IRInstr> leftInstructions, String leftResult, String leftPrimitive, List<IRInstr> rightInstructions, String rightResult, String scopeId, DebugInfo debugInfo)	Append a short-circuit LEFT AND RIGHT Boolean condition to conditionEvaluation and return the combined Boolean result variable.
(package private) String	StreamDemand.appendDemandCondition(List<IRInstr> conditionEvaluation, List<StageState.Counter> bounds, List<IRInstr> rightInstructions, String rightResult, String scopeId, DebugInfo debugInfo)	Append the demand-bounded condition c1 < l1 AND (... AND right) to conditionEvaluation and return its Boolean result.
(package private) String	StreamDemand.appendDemandOverPrimitive(List<IRInstr> condition, List<StageState.Counter> heads, List<IRInstr> primitiveInstructions, String primitiveResult, String scopeId, DebugInfo debugInfo)	Gate a loop whose continuation is a runtime helper's PRIMITIVE hasNext-style call (Ek9Group.hasNextGroup, Ek9Async.hasNext): with no heads the condition is unchanged; otherwise the primitive is lifted to a Boolean (Boolean._of) so it can be the right operand of the demand AND.
List<IRInstr>	FunctionCallProcessor.apply(CallProcessingDetails details, Function<ExprProcessingDetails, List<IRInstr>> exprProcessor)	Apply function call processing with an expression processor function.
List<IRInstr>	StatementOwnedCloseables.apply(org.antlr.v4.runtime.ParserRuleContext statementCtx, List<IRInstr> statement)	The statement's (or initialiser's) instructions, wrapped so it closes the closeable temporaries it created - or unchanged when it creates none.
(package private) void	StreamEmissionEngine.applyGroupingStage(StreamSource source, ISymbol consumedElementType, BucketTracker tracker, StageGroup preStageGroup, StageGroup postStageGroup, BoundaryConditionBuilder boundaryBuilder, TerminalSetup terminalSetup, org.antlr.v4.runtime.tree.ParseTree probeSite, List<IRInstr> instructions, DebugInfo debugInfo)	Shared drain+emit engine for the consecutive-grouping stream stages (GROUP, SPLIT).
protected void	AbstractStreamStageGenerator.borrowedBy(List<IRInstr> target, String value, String scopeId, DebugInfo debugInfo)	THE stream statement that scopeId keeps a value that arrived borrowed (+0: a LOAD, a CAST, a function instance) alive - OWN; DROP_AT_EXIT (OwnershipStatements.borrowInScope(String, String, DebugInfo)).
String	BoundaryConditionBuilder.build(List<IRInstr> innerBody, String drainItemVar)
List<IRInstr>	CloseChain.closeOperator(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	The body of a type's close followed, on every path, by its generated chain.
List<IRInstr>	ResourceCloser.closingRegion(List<IRInstr> body, List<ResourceCloser.Closing> closings, ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	THE owned region: body, then - on the normal path, after an EK9 Exception, and while a Panic unwinds - every value in closings that is present is closed, last first, each in its own protected region; then the first EK9 Exception (the body's, else the first close's) is rethrown with the later close failures suppressed onto it.
List<IRInstr>	CloseChain.constructionFailure(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	A constructor's work after its construction call, with the chain run only if it fails.
List<IRInstr>	CloseChain.constructionFailureInOwnScope(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	CloseChain.constructionFailure(List, IAggregateSymbol, DebugInfo) in a scope of its own (SCOPE_ENTER/SCOPE_EXIT around it), so what the region registers has an entered scope to be released by: a generated constructor has no body scope, and a written one's region sits after its body scope has been left (or, after an explicit super(...), inside it).
(package private) void	StreamEmissionEngine.continueOverIterator(List<EK9Parser.StreamPartContext> stages, IteratorSetup sourceIter, ISymbol sourceElementType, Function<List<IRInstr>, TerminalSetup> terminalResolver, boolean sourceUnbounded, org.antlr.v4.runtime.tree.ParseTree probeSite, DebugInfo debugInfo, List<IRInstr> instructions)	THE pipeline driver over a source iterator: emit a stream given as sourceIter through stages to the terminal, with NO composition limit.
(package private) String	StreamPipelineMachinery.declareElementSlot(List<IRInstr> target, boolean typed, String typeName, String scopeId, DebugInfo debugInfo)	THE declaration of a pipeline's flowing ELEMENT slot - rebound every element (a source item, an emitted item, a drained bucket item, a current group): a compiler-made slot the declaring scope owns, which drops its LAST value at exit and on unwind (A10; EK9_IR_OWNERSHIP_MODEL.md §6), so nothing releases it after the loop.
(package private) String	StreamPipelineMachinery.declareInitialisedSlot(List<IRInstr> target, ISymbol type, String literal, DebugInfo debugInfo)	THE declaration of a compiler-made, initialised SLOT - a counter or flag rebound as the pipeline runs (a head or skip counter, the async in-flight and submitted counts, the windowed-async more flag): REFERENCE, STORE of the initial value, RETAIN, then the slot registered in the current scope, which releases its LAST value on exit and on unwind (A10; EK9_IR_OWNERSHIP_MODEL.md §6).
(package private) void	StreamPipelineMachinery.declareOwnedSlot(List<IRInstr> target, boolean typed, String slot, String typeName, String scopeId, DebugInfo debugInfo)	StreamPipelineMachinery.declareElementSlot(List, boolean, String, String, DebugInfo) for a slot that already has its name - a stream's own for loop variable.
(package private) void	StreamPipelineMachinery.drainNextIntoItem(List<IRInstr> body, HelperSource source, String castTypeName, String drainItemVar, DebugInfo debugInfo)	THE drain-loop body preamble: raw = source.next() (typed Any), cast to the element type, then bound into the persistent drain item variable.
(package private) IteratorSetup	StreamPipelineMachinery.drainSourceToIterator(HelperSource source, ISymbol bucketType, boolean keepsUnset, DebugInfo debugInfo, List<IRInstr> instructions)	As above; keepsUnset appends with += so an UNSET element survives the buffer - a stage never drops one (KeepsUnsetElements).
(package private) IteratorSetup	StreamPipelineMachinery.drainSourceToIterator(HelperSource source, ISymbol bucketType, DebugInfo debugInfo, List<IRInstr> instructions)	MATERIALISE a buffering value source (a GROUP/SPLIT tracker's hasNextGroup/nextGroup, or an async executor's hasNext/next) into a fresh raw EK9_LIST buffer and return an IteratorSetup over it.
protected String	AbstractStreamStageGenerator.emitStageFunctionOperand(List<IRInstr> target, EK9Parser.PipelinePartContext pipelinePartCtx, ISymbol operandSymbol, FunctionSymbol functionType, DebugInfo debugInfo)	THE shared emission of a stream stage's function operand - use this, do not re-derive it.
(package private) void	StreamPipelineMachinery.emitStreamLoop(ConditionAndPostLoop loop, String loopScopeId, DebugInfo debugInfo, List<IRInstr> instructions)	THE emission of a built stream loop: its while (StreamPipelineMachinery.emitWhileLoop(ConditionCaseDetails, String, DebugInfo, List)) then its post-loop instructions (a stage that emits after the loop - tail's drain, join's result).
(package private) void	StreamPipelineMachinery.emitWhileLoop(ConditionCaseDetails conditionCase, String loopScopeId, DebugInfo debugInfo, List<IRInstr> instructions)	THE while loop of a stream loop: conditionCase as a WHILE over loopScopeId, appended to instructions.
(package private) String	IterationSourceLowering.enumInstanceForIteration(IAggregateSymbol enumType, DebugInfo debugInfo, List<IRInstr> instructions)	An unset instance of an enumeration type, made by its default constructor, in a fresh managed temp.
ArgumentDetails	CallArguments.evaluate(EK9Parser.ParamExpressionContext paramExpression, CallArguments.DebugInfoPolicy debugInfoPolicy, Function<ExprProcessingDetails, List<IRInstr>> exprProcessor, List<IRInstr> instructions)	Evaluate every argument of the parameter expression (which may be null) into the instructions.
ArgumentDetails	CallArguments.evaluate(EK9Parser.ParamExpressionContext paramExpression, CallArguments.DebugInfoPolicy debugInfoPolicy, Function<ExprProcessingDetails, List<IRInstr>> exprProcessor, List<IRInstr> instructions)	Evaluate every argument of the parameter expression (which may be null) into the instructions.
protected String	AbstractStreamStageGenerator.evaluateExpressionOperand(EK9Parser.PipelinePartContext pipelinePartCtx, List<IRInstr> target, DebugInfo debugInfo)	THE evaluation of a stream operand written as an EXPRESSION - an objectAccessExpression or a call - into a fresh, managed (RETAIN + SCOPE_REGISTER) temp.
protected String	AbstractStreamStageGenerator.extractPrimitive(List<IRInstr> target, String booleanVar, DebugInfo debugInfo)	THE Boolean-to-primitive extraction: mint a temp and append the _true() call that yields a JVM primitive / LLVM i8 the branch instructions can test directly.
List<IRInstr>	ResourceCloser.failureRegion(List<IRInstr> body, List<ResourceCloser.Closing> closings, ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	The closes of ResourceCloser.closingRegion(List, List, ResourceCloser.FirstFailure, DebugInfo), run only when body fails with an EK9 Exception - which is then rethrown with any close failure suppressed onto it.
List<IRInstr>	ResourceCloser.finallyRegion(List<IRInstr> body, Supplier<List<IRInstr>> finallyBuilder, DebugInfo debugInfo)	body, then finallyBuilder's instructions on EVERY exit - its normal end, an EK9 Exception, a Panic, a cancelled async task's Cancelled - with nothing caught: a TRY_CATCH_FINALLY with no catch, in its own chain scope.
List<IRInstr>	ResourceCloser.finallyRegion(List<IRInstr> body, Supplier<List<IRInstr>> finallyBuilder, DebugInfo debugInfo)	body, then finallyBuilder's instructions on EVERY exit - its normal end, an EK9 Exception, a Panic, a cancelled async task's Cancelled - with nothing caught: a TRY_CATCH_FINALLY with no catch, in its own chain scope.
protected List<IRInstr>	AbstractStreamStageGenerator.gate(List<IRInstr> conditionInstructions, String conditionVar, String primitiveVar, List<IRInstr> bodyWhenTrue, List<IRInstr> bodyWhenFalse, DebugInfo debugInfo)	THE conditional gate: run bodyWhenTrue when the condition holds, bodyWhenFalse otherwise.
List<IRInstr>	ControlFlowChainGenerator.generateAssignIfUnset(ISymbol lhsSymbol, List<IRInstr> assignmentEvaluation, String assignmentResult, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for assign-if-unset (:=?).
List<IRInstr>	ControlFlowChainGenerator.generateExternalFieldAssignIfUnset(String isSetBoolean, List<IRInstr> assignmentBody, DebugInfo debugInfo)	Generate CONTROL_FLOW_CHAIN for assign-if-unset on external field.
boolean	StatementOwnedCloseables.involvesCloseables(List<IRInstr> evaluation, ISymbol resultType)	True when StatementOwnedCloseables.ownedEvaluation(ParserRuleContext, List, String, ISymbol) could do anything to this evaluation: its value is closeable, or it makes a closeable temporary phase 5 marked as owned, or it holds one deferred to it.
(package private) String	IterationSourceLowering.iteratorOf(IAggregateSymbol sourceType, String sourceVar, IAggregateSymbol iteratorType, DebugInfo debugInfo, List<IRInstr> instructions)	sourceVar.iterator() into a fresh managed temp, typed iteratorType.
protected String	AbstractStreamStageGenerator.loadManagedLiteral(List<IRInstr> target, String value, ISymbol type, DebugInfo debugInfo)	THE load of a compiler-made literal ("0", "1", a fixed head/tail limit, "true") into a fresh managed temp - mints the temp, then the managed literal load.
static OperationBodyPlan.Step	OperationBodyPlan.Step.of(Supplier<List<IRInstr>> instructions)	A part that is a list made when the part is reached.
List<IRInstr>	GuardedScopeOrchestrator.orchestrate(org.antlr.v4.runtime.tree.ParseTree ctx, EK9Parser.PreFlowStatementContext preFlowStmt, EK9Parser.ReturningParamContext returningParam, Function<GuardedScopeOrchestrator.OrchestratorContext, List<IRInstr>> coreGenerator)	Orchestrate for constructs whose core produces List<IRInstr>.
List<IRInstr>	GuardedScopeOrchestrator.orchestrate(org.antlr.v4.runtime.tree.ParseTree ctx, EK9Parser.PreFlowStatementContext preFlowStmt, EK9Parser.ReturningParamContext returningParam, Function<GuardedScopeOrchestrator.OrchestratorContext, List<IRInstr>> coreGenerator, boolean coreManagesReturnSetup)	Orchestrate with control over return-variable setup placement.
StatementOwnedCloseables.OwnedTemporaries	StatementOwnedCloseables.own(List<IRInstr> instructions, DebugInfo debugInfo)	The closeable temporaries these instructions make that phase 5 marked as owned: the owner declarations (emit them before the region that closes them), the same instructions with each temporary handed over to its owner right after the call that made it, and one ResourceCloser.Closing per owner, in the order the temporaries are made.
protected void	AbstractStreamStageGenerator.ownedBy(List<IRInstr> target, String value, String scopeId, DebugInfo debugInfo)	THE stream statement that scopeId owns a value just made (+1) here - DROP_AT_EXIT (OwnershipStatements.droppedAtExit(String, String, DebugInfo)).
StatementOwnedCloseables.OwnedEvaluation	StatementOwnedCloseables.ownedEvaluation(org.antlr.v4.runtime.ParserRuleContext ctx, List<IRInstr> evaluation, String resultVariable, ISymbol resultType)	An evaluation nested inside another instruction (a condition, a control, an operand) that hands ONE value on: the evaluation wrapped, like a statement, in THE owned region that closes the closeable temporaries it made - and the variable that now holds its value after the region.
protected List<IRInstr>	AbstractGenerator.processBlockStatements(EK9Parser.BlockContext ctx, Function<EK9Parser.BlockStatementContext, List<IRInstr>> blockStmtGenerator)	Process all block statements from a BlockContext by unwrapping to InstructionBlockContext.
protected List<IRInstr>	AbstractGenerator.processBlockStatements(EK9Parser.InstructionBlockContext ctx, Function<EK9Parser.BlockStatementContext, List<IRInstr>> blockStmtGenerator)	Process all block statements in an instruction block.
ISymbol	ConstructorCallProcessor.processChainStart(CallSymbol callSymbol, EK9Parser.CallContext callContext, String resultVariable, List<IRInstr> instructions)	THE constructor call that STARTS an object-access chain - String(move).upperCase(), Holder(3).amount(), SomeText("en").message().
void	ConstructorCallProcessor.processConstructorCall(CallSymbol callSymbol, EK9Parser.CallContext callContext, String resultVariable, List<IRInstr> instructions)	Process a constructor call that creates a new object and generate appropriate IR instructions - the owner is the (resolved) type of the constructor itself.
void	ConstructorCallProcessor.processDelegatingConstructorCall(CallSymbol callSymbol, EK9Parser.CallContext callContext, String resultVariable, String thisOrSuper, List<IRInstr> instructions)	Process a delegating constructor call - this(...) or super(...) - whose target object is the receiver being constructed.
protected void	AbstractStreamStageGenerator.publishAndContinue(List<IRInstr> target, String outVar, String producedVar, List<IRInstr> innerBody, DebugInfo debugInfo)	Publish a stage's produced value into the flowing out-variable: RELEASE old, STORE new, RETAIN new, then run the inner body (the terminal, or the next stage downstream).
protected void	AbstractStreamStageGenerator.publishCallResultAndContinue(List<IRInstr> target, String outVar, IRInstr callInstr, List<IRInstr> innerBody, DebugInfo debugInfo)	AbstractStreamStageGenerator.publishAndContinue(List, String, String, List, DebugInfo) for a stage value made by a call here (map, call): moved into the out-variable (AbstractStreamStageGenerator.rebindToCallResult(List, String, IRInstr, DebugInfo)), then the inner body.
(package private) IteratorSetup	StreamPipelineMachinery.rawListIterator(String bufferVar, DebugInfo debugInfo, List<IRInstr> instructions)	THE iterator over a stream's raw org.ek9.lang::List buffer: buffer.iterator() into a fresh managed temp, typed as the raw Iterator over the raw List - so the loops that read it cast each next() (an Any) to the element type.
protected void	AbstractStreamStageGenerator.rebind(List<IRInstr> target, String variable, String sourceVar, DebugInfo debugInfo)	THE alloca-backed variable reassignment: RELEASE the old value, STORE the new one, RETAIN it.
protected void	AbstractStreamStageGenerator.rebindToCallResult(List<IRInstr> target, String slot, IRInstr callInstr, DebugInfo debugInfo)	THE move of a call's result, made here, into a slot: the call, then SLOT_ASSIGN slot, result [consume] - the slot takes the call's count, and nothing else owns the result (OwnershipStatements.reboundFresh(String, String, DebugInfo); the harness rule move-into-slot).
protected void	AbstractStreamStageGenerator.rebindToCastCallResult(List<IRInstr> target, String slot, IRInstr callInstr, String castTypeName, DebugInfo debugInfo)	THE move of a call's result, cast to the element type, into a slot: a raw source's next() hands back Any at +1, the CAST takes that count (V-D) and SLOT_ASSIGN slot, cast [consume] moves it in (OwnershipStatements.reboundFresh(String, String, DebugInfo); harness rule move-into-slot).
(package private) ObjectAccessInstrGenerator.ChainStepResult	ObjectAccessInstrGenerator.receiverOfFinalStep(EK9Parser.ObjectAccessExpressionContext ctx, List<IRInstr> instructions)	THE receiver of a chain's FINAL step - getHolder() in getHolder().name, keeper.holder() in keeper.holder().name - evaluated into a temp by exactly the lowering the read side uses for the same chain (start, calls and property loads, with their ARC), so an assignment target that reaches its field through a call cannot lower the call differently from a read of it.
(package private) IteratorSetup	StreamPipelineMachinery.sortBufferAndGetIterator(EK9Parser.StreamPartContext sortStage, String bufferVar, DebugInfo debugInfo, List<IRInstr> instructions)	Sort a raw org.ek9.lang::List buffer in place and return an iterator over the sorted result.
(package private) String	IterationSourceLowering.sourceValue(EK9Parser.ExpressionContext sourceCtx, IAggregateSymbol sourceType, DebugInfo debugInfo, List<IRInstr> instructions)	The source's value in a fresh managed temp: the enumeration instance (IterationSourceLowering.enumInstanceForIteration(IAggregateSymbol, DebugInfo, List)) or the evaluated expression.
(package private) List<IRInstr>	FlattenStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String inVar, String outVar, List<StageState.Counter> downstreamHeads)	Wrap with the downstream body GENERATED inside this flatten's per-element body scope: downstream is called once that scope is current, so whatever the downstream stages register (a head's comparison, a map's result) is owned by the inner loop's body and released every inner iteration - not by a scope entered once around the whole loop, which would release only the last element's (A11; EK9_IR_OWNERSHIP_MODEL.md §7).
List<IRInstr>	FunctionProbes.wrap(List<IRInstr> body, FunctionProbes.Registered probes, IRInstr beforeReturn)	A body generated without probes, instrumented afterwards: the entry probes first, then the body, with beforeReturn (if any) and then the profiling exit before every top-level RETURN.
List<IRInstr>	JoinStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)
(package private) List<IRInstr>	JoinStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap with the downstream body GENERATED inside the post-loop emit's own scope: downstream is called once that scope is current, so what the downstream stages register is owned by a scope open where they run.
(package private) List<IRInstr>	JoinStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap with the downstream body GENERATED inside the post-loop emit's own scope: downstream is called once that scope is current, so what the downstream stages register is owned by a scope open where they run.
List<IRInstr>	StreamPostLoopStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap innerBody such that it runs after the loop rather than during it.
List<IRInstr>	TailStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)
(package private) List<IRInstr>	TailStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap with the downstream body GENERATED inside the drain loop's per-element body scope: downstream is called once that scope is current, so what the downstream stages register is owned by the drain's iteration, not by a scope entered once around the pipeline (A11; EK9_IR_OWNERSHIP_MODEL.md §7).
(package private) List<IRInstr>	TailStageWrapper.wrap(StageWrapParams params, Supplier<List<IRInstr>> downstream, String pipelineItemVar, StageState stageState, List<IRInstr> postLoopInstructions)	Wrap with the downstream body GENERATED inside the drain loop's per-element body scope: downstream is called once that scope is current, so what the downstream stages register is owned by the drain's iteration, not by a scope entered once around the pipeline (A11; EK9_IR_OWNERSHIP_MODEL.md §7).
List<IRInstr>	LoopGuardHelper.wrapBodyWithGuardEntryCheck(GuardVariableDetails guardDetails, List<IRInstr> bodyInstructions, String guardScopeId, DebugInfo debugInfo)	Wrap body instructions in an IF_ELSE_IF that checks the guard entry condition.
List<IRInstr>	LoopGuardHelper.wrapExpressionFormWithGuardEntryCheck(GuardVariableDetails guardDetails, List<IRInstr> returnVariableSetup, List<IRInstr> bodyInstructionsWithoutRtn, String guardScopeId, DebugInfo debugInfo)	Wrap body instructions in an IF_ELSE_IF for EXPRESSION FORM with return variable.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates)	Wrap an innermost body with intermediate pipeline stages in reverse order.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates, String asyncExecutorVar)	Wrap inner body instructions with intermediate pipeline stages in reverse order.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates, String asyncExecutorVar, PipelineVarPlan plan)	Core stage-wrapping with an explicit per-boundary PipelineVarPlan.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, List<StageState> stageStates, String asyncExecutorVar, PipelineVarPlan plan)	Core stage-wrapping over an innermost body that is GENERATED on demand: innerBody is called where the body is placed, so when a flatten or tail opens a loop around it, what it registers is owned by that loop's iteration (A11).

Constructors in org.ek9lang.compiler.phase7.generator with parameters of type IRInstr

Modifier	Constructor	Description
	Registered(IRInstr coverageEntry, IRInstr profilingEntry, IRInstr profilingExit)	Creates an instance of a Registered record class.

Constructor parameters in org.ek9lang.compiler.phase7.generator with type arguments of type IRInstr

Modifier	Constructor	Description
(package private)	AbstractShortCircuitGenerator(IRGenerationContext stackContext, VariableMemoryManagement variableMemoryManagement, RecordExprProcessing recordExprProcessing, Function<LogicalDetails, IRInstr> logicalOperation, Supplier<StatementOwnedCloseables> ownedCloseables)
protected	AssertBodyResult(List<IRInstr> bodyInstructions, String scopeId, String expressionText)	Creates an instance of a AssertBodyResult record class.
(package private)	BufferedStageParams(StageGroup stageGroup, StreamSource source, TerminalSetup terminalSetup, List<IRInstr> instructions, DebugInfo debugInfo, org.antlr.v4.runtime.tree.ParseTree probeSite)	Creates an instance of a BufferedStageParams record class.
(package private)	CaseConstructorParams(List<IRInstr> directionCheck, String directionPrimitive, List<IRInstr> loopConditionTemplate, String loopConditionPrimitive, List<IRInstr> loopBodySetup, ForRangePolymorphicInstr.ValueGuard valueGuard, ForRangePolymorphicInstr.EndCheck endCheck, List<IRInstr> loopIncrement, ForRangePolymorphicInstr.ProgressCheck progressCheck)	Creates an instance of a CaseConstructorParams record class.
	Closing(List<IRInstr> load, String variable, ISymbol staticType, String staticTypeName, DebugInfo debugInfo)	A value brought into a variable by load (a property's LOAD_FIELD).
	Closing(List<IRInstr> load, String variable, ISymbol staticType, String staticTypeName, DebugInfo debugInfo, boolean viaSuper)	Creates an instance of a Closing record class.
	ComparisonResult(List<IRInstr> instructions, String resultVariable, String primitiveCondition)	Creates an instance of a ComparisonResult record class.
(package private)	ConditionAndPostLoop(ConditionCaseDetails conditionCase, List<IRInstr> postLoopInstructions)	Creates an instance of a ConditionAndPostLoop record class.
	ConditionEvaluation(List<IRInstr> instructions, String primitiveCondition)	Creates an instance of a ConditionEvaluation record class.
	ConstructorCallProcessor(IRGenerationContext stackContext, CallArguments callArguments, ParameterPromotionProcessor parameterPromotionProcessor, Function<ExprProcessingDetails, List<IRInstr>> expressionProcessor)
	ControlFlowChainGenerator(IRGenerationContext stackContext, VariableMemoryManagement variableMemoryManagement, SynthesisedCallMetaData synthesisedCallMetaData, Function<ExprProcessingDetails, List<IRInstr>> rawExprProcessor, Supplier<StatementOwnedCloseables> ownedCloseables)
	DeclarationParts(List<IRInstr> declaration, List<IRInstr> initialisation)	Creates an instance of a DeclarationParts record class.
(package private)	DrainCondition(String scopeId, List<IRInstr> instructions, String callResult, String hasNextVar)	Creates an instance of a DrainCondition record class.
(package private)	Evaluated(List<IRInstr> instructions, String primitiveResult, String expressionText, DebugInfo debugInfo)	Creates an instance of a Evaluated record class.
(package private)	FreshBooleanOperand(List<IRInstr> instructions, String result, String primitive)	Creates an instance of a FreshBooleanOperand record class.
(package private)	InitializationData(List<IRInstr> instructions, String endTemp, String byTemp, String directionTemp, String currentTemp, ISymbol rangeType, ISymbol byType, ISymbol constrainedBase, String startTemp, boolean progressChecked)	Creates an instance of a InitializationData record class.
	OwnedEvaluation(List<IRInstr> instructions, String resultVariable, boolean owning)	Creates an instance of a OwnedEvaluation record class.
	OwnedTemporaries(List<IRInstr> declarations, List<IRInstr> instructions, List<ResourceCloser.Closing> closings)	Creates an instance of a OwnedTemporaries record class.
(package private)	StageSetupResult(List<IRInstr> preLoopInstructions, List<StageState> stageStates)	Creates an instance of a StageSetupResult record class.
(package private)	StageWrapParams(EK9Parser.StreamPartContext stageCtx, List<IRInstr> innerBody, DebugInfo debugInfo)	Creates an instance of a StageWrapParams record class.
(package private)	StageWrapResult(List<IRInstr> wrappedBody, List<IRInstr> postLoopInstructions)	Creates an instance of a StageWrapResult record class.

Uses of IRInstr in org.ek9lang.compiler.phase7.support

Classes in org.ek9lang.compiler.phase7.support that implement interfaces with type arguments of type IRInstr

Modifier and Type	Class	Description
final class	BinaryOperatorInvoker	CONCERN: Binary operator invocation with memory management.
final class	BooleanFalseEvaluationCreator	Creates evaluation instructions for Boolean._ofFalse() static method call.
final class	ComparisonEvaluator	CONCERN: Comparison evaluation with boolean primitive extraction.
final class	IncrementEvaluator	CONCERN: Loop counter increment/decrement.
class	IRInstrToList	Converts the single IRInstr supplied by the supplier into a List with one element in.
class	IRInstrToList	Converts the single IRInstr supplied by the supplier into a List with one element in.
final class	ManagedLiteralLoader	CONCERN: Literal loading with memory management.
final class	PrimitiveBooleanExtractor	CONCERN: Boolean primitive extraction from EK9 Boolean objects.
class	RecordExprProcessing	Triggers the expression processing with the given details.
final class	ScopeRegisterOnly	Memory management for CONSUMING a value that was already RETAIN'd by a producer.
final class	ScopeRegisterOnly	Memory management for CONSUMING a value that was already RETAIN'd by a producer.
final class	UnaryOperatorInvoker	CONCERN: Unary operator invocation with memory management.
final class	VariableMemoryManagement	Calls a supplier of main processing instructions and then adds in the memory management.
final class	VariableMemoryManagement	Calls a supplier of main processing instructions and then adds in the memory management.

Methods in org.ek9lang.compiler.phase7.support that return IRInstr

Modifier and Type	Method	Description
IRInstr	ShortCircuitBlock.and(ShortCircuitBlock.Operands operands)	RIGHT is evaluated only when LEFT is true.
IRInstr	CycleGuardOwner.load(String resultVar, IAggregateSymbol aggregate, DebugInfo debugInfo)	Load the constant for a guarded operator - a borrowed reference, neither retained nor released.
IRInstr	ShortCircuitBlock.of(Function<LogicalDetails, IRInstr> operation, ShortCircuitBlock.Operands operands)	The block for the given operation (LogicalOperationInstr::andOperation or ::orOperation).
IRInstr	ShortCircuitBlock.or(ShortCircuitBlock.Operands operands)	RIGHT is evaluated only when LEFT is false.

Methods in org.ek9lang.compiler.phase7.support that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	BinaryOperatorInvoker.apply(BinaryOperatorParams params)	Invoke binary operator on two operands.
List<IRInstr>	BooleanFalseEvaluationCreator.apply(VariableDetails variableDetails)
List<IRInstr>	BooleanNotEvaluationCreator.apply(String booleanVariable, VariableDetails resultDetails)	Creates Boolean._not() method call instructions.
List<IRInstr>	ComparisonEvaluator.apply(ComparisonParams params)	Evaluate comparison and extract primitive boolean.
List<IRInstr>	ConstantCopyOnAccessLoader.apply(ISymbol constantSymbol, String resultVariable, DebugInfo debugInfo)	Read the constant into resultVariable as a fresh copy.
List<IRInstr>	IncrementEvaluator.apply(IncrementParams params)	Evaluate increment/decrement on the counter variable.
List<IRInstr>	IRInstrToList.apply(Supplier<IRInstr> supplier)
List<IRInstr>	IsSetEvaluationCreator.apply(String operandVariable, ISymbol operandSymbol, VariableDetails resultDetails)	Creates _isSet() method call instructions.
List<IRInstr>	ManagedLiteralLoader.apply(LiteralParams params)	Load literal value into temp variable with memory management.
List<IRInstr>	PrimitiveBooleanExtractor.apply(BooleanExtractionParams params)	Extract primitive boolean from EK9 Boolean object.
List<IRInstr>	RecordExprProcessing.apply(ExprProcessingDetails details)
List<IRInstr>	ScopeRegisterOnly.apply(Supplier<List<IRInstr>> mainProcessing, VariableDetails target)
List<IRInstr>	UnaryOperatorInvoker.apply(UnaryOperatorParams params)	Invoke unary operator on operand.
List<IRInstr>	VariableMemoryManagement.apply(Supplier<List<IRInstr>> mainProcessing, VariableDetails target)
List<IRInstr>	OwnershipStatements.armResultFresh(String chainResult, String value, DebugInfo debugInfo)	THE move of a value just made, by one arm of a chain, into the chain's result - which is empty when an arm runs, since exactly one arm sets it (EK9_IR_OWNERSHIP_MODEL.md §4, merges): SLOT_ASSIGN r, v [consume, init], lowered to STORE r, v.
List<IRInstr>	OwnershipStatements.borrowInScope(String variable, String scopeId, DebugInfo debugInfo)	THE borrow with an explicit registration scope, for a body that pushes no frame (synthesis - tidy plan decision 3): a value that arrived at +0 (a CAST of a parameter, a LOAD) is owned for that scope and dropped at its exit.
List<IRInstr>	ConditionalEvaluation.conditionInstructions()	Returns the value of the conditionInstructions record component.
List<IRInstr>	OwnershipStatements.declaredOwnedSlot(String slot, String typeName, String scopeId, boolean typed, DebugInfo debugInfo)	THE declaration of a compiler-made slot its scope owns and that nothing initialises where it is declared - it is only ever rebound (a stream join accumulator, a type-boundary out-variable): the scope releases its LAST value (A10).
List<IRInstr>	OwnershipStatements.declaredSlot(String slot, String typeName, String owner, DebugInfo debugInfo)	THE declaration of a named slot and of its owner: a local is owned by the scope that declares it, a parameter or returning variable by the CALLER (OwnershipInstr.CALLER), a property by its OBJECT (OwnershipInstr.OBJECT).
List<IRInstr>	OwnershipStatements.droppedAtExit(String value, String scopeId, DebugInfo debugInfo)	THE value-ownership function (D-O11, EK9_IR_OWNERSHIP_STAGE1_DESIGN.md §11): states, where a value is made, that the scope owns it - DROP_AT_EXIT, dropped at every exit of the scope's activation (lowered to SCOPE_REGISTER).
List<IRInstr>	OwnershipStatements.escaping(String value, DebugInfo debugInfo)	THE extra count a value takes so that it outlives the region it was evaluated in - a chain arm's value handed out as the chain's result while the arm's region still drops its own count (EK9_IR_OWNERSHIP_MODEL.md §4, an escape): OWN v.
List<IRInstr>	OperandEvaluation.evaluationInstructions()	Returns the value of the evaluationInstructions record component.
List<IRInstr>	ScopedInstructionExecutor.execute(Supplier<List<IRInstr>> instructionGenerator, DebugInfo debugInfo)	Execute instructions within temporary scope.
List<IRInstr>	OwnershipStatements.fieldAssigned(FieldTarget field, String value, OwnershipInstr.AssignMode mode, boolean init, DebugInfo debugInfo)	THE store of a value into an object's FIELD (family 6): drop the field's old value and store the new one - [copy] takes the field's own reference to a value something else still owns, [consume] moves an owned value in; init is the fact that the field is empty here (a constructor's first store), so there is nothing to drop.
List<IRInstr>	OwnershipStatements.handedOver(String target, String source, DebugInfo debugInfo)	THE hand-over of a slot's value to another slot that is empty here, after which the source slot is done with: a control-flow expression's returning variable handed to the expression's result (J3).
List<IRInstr>	CycleGuardOwner.initialise(IAggregateSymbol aggregate, String tempVar, DebugInfo debugInfo)	Make the constant, once, in the type's _c_init.
List<IRInstr>	OwnershipStatements.initialised(String slot, String value, DebugInfo debugInfo)	THE first value of a local declared with one (x <- v): the slot takes its own reference to a value its scope still owns, and the declaring scope owns the slot.
List<IRInstr>	OwnershipStatements.initialisedFresh(String slot, String value, DebugInfo debugInfo)	THE first value of a local declared with a value just made (x <- Call()): the slot takes the producer's count, so the value is neither registered with a scope nor retained again (EK9_IR_OWNERSHIP_MODEL.md §6, [consume]).
List<IRInstr>	ConditionEvaluationResult.instructions()	Returns the value of the instructions record component.
List<IRInstr>	ConstantCopyOnAccessLoader.LoadedConstant.instructions()	Returns the value of the instructions record component.
List<IRInstr>	LoopIterationCondition.Evaluated.instructions()	Returns the value of the instructions record component.
List<IRInstr>	LoopIterationCondition.instructions()	Returns the value of the instructions record component.
List<IRInstr>	PromotedVariable.instructions()	Returns the value of the instructions record component.
List<IRInstr>	ScopedInstructionExecutor.ScopedBlock.instructions()	Returns the value of the instructions record component.
List<IRInstr>	CaptureStores.of(List<ISymbol> capturedVars, List<ISymbol> parameters, DebugInfo debugInfo)	The stores of each captured variable's property from the capture constructor's parameter at the same position.
List<IRInstr>	CaptureStores.of(List<ISymbol> capturedVars, DebugInfo debugInfo)	The stores of a construct whose capture constructor's parameters are its captured variables themselves (a dynamic function's, or a dynamic class's synthetic one).
List<IRInstr>	SamenessTypeCheck.of(IRGenerationContext stackContext, String otherVar, String differentTypeLabel, DebugInfo debugInfo)	The check: this against otherVar, going to differentTypeLabel when they differ.
List<IRInstr>	SanitizedParameterPrologue.of(IRGenerationContext stackContext, List<ISymbol> parameters)	Create the prologue that cleans every SANITIZED_REQUIRED parameter in place, each instruction attributed to the parameter's own declaration.
List<IRInstr>	SanitizedParameterPrologue.of(IRGenerationContext stackContext, List<ISymbol> parameters, DebugInfo debugInfo)	Create the prologue with every instruction attributed to debugInfo.
List<IRInstr>	PromotionResult.promotionInstructions()	Returns the value of the promotionInstructions record component.
List<IRInstr>	OwnershipStatements.propertyAssigned(String property, String value, boolean init, DebugInfo debugInfo)	THE store of a value into a PROPERTY named as a slot of its object (this.p): the property takes its own reference to a value something else still owns, and drops the value it replaces unless it is empty here (init, a property initialiser's first store).
List<IRInstr>	OwnershipStatements.rebound(String slot, String value, DebugInfo debugInfo)	THE rebinding of a slot that already holds a value - drop the old one, take a reference to the new one: SLOT_ASSIGN x, v [copy] (lowered: RELEASE x; STORE x, v; RETAIN x).
List<IRInstr>	OwnershipStatements.reboundFresh(String slot, String value, DebugInfo debugInfo)	THE rebinding of a slot to a value just made (x := Call()): drop the old value and move the new one in.
List<IRInstr>	VariableMemoryManagement.registerIfOwnedProducer(List<IRInstr> instructions, VariableDetails target)	SCOPE_REGISTER the target ONLY when it is a freshly produced (+1) value, adding nothing for a borrow.
List<IRInstr>	OwnershipStatements.returnFresh(String returnVariable, String value, DebugInfo debugInfo)	THE move of a value just made into the returning variable: the return variable takes the producer's count, so the value is neither registered with a scope nor retained again (EK9_IR_OWNERSHIP_MODEL.md §6, [consume]).
List<IRInstr>	OwnershipStatements.returnSlot(String returnVariable, String typeName, DebugInfo debugInfo)	THE declaration of the return variable: owned by the CALLER, never released by a scope here - SLOT_DECLARE rtn, T, CALLER (lowered to REFERENCE rtn, T).
List<IRInstr>	OwnershipStatements.storeReturn(String returnVariable, String value, DebugInfo debugInfo)	THE store of a result into the returning variable (tidy plan 8a rule 3): SLOT_ASSIGN rtn, v [copy, init] - the return variable takes its own reference to a value its scope still owns, into a slot that is empty here - which lowers to exactly STORE rtn, v; RETAIN rtn.

Method parameters in org.ek9lang.compiler.phase7.support with type arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	IRInstrToList.apply(Supplier<IRInstr> supplier)
List<IRInstr>	ScopeRegisterOnly.apply(Supplier<List<IRInstr>> mainProcessing, VariableDetails target)
List<IRInstr>	VariableMemoryManagement.apply(Supplier<List<IRInstr>> mainProcessing, VariableDetails target)
String	BooleanCondition.asBoolean(EK9Parser.ExpressionContext condition, String conditionVariable, DebugInfo debugInfo, List<IRInstr> instructions)	The Boolean holding the condition: the evaluated variable itself, or - for a type that promotes to Boolean - the result of its _promote(), appended to instructions (scope-local, released with the scope).
String	DelegateLoad.borrowed(List<IRInstr> instructions, Supplier<String> newTemp, String objectVar, String ownerType, String delegateType, String scopeId, DebugInfo debugInfo)	Load objectVar.delegate into a new temporary, borrowed for scopeId.
String	WrapperGivenAsAny.castWhenExactly(List<IRInstr> instructions, Supplier<String> tempNames, String operandName, String wrapperType, String notThisWrapperLabel, String scopeId, DebugInfo debugInfo)	The test of an operand for being exactly wrapperType, and its cast when it is.
String	WrapperGivenAsAny.delegateWhenExactly(List<IRInstr> instructions, Supplier<String> tempNames, String parameterName, String wrapperType, String delegateType, String passAsIsLabel, String scopeId, DebugInfo debugInfo)	The value to hand a base operator for a parameter declared Any: the wrapper's delegate when the argument is exactly wrapperType, the argument as it is otherwise.
void	PanicThrowInstrs.emit(IRGenerationContext stackContext, List<IRInstr> instructions, String message, String exitCode, String scopeId, DebugInfo debugInfo)	Append the construct-and-throw-Panic sequence to instructions.
void	StrictAbsent.emitIfEnabled(IRGenerationContext stackContext, List<IRInstr> instructions, StrictAbsent.Observer observer, DebugInfo debugInfo)	In strict-absent mode, append the Panic to instructions - the start of the branch a compiled absence test takes on a null.
List<IRInstr>	ScopedInstructionExecutor.execute(Supplier<List<IRInstr>> instructionGenerator, DebugInfo debugInfo)	Execute instructions within temporary scope.
ScopedInstructionExecutor.ScopedBlock	ScopedInstructionExecutor.executeWithScopeId(Function<String, List<IRInstr>> body, DebugInfo debugInfo)	THE scoped body for a generator whose body needs, or whose caller needs, the scope id.
boolean	VariableMemoryManagement.isOwnedProducer(List<IRInstr> instructions, String target)	True when the evaluation hands target back at +1, owned by whoever receives it - made OWNED by the instruction that ends it (ValueKind.madeBy(IRInstr), the rule the verifier checks against: a call, constructors and operators included, or a literal) or an escaping chain result: THE question a receiver asks before owning a value rather than borrowing it, or moving it rather than copying it.
static PromotedVariable	PromotedVariable.of(String variable, List<IRInstr> instructions)	Create a promoted variable result.
IRInstr	ShortCircuitBlock.of(Function<LogicalDetails, IRInstr> operation, ShortCircuitBlock.Operands operands)	The block for the given operation (LogicalOperationInstr::andOperation or ::orOperation).
String	BooleanCondition.primitiveOf(String booleanVariable, DebugInfo debugInfo, List<IRInstr> instructions)	The primitive boolean a branch reads from a variable already holding a Boolean (BooleanCondition.asBoolean(EK9Parser.ExpressionContext, String, DebugInfo, List)): _true(), appended to instructions.
String	CollectionElementPromoter.promoteIfRequired(ISymbol elementType, ISymbol targetType, String elementTemp, DebugInfo debugInfo, List<IRInstr> setupInstructions)	Insert a #^ promotion for a collection element when its static type is not directly assignable to the collection's resolved element type but is coercible to it (single promotion, per EK9 rules).
String	CollectionElementPromoter.promoteIfRequired(ISymbol elementType, ISymbol targetType, String elementTemp, DebugInfo debugInfo, List<IRInstr> setupInstructions, boolean escaping)	As CollectionElementPromoter.promoteIfRequired(ISymbol, ISymbol, String, DebugInfo, List), but escaping selects the ARC of any inserted promote: false for a scope-local value (collection element, range bound, comparison operand) — RETAIN + SCOPE_REGISTER; true for a value that ESCAPES the current scope (a coalescing/ternary body-result that becomes the expression value) — RETAIN only, the consumer takes ownership.
List<IRInstr>	VariableMemoryManagement.registerIfOwnedProducer(List<IRInstr> instructions, VariableDetails target)	SCOPE_REGISTER the target ONLY when it is a freshly produced (+1) value, adding nothing for a borrow.
String	BooleanCondition.toPrimitive(EK9Parser.ExpressionContext condition, String conditionVariable, DebugInfo debugInfo, List<IRInstr> instructions)	The primitive boolean a branch reads: the condition as a Boolean (BooleanCondition.asBoolean(EK9Parser.ExpressionContext, String, DebugInfo, List)), then _true().

Constructor parameters in org.ek9lang.compiler.phase7.support with type arguments of type IRInstr

Modifier	Constructor	Description
	ConditionalEvaluation(List<IRInstr> conditionInstructions, String conditionResult)	Creates an instance of a ConditionalEvaluation record class.
	ConditionEvaluationResult(List<IRInstr> instructions, String primitiveVariableName)	Creates an instance of a ConditionEvaluationResult record class.
	Evaluated(List<IRInstr> instructions, String resultVariable, String primitiveCondition)	Creates an instance of a Evaluated record class.
	LoadedConstant(List<IRInstr> instructions, String resultVariable)	Creates an instance of a LoadedConstant record class.
	LoopIterationCondition(String scopeId, List<IRInstr> instructions, String resultVariable, String primitiveCondition)	Creates an instance of a LoopIterationCondition record class.
	OperandEvaluation(List<IRInstr> evaluationInstructions, String operandName)	Creates an instance of a OperandEvaluation record class.
	PromotedVariable(String variable, List<IRInstr> instructions)	Creates an instance of a PromotedVariable record class.
	RecordExprProcessing(Function<ExprProcessingDetails, List<IRInstr>> processor, VariableMemoryManagement variableMemoryManagement)
	ScopedBlock(String scopeId, List<IRInstr> instructions)	Creates an instance of a ScopedBlock record class.

Uses of IRInstr in org.ek9lang.compiler.phase7.synthesis

Methods in org.ek9lang.compiler.phase7.synthesis that return types with arguments of type IRInstr

Modifier and Type	Method	Description
protected List<IRInstr>	AbstractSyntheticGenerator.fieldIsSetCall(ISymbol field, String fieldVar, String resultVar, DebugInfo debugInfo, String scopeId)	THE field._isSet() step of the field-wise synthetic generators - a trait-typed field is dispatched through its interface.
protected List<IRInstr>	AbstractSyntheticGenerator.fieldOperatorCall(ISymbol field, String fieldVar, String glyph, String jvmMethodName, String otherVar, String returnTypeName, String resultVar, DebugInfo debugInfo, String scopeId)	THE per-field "call the field type's own operator, or fall back to Any's" step of every field-wise synthetic generator (==, <=>, #?, $, $$) - use this, never a hand-written fieldCapable ? getType(field) : getAnyType() (SYN-3).
(package private) List<IRInstr>	CloseGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _close operator IR for the given aggregate.
(package private) List<IRInstr>	CompareGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _cmp operator IR for the given aggregate.
(package private) List<IRInstr>	CopyGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _copy operator IR for the given aggregate - its own :=:(Owner), or the override of an inherited :=:(Super) signature (PolymorphicCopy, Q5b; told apart by the parameter type).
(package private) List<IRInstr>	DelegationGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate delegation IR for a synthetic delegation method.
(package private) List<IRInstr>	DerivedComparisonGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate IR for a derived comparison operator.
(package private) List<IRInstr>	EnumConstructorGenerator.generate(MethodSymbol constructorSymbol, AggregateSymbol aggregateSymbol)	Generate a parameterized enum constructor.
List<IRInstr>	EnumFirstLastGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the #< or #> operator for an enumeration.
(package private) List<IRInstr>	EnumIncrementDecrementGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the ++ or -- operator for an enumeration.
List<IRInstr>	EnumIteratorGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the iterator() method for an enumeration.
(package private) List<IRInstr>	EnumPrimitiveOperatorGenerator.generate(EnumPrimitiveOperatorGenerator.Shape shape, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)
(package private) List<IRInstr>	EnumStringParamGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate a String-param comparison operator for an enumeration.
(package private) List<IRInstr>	EqualsGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _eq operator IR for the given aggregate.
(package private) List<IRInstr>	FieldSetStatusGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the _fieldSetStatus method IR for the given aggregate.
List<IRInstr>	FunctionIsSetGenerator.generate(MethodSymbol methodSymbol, FunctionSymbol functionSymbol)	Generate the _isSet operator IR for the given function.
(package private) List<IRInstr>	HashCodeGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _hashcode operator IR for the given aggregate.
(package private) List<IRInstr>	InheritedDispatcherGenerator.generate(MethodSymbol entryPoint, AggregateSymbol aggregateSymbol)
(package private) List<IRInstr>	IsSetGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the _isSet operator IR for the given aggregate.
(package private) List<IRInstr>	NotEqualsGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _neq operator IR for the given aggregate.
(package private) List<IRInstr>	SamenessOverrideGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)
(package private) List<IRInstr>	ToJsonGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _json operator IR for the given aggregate.
(package private) List<IRInstr>	ToStringGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _string operator IR for the given aggregate.
protected List<IRInstr>	AbstractSyntheticGenerator.generateBinaryOperatorGuards(String aggregateTypeName, ISymbol aggregateType, String paramName, String unsetLabel, SynthesisScope ctx)	Generate isSet guards for binary operators (this and param).
protected List<IRInstr>	AbstractSyntheticGenerator.generateBooleanBranch(String booleanVar, String label, boolean branchIfTrue, SynthesisScope ctx)	Extract primitive boolean from Boolean object and branch.
(package private) List<IRInstr>	CopyGenerator.generateCopyAccepts(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the owner's _copyAccepts(target as Any) <- Boolean: is target an instance of this owner (a SUBTYPE test - the owner or any class below it)? Asked of the SOURCE of a copy with the copy's target, so a copy runs in full only between objects whose nearest copy owner is the same class.
protected List<IRInstr>	AbstractSyntheticGenerator.generateCycleGuardedRegion(String exitMethod, AbstractSyntheticGenerator.CycleGuardEntry entry, List<IRInstr> body, String endLabel, SynthesisScope ctx)	THE guarded region of a cycle-guarded operator whose exit returns nothing (?, ==, <=>): the body runs as the try of a TRY_CATCH_FINALLY with NO catches whose finally is the guard's exit, so the exit runs on every path - including an exception thrown by a field's hand-written operator, which would otherwise leave this object's entry behind and make a later call read as a cycle (Contract 13).
protected List<IRInstr>	AbstractSyntheticGenerator.generateFieldLoad(String targetVar, String objectVar, String fieldName, String ownerTypeName, String fieldTypeName, DebugInfo debugInfo, String scopeId)	Generate field load instruction with memory management using explicit LOAD_FIELD.
protected List<IRInstr>	AbstractSyntheticGenerator.generateFieldLoad(String targetVar, String objectVar, String fieldName, String ownerTypeName, String fieldTypeName, SynthesisScope ctx)	Generate field load using SynthesisScope with explicit type information.
protected List<IRInstr>	AbstractSyntheticGenerator.generateFieldSetStatusCheck(String otherParamName, AggregateSymbol aggregateSymbol, DebugInfo debugInfo, String scopeId, String returnUnsetLabel)	Generate field set status comparison check.
protected List<IRInstr>	AbstractSyntheticGenerator.generateIsSetGuard(String variableName, String typeName, ISymbol type, String unsetLabel, SynthesisScope ctx)	Generate isSet guard check for a variable using SynthesisScope.
protected List<IRInstr>	AbstractSyntheticGenerator.generateIsSetGuard(String variableName, String typeName, ISymbol type, DebugInfo debugInfo, String unsetLabel, String scopeId)	Generate isSet guard check for a variable with branch to unset return.
protected List<IRInstr>	AbstractSyntheticGenerator.generatePoisonableCycleGuardedRegion(String exitMethod, AbstractSyntheticGenerator.CycleGuardEntry entry, List<IRInstr> body, String unsetLabel, String keepLabel, SynthesisScope ctx)	THE guarded region of a representation ($, $$): as AbstractSyntheticGenerator.generateCycleGuardedRegion(String, AbstractSyntheticGenerator.CycleGuardEntry, List, String, SynthesisScope), but the exit in the finally also says whether a cycle was met while the body ran.
protected List<IRInstr>	AbstractSyntheticGenerator.generateReplacingUnsetReturnBlockWithLabel(String labelName, String returnTypeName, String returnVarName, SynthesisScope ctx)	AbstractSyntheticGenerator.generateUnsetReturnBlockWithLabel(String, String, String, DebugInfo, String) for a label reached with the return variable possibly holding a value - a representation poisoned by a cycle, discarding what it built (AbstractSyntheticGenerator.generatePoisonableCycleGuardedRegion(String, AbstractSyntheticGenerator.CycleGuardEntry, List, String, String, SynthesisScope)), as well as the guard's back-edge, where it is still empty: the unset value is MOVED in and REPLACES whatever is there (SLOT_ASSIGN rtn, v [consume], lowered to RELEASE rtn - null-safe - then STORE).
protected List<IRInstr>	AbstractSyntheticGenerator.generateResultReturnBlock(String labelName, String returnVarName, DebugInfo debugInfo, String scopeId)	Generate a result return block that returns whatever is in the return variable.
protected List<IRInstr>	AbstractSyntheticGenerator.generateResultReturnBlock(String labelName, String returnVarName, SynthesisScope ctx)	Generate result return block using SynthesisScope.
protected List<IRInstr>	AbstractSyntheticGenerator.generateStringLiteralLoad(String resultVar, String literalValue, DebugInfo debugInfo, String scopeId)	Generate a string literal load with memory management.
protected List<IRInstr>	AbstractSyntheticGenerator.generateThisIsSetGuard(String aggregateTypeName, ISymbol aggregateType, String unsetLabel, SynthesisScope ctx)	Generate isSet guard for 'this' using SynthesisScope.
protected List<IRInstr>	AbstractSyntheticGenerator.generateThisIsSetGuard(String aggregateTypeName, ISymbol aggregateType, DebugInfo debugInfo, String unsetLabel, String scopeId)	Generate isSet guard check for 'this' with branch to unset return.
protected List<IRInstr>	AbstractSyntheticGenerator.generateUnsetReturnBlockWithLabel(String labelName, String returnTypeName, String returnVarName, DebugInfo debugInfo, String scopeId)	Generate unset return block at a specific label.
protected List<IRInstr>	AbstractSyntheticGenerator.generateUnsetReturnBlockWithLabel(String labelName, String returnTypeName, String returnVarName, SynthesisScope ctx)	Generate unset return block using SynthesisScope.
List<IRInstr>	AbstractSyntheticGenerator.CycleGuardEntry.instructions()	Returns the value of the instructions record component.
List<IRInstr>	AbstractSyntheticGenerator.ScopeSetup.instructions()	Returns the value of the instructions record component.
protected List<IRInstr>	AbstractSyntheticGenerator.runtimeTypeCheck(String differentTypeLabel, DebugInfo debugInfo)	THE run-time-type check itself, the first step of the comparison: nothing when differentTypeLabel is null.
protected List<IRInstr>	AbstractSyntheticGenerator.runUnderCycleGuard(AbstractSyntheticGenerator.CycleGuardEntry guard, String exitMethod, List<IRInstr> checks, String endLabel, String resultLabel, SynthesisScope ctx)	THE tail of a cycle-guarded ?, == or <=>: enter the guard, run checks (whose outcome blocks store into rtn and end at endLabel) as the guarded region, then go on to the operator's result return block.

Method parameters in org.ek9lang.compiler.phase7.synthesis with type arguments of type IRInstr

Modifier and Type	Method	Description
protected List<IRInstr>	AbstractSyntheticGenerator.generateCycleGuardedRegion(String exitMethod, AbstractSyntheticGenerator.CycleGuardEntry entry, List<IRInstr> body, String endLabel, SynthesisScope ctx)	THE guarded region of a cycle-guarded operator whose exit returns nothing (?, ==, <=>): the body runs as the try of a TRY_CATCH_FINALLY with NO catches whose finally is the guard's exit, so the exit runs on every path - including an exception thrown by a field's hand-written operator, which would otherwise leave this object's entry behind and make a later call read as a cycle (Contract 13).
protected List<IRInstr>	AbstractSyntheticGenerator.generatePoisonableCycleGuardedRegion(String exitMethod, AbstractSyntheticGenerator.CycleGuardEntry entry, List<IRInstr> body, String unsetLabel, String keepLabel, SynthesisScope ctx)	THE guarded region of a representation ($, $$): as AbstractSyntheticGenerator.generateCycleGuardedRegion(String, AbstractSyntheticGenerator.CycleGuardEntry, List, String, SynthesisScope), but the exit in the finally also says whether a cycle was met while the body ran.
protected List<IRInstr>	AbstractSyntheticGenerator.runUnderCycleGuard(AbstractSyntheticGenerator.CycleGuardEntry guard, String exitMethod, List<IRInstr> checks, String endLabel, String resultLabel, SynthesisScope ctx)	THE tail of a cycle-guarded ?, == or <=>: enter the guard, run checks (whose outcome blocks store into rtn and end at endLabel) as the guarded region, then go on to the operator's result return block.

Constructor parameters in org.ek9lang.compiler.phase7.synthesis with type arguments of type IRInstr

Modifier	Constructor	Description
protected	CycleGuardEntry(String ownerVar, String otherVar, List<IRInstr> instructions)	Creates an instance of a CycleGuardEntry record class.
protected	ScopeSetup(SynthesisScope ctx, List<IRInstr> instructions)	Creates an instance of a ScopeSetup record class.

Uses of IRInstr in org.ek9lang.compiler.phase7.synthesis.support

Methods in org.ek9lang.compiler.phase7.synthesis.support that return IRInstr

Modifier and Type	Method	Description
IRInstr	SyntheticMethodCallBuilder.buildCall(DebugInfo debugInfo)	The call instruction alone, for a caller that states the result's owner itself.
IRInstr	PrimitiveToEk9Conversion.ofCall(String resultVar, String primitiveVar, String ek9TypeName, String ofParamType, SynthesisScope ctx)	THE ek9Type._of(primitiveVar) static call alone, for a caller that states the result's owner itself.

Methods in org.ek9lang.compiler.phase7.synthesis.support that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	SyntheticMethodCallBuilder.build(DebugInfo debugInfo, String scopeId)	Build the IR instructions for this call using explicit debugInfo and scopeId.
List<IRInstr>	SyntheticMethodCallBuilder.build(SynthesisScope ctx)	Build the IR instructions for this call using a SynthesisScope context.
List<IRInstr>	SyntheticMethodCallBuilder.buildReturning(String returnVariable, DebugInfo debugInfo, String scopeId)	SyntheticMethodCallBuilder.buildReturning(String, SynthesisScope) with explicit debugInfo and scopeId.
List<IRInstr>	SyntheticMethodCallBuilder.buildReturning(String returnVariable, SynthesisScope ctx)	Build the call and hand its result straight to the returning variable: the result is made for rtn and nothing else, so it is moved there (OwnershipStatements.returnFresh(String, String, DebugInfo)) rather than registered with the scope and copied.
List<IRInstr>	SyntheticMethodCallBuilder.buildVoid(DebugInfo debugInfo, String scopeId)	Build the IR instructions for a void method call using explicit debugInfo and scopeId.
List<IRInstr>	SyntheticMethodCallBuilder.buildVoid(SynthesisScope ctx)	Build the IR instructions for a void method call using a SynthesisScope context.
List<IRInstr>	PrimitiveToEk9Conversion.convert(String resultVar, String primitiveVar, String ek9TypeName, String ofParamType, SynthesisScope ctx)	Build the ek9Type._of(primitiveVar) static-call sequence with ARC ownership: the _of factory hands back a fresh object at +1, so the scope owns it (DROP_AT_EXIT) and nothing retains it.
List<IRInstr>	ReturnBlockHelper.generateBooleanReturn(String labelName, boolean value, String returnVarName, DebugInfo debugInfo, String scopeId)	Generate a return block that returns a boolean value (true or false).
List<IRInstr>	ReturnBlockHelper.generateBooleanStore(String labelName, boolean value, String returnVarName, DebugInfo debugInfo, String scopeId, String continueLabel)	Generate a block that sets the return variable to a boolean value and then goes on to continueLabel instead of returning - for a value decided INSIDE a region that must be left by falling through (the cycle guard's try body, whose finally must run: Contract 13).
List<IRInstr>	ReturnBlockHelper.generateIntegerReturn(String labelName, int value, String returnVarName, DebugInfo debugInfo, String scopeId)	Generate a return block that returns an integer literal value.
List<IRInstr>	ReturnBlockHelper.generateIntegerStore(String labelName, int value, String returnVarName, DebugInfo debugInfo, String scopeId, String continueLabel)	Generate a block that sets the return variable to an integer literal and then goes on to continueLabel instead of returning (see ReturnBlockHelper.generateBooleanStore(String, boolean, String, DebugInfo, String, String)).
List<IRInstr>	ReturnBlockHelper.generateUnsetReturn(String labelName, String returnTypeName, ISymbol returnType, String returnVarName, DebugInfo debugInfo, String scopeId)	Generate a return block that returns an unset value of the given type.
List<IRInstr>	ReturnBlockHelper.generateUnsetStore(String labelName, String returnTypeName, ISymbol returnType, String returnVarName, DebugInfo debugInfo, String scopeId, String continueLabel)	Generate a block that sets the return variable to an unset value of the given type and then goes on to continueLabel instead of returning (see ReturnBlockHelper.generateBooleanStore(String, boolean, String, DebugInfo, String, String)).
List<IRInstr>	ReturnBlockHelper.generateValueReturn(String labelName, String returnVarName, DebugInfo debugInfo, String scopeId)	Generate a return block that returns the value already in the return variable.
List<IRInstr>	ReturnBlockHelper.generateVoidReturn(String labelName, DebugInfo debugInfo, String scopeId)	Generate a return block that returns nothing (a void operation): label, scope exit, void return.

Uses of IRInstr in org.ek9lang.compiler.phase9

Classes in org.ek9lang.compiler.phase9 that implement interfaces with type arguments of type IRInstr

Modifier and Type	Class	Description
final class	AfterThreadsSafePoints	The SAFE_POINT after_threads of one instruction list (EK9_NATIVE_CYCLE_COLLECTOR_DESIGN.md §13.11, T10): after the exit of the innermost scope in this list that holds a call which starts runtime threads and finishes only once they have all stopped (StartsAndStopsRuntimeThreads) - an async pipeline's statement scope, the scope of a server's accept or serve.
(package private) final class	ArmResults	THE value each list of a chain hands to the chain's result: an arm's body result, the default's result - keyed by the list's identity (two equal lists are two places).
final class	BackEdgePoints	THE back-edge placement of IR_OPTIMISATION: a point instruction at the end of every loop body of an operation - the back edge, reached once per iteration after the body's own scope has dropped its values - unless one of the same opcode is already last.
final class	BeforeThreadsSafePoints	The SAFE_POINT before_threads of one instruction list (EK9_NATIVE_CYCLE_COLLECTOR_DESIGN.md §13.11, S0b): ahead of each call that starts runtime threads (StartsRuntimeThreads).
final class	HandsValuesToRuntimeThreads	THE calls that hand values to runtime threads for the life of a server or of the program (EK9_NATIVE_CYCLE_COLLECTOR_DESIGN.md §13.11, S2): one handler serves every connection, the ready handler runs on its own thread while the caller serves, and the signal dispatcher keeps its handler until the program ends.
(package private) final class	LoopActivationOwnership	The two ownership rules that need to know which instruction lists run once per loop ITERATION (an activation), not just which scope ids exist - EK9_IR_OWNERSHIP_MODEL.md §12, stage 0, stated in today's opcodes: A value is owned by the activation that makes it (model V-F, the A11 rule).
(package private) final class	MovedOutOf	THE variables an operation body's ownership form moves out of (the value of a consuming SLOT_ASSIGN).
(package private) final class	OperationFindings	THE findings of a per-body ownership check over every operation of a construct, each as "operation: problem", in operation order; an operation with no body has none.
(package private) final class	ReferenceEdges	Every reference an instruction stores INTO an object - the edges a published object could gain - classified by OPCODE, for V-P's audit (PublishVerifier, review 2026-11-02 M4).
(package private) final class	ShortInstructionText	THE short text of an instruction named in an ownership finding: a composite by its opcode, anything else by its IR text without the debug comment and the purity annotation, cut at 110 characters - so a finding shows the instruction's shape without the operation's IR.
final class	StartsAndStopsRuntimeThreads	THE calls that start runtime threads and finish only once every one of them has stopped (EK9_NATIVE_CYCLE_COLLECTOR_DESIGN.md §13.11, T10): a server's accept, acceptUntilComplete, serve and serveUntilComplete return after shutting down the scheduler they started, and an async pipeline's Ek9Async.create() begins the statement whose close() drains its workers and does the same.
final class	StartsRuntimeThreads	THE calls that start runtime threads (EK9_NATIVE_CYCLE_COLLECTOR_DESIGN.md §13.11, S0b): every call StartsAndStopsRuntimeThreads names - an async pipeline's Ek9Async.create(), a server's accept and serve, each of which starts the carrier scheduler - and Signals.register, which starts the signal dispatcher that never stops.

Methods in org.ek9lang.compiler.phase9 that return types with arguments of type IRInstr

Modifier and Type	Method	Description
List<IRInstr>	AfterThreadsSafePoints.apply(List<IRInstr> instructions)
Map<List<IRInstr>, String>	ArmResults.apply(CompositeInstr composite)
List<IRInstr>	BeforeThreadsSafePoints.apply(List<IRInstr> instructions)
(package private) List<IRInstr>	OwnershipLowering.lowerList(List<IRInstr> instructions)	Lower an instruction list and every list nested in it, as one operation body.

Methods in org.ek9lang.compiler.phase9 with parameters of type IRInstr

Modifier and Type	Method	Description
List<String>	HandsValuesToRuntimeThreads.apply(IRInstr instruction)
List<ReferenceEdges.Edge>	ReferenceEdges.apply(IRInstr instruction)
String	ShortInstructionText.apply(IRInstr instruction)
(package private) void	ActivationScopes.instruction(IRInstr instruction)	Track one instruction (only SCOPE_ENTER matters).
(package private) List<PublishInstr>	PublishedValues.of(IRInstr instruction, PublishedValues.Where where)	The PUBLISHes that must come immediately before this instruction, in order; empty for most.
boolean	StartsAndStopsRuntimeThreads.test(IRInstr instruction)
boolean	StartsRuntimeThreads.test(IRInstr instruction)

Method parameters in org.ek9lang.compiler.phase9 with type arguments of type IRInstr

Modifier and Type	Method	Description
void	BackEdgePoints.accept(OperationInstr operation, Supplier<IRInstr> point)
List<IRInstr>	AfterThreadsSafePoints.apply(List<IRInstr> instructions)
List<IRInstr>	BeforeThreadsSafePoints.apply(List<IRInstr> instructions)
List<String>	LoopActivationOwnership.apply(List<IRInstr> body, Set<String> returnVariables)	The problems in one operation body, in walk order; empty when it keeps both rules.
Set<String>	MovedOutOf.apply(List<IRInstr> body)
List<String>	OperationFindings.apply(IRConstruct construct, Function<List<IRInstr>, List<String>> bodyCheck)
(package private) List<String>	OwnershipBorrowVerifier.check(List<IRInstr> body)	The V-I findings of one operation body.
(package private) List<String>	OwnershipPathVerifier.check(List<IRInstr> body)	The per-path findings of one operation body.
(package private) List<String>	OwnershipVerifier.check(List<IRInstr> body)	The problems in one operation body; empty when it keeps every local rule.
(package private) List<IRInstr>	OwnershipLowering.lowerList(List<IRInstr> instructions)	Lower an instruction list and every list nested in it, as one operation body.