Uses of Record Class
org.ek9lang.compiler.ir.support.DebugInfo

Packages that use DebugInfo

Package	Description
org.ek9lang.compiler.backend.jvm	JVM Bytecode Generation - Transforms EK9 IR into JVM bytecode.
org.ek9lang.compiler.backend.jvm.support	JVM Backend Support Utilities - Extracted utilities for bytecode generation.
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.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.

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

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

Modifier and Type	Method	Description
void	SmapGenerator.addMapping(DebugInfo debugInfo, int outputLineNumber)	Add debug information from an IR instruction to the SMAP.
protected void	AbstractAsmGenerator.generateDebugInfo(DebugInfo debugInfo)	Generate debug line number from EK9 debug info if available.

Uses of DebugInfo in org.ek9lang.compiler.backend.jvm.support

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

Modifier and Type	Method	Description
void	DebugInfoGenerator.generateDebugInfo(org.objectweb.asm.MethodVisitor mv, DebugInfo debugInfo)	Generate debug line number from EK9 debug info if available.

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

Methods in org.ek9lang.compiler.ir.data that return DebugInfo

Modifier and Type	Method	Description
DebugInfo	AspectProxyDetails.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	ControlFlowChainDetails.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	DispatchTableDetails.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	EnumIteratorImplDetails.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	LogicalDetails.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	ServiceRegistrationDetails.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	ServiceRouteDetails.debugInfo()	Returns the value of the debugInfo record component.

Methods in org.ek9lang.compiler.ir.data with parameters of type DebugInfo

Modifier and Type	Method	Description
static ControlFlowChainDetails	ControlFlowChainDetails.createComparisonCoalescing(String result, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId, String chainType)	Create details for comparison coalescing operators (<?, >?).
static ControlFlowChainDetails	ControlFlowChainDetails.createDoWhileExpression(String result, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Create details for a do-while expression (result <- do { body } while condition).
static ControlFlowChainDetails	ControlFlowChainDetails.createDoWhileLoopUnified(GuardVariableDetails guardDetails, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Unified factory for do-while loops - automatically selects expression or statement form.
static ControlFlowChainDetails	ControlFlowChainDetails.createDoWhileLoopWithGuards(GuardVariableDetails guardDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Create details for a do-while loop with guard variables (statement form).
static ControlFlowChainDetails	ControlFlowChainDetails.createElvisCoalescing(String result, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId)	Create details for an Elvis Coalescing operator (:?).
static ControlFlowChainDetails	ControlFlowChainDetails.createForInExpression(String result, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Create details for a for-in expression (result <- for item in collection).
static ControlFlowChainDetails	ControlFlowChainDetails.createForRangeExpression(String result, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Create details for a for-range expression (result <- for i in start ..< end).
static ControlFlowChainDetails	ControlFlowChainDetails.createIfElse(String result, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId)	Create details for an if/else statement.
static ControlFlowChainDetails	ControlFlowChainDetails.createIfElseWithGuards(String result, GuardVariableDetails guardDetails, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId)	Create details for an if/else statement with guard variables.
static ControlFlowChainDetails	ControlFlowChainDetails.createQuestionOperator(String result, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId)	Create details for a Question operator (?).
static ControlFlowChainDetails	ControlFlowChainDetails.createSwitchExpression(String result, EvaluationVariableDetails evaluationDetails, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId)	Create details for a switch expression (result <- switch expr).
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 ControlFlowChainDetails	ControlFlowChainDetails.createTernaryOperator(String result, List<ConditionCaseDetails> conditionChain, List<IRInstr> defaultBodyEvaluation, String defaultResult, DebugInfo debugInfo, String scopeId)	Create details for a Ternary operator (condition <- thenValue : elseValue).
static ControlFlowChainDetails	ControlFlowChainDetails.createTryCatchExpression(String result, ReturnVariableDetails returnDetails, TryBlockDetails tryBlockDetails, List<ConditionCaseDetails> catchHandlers, List<IRInstr> finallyBlockEvaluation, DebugInfo debugInfo, String scopeId)	Create details for a try-catch expression (result <- try { expr } catch { handler }).
static ControlFlowChainDetails	ControlFlowChainDetails.createTryCatchFinally(String result, GuardVariableDetails guardDetails, ReturnVariableDetails returnDetails, TryBlockDetails tryBlockDetails, List<ConditionCaseDetails> catchHandlers, List<IRInstr> finallyBlockEvaluation, DebugInfo debugInfo, String scopeId)	Create details for a try/catch/finally construct.
static ControlFlowChainDetails	ControlFlowChainDetails.createWhileExpression(String result, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Create details for a while expression (result <- while condition).
static ControlFlowChainDetails	ControlFlowChainDetails.createWhileLoop(List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Create details for a while loop (statement form).
static ControlFlowChainDetails	ControlFlowChainDetails.createWhileLoopUnified(GuardVariableDetails guardDetails, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Unified factory for while loops - automatically selects expression or statement form.
static ControlFlowChainDetails	ControlFlowChainDetails.createWhileLoopWithGuards(GuardVariableDetails guardDetails, List<ConditionCaseDetails> conditionChain, DebugInfo debugInfo, String scopeId)	Create details for a while loop with guard variables (statement form).
static EnumIteratorImplDetails	EnumIteratorImplDetails.forBaseEnum(String enumTypeName, String superTypeName, List<String> enumValues, String resultVariable, DebugInfo debugInfo)	Details for a base enumeration (each value is a fresh enumTypeName instance, ordinal = index).
static EnumIteratorImplDetails	EnumIteratorImplDetails.forConstrainedEnum(String enumTypeName, String superTypeName, List<String> enumValues, String baseEnumTypeName, List<Integer> baseOrdinals, String resultVariable, DebugInfo debugInfo)	Details for a constrained enumeration: yield the enumValues SUBSET (with their baseOrdinals) of baseEnumTypeName, each WRAPPED in enumTypeName via its (baseEnum) constructor.

Constructors in org.ek9lang.compiler.ir.data with parameters of type DebugInfo

Modifier	Constructor	Description
	AspectProxyDetails(String baseTypeFqn, String delegateTypeFqn, String delegateTemp, List<String> aspectTemps, List<String> aspectTypeFqns, List<AspectProxyDetails.ProxyMethodInfo> proxyMethods, String resultVariable, IToken sourceToken, DebugInfo debugInfo, boolean forwardsClose, boolean implementsCloseable)	Create aspect proxy details with validation.
	ControlFlowChainDetails(String result, String chainType, GuardVariableDetails guardDetails, EvaluationVariableDetails evaluationDetails, ReturnVariableDetails returnDetails, List<ConditionCaseDetails> conditionChain, DefaultCaseDetails defaultDetails, TryBlockDetails tryBlockDetails, List<IRInstr> finallyBlockEvaluation, DebugInfo debugInfo, String scopeId)	Creates an instance of a ControlFlowChainDetails record class.
	DispatchTableDetails(String selfTypeFqn, String methodName, String returnTypeFqn, List<String> paramNames, List<String> baseTypeFqns, List<DispatchTableDetails.DispatchEntry> entries, DebugInfo debugInfo)	Create dispatch table details with validation.
	EnumIteratorImplDetails(String enumTypeName, String superTypeName, List<String> enumValues, String baseEnumTypeName, List<Integer> baseOrdinals, String resultVariable, DebugInfo debugInfo)	Canonical constructor with validation and defensive copies.
	LogicalDetails(String result, OperandEvaluation leftEvaluation, ConditionalEvaluation conditionalEvaluation, OperandEvaluation rightEvaluation, OperandEvaluation resultEvaluation, DebugInfo debugInfo, String scopeId)	Creates an instance of a LogicalDetails record class.
	ServiceRegistrationDetails(String serviceFqn, ServiceRouteDetails routeDetails, DebugInfo debugInfo)	Create service registration details with validation.
	ServiceRouteDetails(String serviceFqn, String baseUri, List<ServiceRouteDetails.RouteEntry> routes, DebugInfo debugInfo)	Create service route details with validation.

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

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

Modifier and Type	Method	Description
DebugInfo	ForRangePolymorphicInstr.EndCheck.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	Field.getDebugInfo()	Get debug information for this field.
DebugInfo	OperationInstr.getDebugInfo()

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

Modifier and Type	Method	Description
Optional<DebugInfo>	IRInstr.getDebugInfo()	Get debug information for this instruction.

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

Modifier and Type	Method	Description
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 BranchInstr	BranchInstr.assertValue(String condition, String message, DebugInfo debugInfo)	Create assert instruction with message and debug info: ASSERT condition, message.
static BranchInstr	BranchInstr.assertValue(String condition, DebugInfo debugInfo)	Create assert instruction with debug info: ASSERT condition.
static InputClassProbeInstr	InputClassProbeInstr.assertWindowEnter(DebugInfo debugInfo)	Open the §5.3 assert window — emitted immediately before an assert condition is evaluated.
static InputClassProbeInstr	InputClassProbeInstr.assertWindowExit(DebugInfo debugInfo)	Close the §5.3 assert window opened by InputClassProbeInstr.assertWindowEnter(DebugInfo).
static BranchInstr	BranchInstr.branch(String targetLabel, DebugInfo debugInfo)	Create unconditional branch: BRANCH target_label.
static BranchInstr	BranchInstr.branchIfFalse(String condition, String targetLabel, DebugInfo debugInfo)	Create conditional branch if false: BRANCH_FALSE condition, target_label.
static BranchInstr	BranchInstr.branchIfTrue(String condition, String targetLabel, DebugInfo debugInfo)	Create conditional branch if true: BRANCH_TRUE condition, target_label.
static CallInstr	CallInstr.call(String result, DebugInfo debugInfo, CallDetails callDetails)	Create method call with complete type information from resolved symbols: CALL result = object.method(args...)
static CallInstr	CallInstr.callStatic(String result, DebugInfo debugInfo, CallDetails callDetails)	Create static method call with complete type information: CALL_STATIC result = Type.method(args...)
static CastInstr	CastInstr.cast(String result, String source, String targetType, DebugInfo debugInfo)	Create instruction to cast source to target type and store in result.
static CallInstr	CallInstr.constructor(String result, DebugInfo debugInfo, CallDetails callDetails)	Create constructor call with complete type information: CALL result = Type.<init>(args...)
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 OwnershipInstr	OwnershipInstr.drop(String value, DebugInfo debugInfo)	DROP value: the end of an OWNED value on this path (lowered: RELEASE).
static OwnershipInstr	OwnershipInstr.dropAtExit(String value, String scopeId, DebugInfo debugInfo)	DROP_AT_EXIT value, scope: the end of an OWNED value at every exit of the scope's current activation (lowered: SCOPE_REGISTER).
static ScopeInstr	ScopeInstr.enter(String scopeId, DebugInfo debugInfo)	Create scope enter instruction with debug info: SCOPE_ENTER scope_id.
static ProfilingEntryInstr	ProfilingEntryInstr.entry(long functionId, String functionName, DebugInfo debugInfo)	Create a profiling entry instruction.
static ProfilingExitInstr	ProfilingExitInstr.exit(long functionId, DebugInfo debugInfo)	Create a profiling exit instruction.
static ScopeInstr	ScopeInstr.exit(String scopeId, DebugInfo debugInfo)	Create scope exit instruction with debug info: SCOPE_EXIT scope_id.
static OwnershipInstr	OwnershipInstr.fieldAssign(String objectVar, String fieldName, String ownerType, String fieldType, String value, int fieldIndex, OwnershipInstr.AssignMode mode, boolean init, DebugInfo debugInfo)	FIELD_ASSIGN object, field, ownerType, fieldType, value, index [consume|copy] [init]: drop the field's value and store the new one.
static CoverageFinalizeInstr	CoverageFinalizeInstr.finalize(String outputPath, DebugInfo debugInfo)	Create a coverage finalize instruction with explicit output path.
static CoverageFinalizeInstr	CoverageFinalizeInstr.finalize(DebugInfo debugInfo)	Create a coverage finalize instruction with default output path.
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 MemoryInstr	MemoryInstr.functionInstance(String result, String functionType, DebugInfo debugInfo)	Create FUNCTION_INSTANCE instruction with debug info: FUNCTION_INSTANCE result = FunctionType.
static CastInstr	CastInstr.instanceOf(String result, String source, String targetType, InstanceOfKind kind, DebugInfo debugInfo)	Create instruction to check if source is instance of target type with explicit kind.
static StringInterpolationInstr	StringInterpolationInstr.interpolate(String result, List<IRInstr> setupInstructions, List<StringInterpolationPart> parts, String scopeId, DebugInfo debugInfo)	Create a string interpolation instruction.
static MemoryInstr	MemoryInstr.isNull(String result, String operand, DebugInfo debugInfo)	Create IS_NULL instruction with debug info: IS_NULL result = operand.
static LabelInstr	LabelInstr.label(String labelName, DebugInfo debugInfo)	Create label instruction with debug info: LABEL label_name.
static MemoryInstr	MemoryInstr.load(String destination, String sourceLocation, DebugInfo debugInfo)	Create LOAD instruction with debug info: LOAD dest = source_location.
static MemoryInstr	MemoryInstr.loadConstant(String result, String constantName, String moduleName, String typeName, DebugInfo debugInfo)	Create LOAD_CONSTANT instruction: load from module constant storage.
static MemoryInstr	MemoryInstr.loadField(String destination, String objectVar, String fieldName, String ownerType, String fieldType, int fieldIndex, DebugInfo debugInfo)	Create LOAD_FIELD instruction: load field value from object.
static MemoryInstr	MemoryInstr.loadField(String destination, String objectVar, String fieldName, String ownerType, String fieldType, DebugInfo debugInfo)	Create LOAD_FIELD instruction without explicit field index (defaults to context lookup).
static MemoryInstr	MemoryInstr.loadStaticField(String result, String fieldName, String ownerType, String fieldType, DebugInfo debugInfo)	Create LOAD_STATIC_FIELD instruction: load static field from class.
static LiteralInstr	LiteralInstr.objectFromLiteral(String result, String literalValue, String literalType, DebugInfo debugInfo)	Create instruction to load a literal value as an EK9 object.
static CallInstr	CallInstr.operator(String result, DebugInfo debugInfo, CallDetails callDetails)	Create EK9 operator call with complete type information: CALL result = object._operatorMethod(args...) Common operators: _add, _sub, _eq, _lt, _addAss, _isSet, etc.
static OwnershipInstr	OwnershipInstr.own(String value, DebugInfo debugInfo)	OWN value: a new OWNED reference to the value's object (lowered: RETAIN).
static PrimitiveLiteralInstr	LiteralInstr.primitiveFromLiteral(String result, String literalValue, String primitiveType, DebugInfo debugInfo)	Create instruction to load a literal value as a primitive (int, boolean, java.lang.String).
static CoverageProbeInstr	CoverageProbeInstr.probe(CoverageProbeDetails probeDetails, DebugInfo debugInfo)	Create a coverage probe instruction.
static InputClassProbeInstr	InputClassProbeInstr.probe(String constructFullyQualifiedName, String constructName, List<InputClassProbeArg> args, DebugInfo debugInfo)	Create an input-class probe instruction.
static MemoryInstr	MemoryInstr.reference(String variableName, String typeInfo, DebugInfo debugInfo)	Create REFERENCE instruction with debug info: REFERENCE variable_name, type_info.
static CoverageRegisterInstr	CoverageRegisterInstr.register(CoverageModuleDetails moduleDetails, DebugInfo debugInfo)	Create a coverage register instruction.
static ScopeInstr	ScopeInstr.register(String object, String scopeId, DebugInfo debugInfo)
static MemoryInstr	MemoryInstr.release(String object, DebugInfo debugInfo)	Create RELEASE instruction with debug info: RELEASE object, decrement ARC.
static MemoryInstr	MemoryInstr.releaseField(String objectVar, String fieldName, String ownerType, String fieldType, int fieldIndex, DebugInfo debugInfo)	Create RELEASE_FIELD instruction: release the object reference currently held in a field before a STORE_FIELD overwrites it.
static MemoryInstr	MemoryInstr.retain(String object, DebugInfo debugInfo)	Create RETAIN instruction with debug info: RETAIN object, i.e.
static BranchInstr	BranchInstr.returnValue(String value, DebugInfo debugInfo)	Create return with value and debug info: RETURN value.
static BranchInstr	BranchInstr.returnVoid(DebugInfo debugInfo)	Create return with no value and debug info: RETURN.
static SanitizeInstr	SanitizeInstr.sanitize(String destination, String source, DebugInfo debugInfo)	Create instruction to sanitize a string and store in destination.
static OwnershipInstr	OwnershipInstr.slotAssign(String slot, String value, OwnershipInstr.AssignMode mode, boolean init, DebugInfo debugInfo)	SLOT_ASSIGN slot, value [consume|copy] [init]: drop the slot's value (unless init - a fact that it is empty) and store the new one.
static OwnershipInstr	OwnershipInstr.slotDeclare(String slot, String type, String owner, boolean typed, DebugInfo debugInfo)	SLOT_DECLARE slot, type, owner [typed]: an empty slot owned by a scope, or by OwnershipInstr.CALLER.
static Field	Field.staticField(ISymbol symbol, String name, String typeName, DebugInfo debugInfo)	Factory method for creating a static field (e.g., enum constants).
static OwnershipInstr	OwnershipInstr.staticFieldAssign(String fieldName, String ownerType, String fieldType, String value, OwnershipInstr.AssignMode mode, boolean init, DebugInfo debugInfo)	STATIC_FIELD_ASSIGN field, ownerType, fieldType, value [consume|copy] [init]: store into a static field, described exactly as STORE_STATIC_FIELD describes it.
static OwnershipInstr	OwnershipInstr.staticFieldTake(String result, String fieldName, String ownerType, String fieldType, DebugInfo debugInfo)	result = STATIC_FIELD_TAKE field, ownerType, fieldType: the static's value, OWNED - its count moves to the result.
static MemoryInstr	MemoryInstr.store(String destinationLocation, String source, DebugInfo debugInfo)	Create STORE instruction with debug info: STORE dest_location = source.
static MemoryInstr	MemoryInstr.storeField(String objectVar, String fieldName, String ownerType, String fieldType, String value, int fieldIndex, DebugInfo debugInfo)	Create STORE_FIELD instruction: store value into object field.
static MemoryInstr	MemoryInstr.storeField(String objectVar, String fieldName, String ownerType, String fieldType, String value, DebugInfo debugInfo)	Create STORE_FIELD instruction without explicit field index (defaults to context lookup).
static MemoryInstr	MemoryInstr.storeStaticField(String fieldName, String ownerType, String fieldType, String value, DebugInfo debugInfo)	Create STORE_STATIC_FIELD instruction: store value into static field.
static ThrowInstr	ThrowInstr.throwException(String exceptionVariable, String exceptionType, DebugInfo debugInfo)	Create throw instruction with exception object variable, type, and debug info.
static MemoryInstr	MemoryInstr.typedReference(String variableName, String typeInfo, DebugInfo debugInfo)	Create TYPED_REFERENCE instruction: like REFERENCE but emits CHECKCAST after ACONST_NULL so ASM records the variable's type (not "Null") for correct stackmap frame computation.

Constructors in org.ek9lang.compiler.ir.instructions with parameters of type DebugInfo

Modifier	Constructor	Description
	EndCheck(String primitive, DebugInfo debugInfo)	Creates an instance of a EndCheck record class.
	Field(ISymbol symbol, String name, String typeName, DebugInfo debugInfo)	Create a new instance Field IR node.
	IRInstr(IROpcode opcode, String result, DebugInfo debugInfo)	Create instruction with result and debug information.
	OperationInstr(ISymbol symbol, DebugInfo debugInfo)
(package private)	PrimitiveLiteralInstr(String result, String literalValue, String primitiveType, DebugInfo debugInfo)
	ProgramEntryPointInstr(List<ProgramDetails> availablePrograms, DebugInfo debugInfo)	Create program entry point instruction with complete program metadata.

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

Methods in org.ek9lang.compiler.ir.support that return DebugInfo

Modifier and Type	Method	Description
static DebugInfo	DebugInfo.from(CompilableSource compilableSource, IToken token)	Create DebugInfo from an ISymbol's source token.
static DebugInfo	DebugInfo.of(String sourceFile, int lineNumber, int columnNumber)	Create DebugInfo with just file and position (no original text).

Uses of DebugInfo in org.ek9lang.compiler.phase7

Methods in org.ek9lang.compiler.phase7 that return DebugInfo

Modifier and Type	Method	Description
(package private) DebugInfo	Scenario2WrapperHelper.createDebugInfo()

Methods in org.ek9lang.compiler.phase7 with parameters of type DebugInfo

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) 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.
(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 DebugInfo in org.ek9lang.compiler.phase7.generation

Classes in org.ek9lang.compiler.phase7.generation that implement interfaces with type arguments of type DebugInfo

Modifier and Type	Class	Description
(package private) final class	DebugInfoCreator	Creates the debug information for the symbol provided.

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

Modifier and Type	Method	Description
DebugInfo	DebugInfoCreator.apply(IToken token)
DebugInfo	IRGenerationContext.createDebugInfo(org.antlr.v4.runtime.Token token)	Create debug info from an ANTLR token.
DebugInfo	IRGenerationContext.createDebugInfo(org.antlr.v4.runtime.tree.ParseTree ctx)	Create debug info from a parse context.
DebugInfo	IRGenerationContext.createDebugInfo(Ek9Token token)	Create debug info from a token.
DebugInfo	IRGenerationContext.createDebugInfo(IToken token)	Create debug info from an EK9 IToken (null-safe: a null token has no location).
DebugInfo	IRInstructionBuilder.createDebugInfo(org.antlr.v4.runtime.Token token)	Create debug info from an ANTLR token.
DebugInfo	IRInstructionBuilder.createDebugInfo(org.antlr.v4.runtime.tree.ParseTree ctx)
DebugInfo	IRInstructionBuilder.createDebugInfo(Ek9Token token)	Create debug info from a token.
DebugInfo	IRInstructionBuilder.createDebugInfo(IToken token)	Create debug info from an EK9 IToken.
DebugInfo	IRGenerationContext.createDebugInfoAlways(org.antlr.v4.runtime.Token token)	Create debug info ALWAYS, regardless of debug mode flag.
DebugInfo	IRGenerationContext.createDebugInfoAlways(org.antlr.v4.runtime.tree.ParseTree ctx)	Create debug info ALWAYS from a parse context, regardless of debug mode flag.
DebugInfo	IRGenerationContext.createDebugInfoAlways(IToken token)	Create debug info ALWAYS from an EK9 token, regardless of debug mode flag.
DebugInfo	IRStackFrame.debugInfo()	Returns the value of the debugInfo record component.

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

Modifier and Type	Method	Description
Optional<DebugInfo>	IRGenerationContext.currentDebugInfo()	Get current debug info from the stack.
Optional<DebugInfo>	IRGenerationStack.currentDebugInfo()	Get current debug info from the top frame.

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

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).
static IRStackFrame	IRStackFrame.basic(String scopeId, DebugInfo debugInfo, IRFrameType frameType)	Create a basic frame with just scope and debug info.
void	IRInstructionBuilder.callInstanceInit(ISymbol constructType, DebugInfo debugInfo)	Add IRInstructionBuilder.instanceInitCall(ISymbol, DebugInfo).
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.
void	IRGenerationContext.enterMethodScope(String scopeId, DebugInfo debugInfo, IRFrameType frameType)	Enter a method/function scope with fresh IRContext for counter isolation.
void	IRGenerationContext.enterScope(String scopeId, DebugInfo debugInfo, IRFrameType frameType)	Enter a new IR scope context.
void	IRGenerationContext.inMethodFrame(String frameName, DebugInfo debugInfo, Runnable work)	THE method frame (IR tidy W3.4, INFRA-8): a fresh IRContext - its own temp, label and scope counters - for the work, then popped.
void	IRInstructionBuilder.inNewScope(DebugInfo debugInfo, Consumer<String> body)	THE scoped body for code built through this builder (INFRA-1): a fresh scope id, pushed on the stack, SCOPE_ENTER, whatever body adds (it is handed the scope id), SCOPE_EXIT, popped.
CallInstr	IRInstructionBuilder.instanceInitCall(ISymbol constructType, DebugInfo debugInfo)	THE call of a construct's own _i_init - its field initialisers - from a constructor, synthetic or written (IR tidy W3.4, OPS-2/MONO-14); use this, never a hand-built CallDetails.
BasicBlockInstr	IRGenerationContext.methodBody(String frameName, DebugInfo debugInfo, Consumer<IRInstructionBuilder> body)	THE method body (IR tidy W3.4, INFRA-8): in a method frame (IRGenerationContext.inMethodFrame(String, DebugInfo, Runnable)), one builder, the body, then the entry block labelled on the frame's own counter - the operation's body.
void	IRInstructionBuilder.returnValue(String variableName, DebugInfo debugInfo)
CallInstr	IRInstructionBuilder.superConstructorCall(ISymbol superType, DebugInfo debugInfo)	THE implicit super-constructor call (super.<init>()) of a constructor, synthetic or written (IR tidy W3.4, OPS-2/MONO-14) - use this, never a hand-built CallDetails.
static IRStackFrame	IRStackFrame.withContext(String scopeId, DebugInfo debugInfo, IRFrameType frameType, Object contextData)	Create a frame with additional context data.

Constructors in org.ek9lang.compiler.phase7.generation with parameters of type DebugInfo

Modifier	Constructor	Description
	IRStackFrame(String scopeId, DebugInfo debugInfo, IRFrameType frameType, Object contextData)	Creates an instance of a IRStackFrame record class.

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

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

Modifier and Type	Method	Description
DebugInfo	OperationBodyPlan.bodyScopeDebugInfo()	Returns the value of the bodyScopeDebugInfo record component.
DebugInfo	ReturningParamProcessor.createDebugInfo(EK9Parser.ReturningParamContext ctx)	Create debug info from the returningParam context.
DebugInfo	BufferedStageParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	ConditionStatementPrelude.Evaluated.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	GuardedScopeOrchestrator.OrchestratorContext.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	ResourceCloser.Closing.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	StageWrapParams.debugInfo()	Returns the value of the debugInfo record component.

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

Modifier and Type	Method	Description
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.
(package private) void	StreamEmissionEngine.applyAsyncBufferSortEmit(String asyncExecutorVar, ISymbol asyncProducesType, List<EK9Parser.StreamPartContext> preSortStages, EK9Parser.StreamPartContext sortStage, List<EK9Parser.StreamPartContext> postSortStages, TerminalSetup terminalSetup, org.antlr.v4.runtime.tree.ParseTree probeSite, DebugInfo debugInfo, List<IRInstr> instructions)	Async-specific entry to StreamEmissionEngine.bufferSortEmit(HelperSource, ISymbol, List, EK9Parser.StreamPartContext, List, TerminalSetup, ParseTree, DebugInfo, List): drains the async executor (hasNext/next); its pipeline's finally region closes it.
(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).
(package private) SortSetup	StreamEmissionEngine.applySortToCollection(List<EK9Parser.StreamPartContext> stages, IteratorSetup iteratorSetup, ISymbol elementType, IAggregateSymbol collectionType, org.antlr.v4.runtime.tree.ParseTree probeSite, DebugInfo debugInfo, List<IRInstr> instructions)
(package private) void	StreamEmissionEngine.applyWindowedAsyncToCollection(List<EK9Parser.StreamPartContext> stages, int asyncIndex, List<EK9Parser.StreamPartContext> preAsyncStages, List<StageState> preAsyncStageStates, IteratorSetup iteratorSetup, ISymbol elementType, ISymbol asyncProducesType, String asyncExecutorVar, TerminalSetup terminalSetup, org.antlr.v4.runtime.tree.ParseTree probeSite, DebugInfo debugInfo, List<IRInstr> instructions, List<StageState> postAsyncStates)	Step C — the interleaved WINDOWED async driver for an unbounded source (the telemetry case cat udp | async | filter | head N | collect).
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)).
(package private) void	StreamEmissionEngine.bufferSortEmit(HelperSource source, ISymbol bucketType, List<EK9Parser.StreamPartContext> preSortStages, EK9Parser.StreamPartContext sortStage, List<EK9Parser.StreamPartContext> postSortStages, TerminalSetup terminalSetup, org.antlr.v4.runtime.tree.ParseTree probeSite, DebugInfo debugInfo, List<IRInstr> instructions)
protected AbstractAssertExprGenerator.AssertBodyResult	AbstractAssertExprGenerator.buildAssertionBody(EK9Parser.ExpressionContext exprCtx, DebugInfo debugInfo)	Build the assertion body with proper scope management.
(package private) StageWrapResult	StreamEmissionEngine.buildAsyncSubmitAction(String submitItemVar, ISymbol elementType, String asyncExecutorVar, String inFlightVar, String oneVar, ISymbol integerType, List<EK9Parser.StreamPartContext> preAsyncStages, List<StageState> preAsyncStageStates, org.ek9lang.compiler.phase7.generator.StreamEmissionEngine.AsyncCap cap, DebugInfo debugInfo)	The per-item SUBMIT action shared by the windowed prime loop and the drain refill: executor.submit(item); inFlight++, wrapped in the pre-ASYNC stages (filter/map/etc.).
(package private) ConditionAndPostLoop	StreamPipelineMachinery.buildStreamLoop(IteratorSetup iteratorSetup, List<StageState.Counter> demandBounds, String itemVar, ISymbol itemType, boolean rawIterator, org.antlr.v4.runtime.tree.ParseTree probeSite, StreamLoopSink sink, DebugInfo debugInfo)	The unified iterator-driven stream while-loop skeleton: condition scope (hasNext(), with the demand bounds - the segment's heads, or the async window - folded in ahead of it by StreamDemand) + body scope (bind iterator.next() then the StreamLoopSink body-tail) + the ConditionAndPostLoop the caller emits with StreamPipelineMachinery.emitStreamLoop(ConditionAndPostLoop, String, DebugInfo, List).
(package private) ConditionAndPostLoop	StreamPipelineMachinery.buildUnprobedStreamLoop(IteratorSetup iteratorSetup, List<StageState.Counter> demandBounds, String itemVar, ISymbol itemType, boolean rawIterator, StreamLoopSink sink, DebugInfo debugInfo)	StreamPipelineMachinery.buildStreamLoop(IteratorSetup, List, String, ISymbol, boolean, ParseTree, StreamLoopSink, DebugInfo) with NO loop-body coverage probe - the emission of a sorted bucket buffer (StreamEmissionEngine.bufferSortEmit), which has never carried one.
(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.
void	ApplicationClose.closeOwned(IRInstructionBuilder builder, String taken, RegistrationData registration, ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	The close of one registered component that has been taken out of the registry into taken, inside the registration's OWN scope (the caller's IRInstructionBuilder.inNewScope(DebugInfo, Consumer)): that scope owns the component across the close and drops it at its exit, so it is released whether the close returns, records a failure or the region is left by a Panic (V-A: never live and unowned across a call).
(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).
(package private) FreshBooleanOperand	StreamDemand.continueCondition(List<StageState.Counter> heads, String scopeId, DebugInfo debugInfo)	The demand condition of a loop whose own continuation is not a hasNext() - a for range, whose range test the back end evaluates itself.
(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) void	StreamEmissionEngine.continueOverIterator(List<EK9Parser.StreamPartContext> stages, IteratorSetup sourceIter, ISymbol sourceElementType, TerminalSetup terminalSetup, org.antlr.v4.runtime.tree.ParseTree probeSite, DebugInfo debugInfo, List<IRInstr> instructions, boolean sourceUnbounded)	THE pipeline driver over a terminal that is already resolved - the buffers' own re-entry: see the overload below.
protected FreshBooleanOperand	AbstractStreamStageGenerator.counterBelowLimit(StageState.Counter bound, DebugInfo debugInfo)	THE counter._lt(limit) and its primitive: the comparison every bound (a head/skip gate and each demand bound folded by StreamDemand) is built from - use this, do not hand-roll a fourth.
protected VariableDetails	AbstractGenerator.createTempVariable(DebugInfo debugInfo)	Create a temporary variable with associated debug info.
IRInstr	ApplicationClose.declare(ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)
(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.
IRInstr	ResourceCloser.declareFirstFailure(ResourceCloser.FirstFailure firstFailure, DebugInfo debugInfo)	SLOT_DECLARE firstFailure, org.ek9.lang::Exception, owner - null until a failure is recorded.
(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) DrainCondition	StreamPipelineMachinery.drainCondition(HelperSource source, List<StageState.Counter> heads, DebugInfo debugInfo)	THE drain-loop condition: source.hasNext() evaluated in its own scope, bounded by heads (rule B): c < l AND ... source.hasNext(), the counters first.
(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.
<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.
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.
FunctionProbes.Registered	FunctionProbes.enter(CoverageProbePlacer placer, ISymbol operation, DebugInfo debugInfo)	THE registration of a callable with the probe placer, and its three probes.
(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.
GuardedConditionEvaluator.ConditionEvaluation	GuardedConditionEvaluator.evaluate(EK9Parser.ExpressionContext conditionExpr, EK9Parser.PreFlowStatementContext preFlowStmt, VariableDetails conditionResult, String scopeId, DebugInfo debugInfo)	Evaluates a condition expression that may have guard variables.
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.
GuardedConditionEvaluator.ConditionEvaluation	GuardedConditionEvaluator.evaluateGuardOnlyForVariable(ISymbol guardSymbol, String variableName, VariableDetails conditionResult, String scopeId, DebugInfo debugInfo)	Evaluates guard only for a pre-resolved variable (used by WHILE/DO-WHILE for entry check).
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.
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.
(package private) ConditionAndPostLoop	StreamEmissionEngine.generateConditionAndBody(org.antlr.v4.runtime.tree.ParseTree probeSite, List<EK9Parser.StreamPartContext> stages, IteratorSetup iteratorSetup, String pipelineItemVar, ISymbol elementType, TerminalSetup terminalSetup, DebugInfo debugInfo, List<StageState> stageStates, boolean rawIterator, String pipelineScopeId, List<IRInstr> preLoopInstructions)	Generate condition (hasNext) and body (next + stages + terminal pipe).
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) ForRangePolymorphicInstr.DispatchCases	RangeIterationHelper.generateDispatchCases(RangeIterationHelper.InitializationData initData, String loopVariableName, DebugInfo debugInfo)	Generate dispatch cases with explicit IR for all three directions.
(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.generateExternalFieldAssignIfUnset(String isSetBoolean, List<IRInstr> assignmentBody, DebugInfo debugInfo)	Generate CONTROL_FLOW_CHAIN for assign-if-unset on external field.
(package private) RangeIterationHelper.InitializationData	RangeIterationHelper.generateInitialization(EK9Parser.ForRangeContext forRangeCtx, DebugInfo debugInfo)	Generate initialization instructions for the loop.
(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.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.
(package private) StageSetupResult	StreamPipelineMachinery.generateStageSetup(List<EK9Parser.StreamPartContext> stages, String scopeId, DebugInfo debugInfo)
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.
(package private) StageWrapResult	StreamPipelineMachinery.helperDrainBody(HelperSource source, String castTypeName, String itemVar, Supplier<StageWrapResult> downstream, DebugInfo debugInfo)	THE body of a loop over a runtime helper: its own per-element scope, item = (castType) source.next() (StreamPipelineMachinery.drainNextIntoItem(List, HelperSource, String, String, DebugInfo)), then what downstream builds - generated once that scope is current, so what it makes per element is owned by the iteration (A11).
(package private) ConditionAndPostLoop	StreamPipelineMachinery.helperDrainLoop(HelperSource source, String castTypeName, String itemVar, List<StageState.Counter> heads, Supplier<StageWrapResult> downstream, DebugInfo debugInfo)	THE loop over a runtime helper - the twin of StreamPipelineMachinery.buildStreamLoop(IteratorSetup, List, String, ISymbol, boolean, ParseTree, StreamLoopSink, DebugInfo) for an HelperSource rather than an iterator: the StreamPipelineMachinery.drainCondition(HelperSource, List, DebugInfo) (bounded by heads), then the StreamPipelineMachinery.helperDrainBody(HelperSource, String, String, Supplier, DebugInfo).
OperationBodyPlan.Builder	OperationBodyPlan.Builder.inBodyScope(DebugInfo debugInfo)
(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.
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)).
(package private) PipelineVarPlan	StreamPipelineMachinery.planPipelineVars(List<EK9Parser.StreamPartContext> stages, String sourceVar, ISymbol sourceType, String scopeId, DebugInfo debugInfo, List<IRInstr> declarationsOut)	Compute the per-boundary item-variable plan for an in-loop stage list, allocating a fresh variable (declared at the produced type) only where a stage changes the element type.
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).
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.
(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.
protected CallDetails	AbstractStreamStageGenerator.streamFunctionCall(FunctionSymbol fn, String funcInstanceVar, List<ISymbol> flowingTypes, List<String> argVars, String returnTypeName, DebugInfo debugInfo, List<IRInstr> setupInstructions)	THE shared builder for a stream stage-function _call invocation - used by every stage that invokes a resolved function on the flowing element(s): filter/reject and split predicates, map and tee mappers, uniq and group key-functions, and the join fold.
(package private) StageWrapResult	StreamEmissionEngine.terminalBodyTail(List<EK9Parser.StreamPartContext> stages, String itemVar, ISymbol itemType, TerminalSetup terminalSetup, String scopeId, List<IRInstr> preLoopInstructions, List<StageState> stageStates, String asyncExecutorVar, DebugInfo debugInfo)	StreamEmissionEngine.terminalBodyTail(List, String, ISymbol, TerminalSetup, String, List, List, DebugInfo) over an async executor's results: asyncExecutorVar is handed to a HEAD among the stages so a satisfied head cancels the executor's outstanding work (null: no executor).
(package private) StageWrapResult	StreamEmissionEngine.terminalBodyTail(List<EK9Parser.StreamPartContext> stages, String itemVar, ISymbol itemType, TerminalSetup terminalSetup, String scopeId, List<IRInstr> preLoopInstructions, List<StageState> stageStates, DebugInfo debugInfo)	The shared stream body-tail, used identically by the cat path (the StreamPipelineMachinery.buildStreamLoop(IteratorSetup, List, String, ISymbol, boolean, ParseTree, StreamLoopSink, DebugInfo) sink) and the for-range streaming body: plan the per-boundary item vars (declared pre-loop in preLoopInstructions so a post-loop consumer like JOIN's emit references a dominating var), pipe the final-typed item to the terminal, and wrap the result in the intermediate stages.
static ResourceCloser.Closing	ResourceCloser.Closing.viaSuper(ISymbol superType, String superTypeName, DebugInfo debugInfo)	The super class's close, called NON-virtually on this object (super._close()): the last step of a generated close chain.
(package private) void	StreamPipelineMachinery.withPipelineScope(List<EK9Parser.StreamPartContext> stages, boolean typedItem, String itemTypeName, DebugInfo debugInfo, List<IRInstr> instructions, PipelineScopeBody body)	THE pipeline scope frame: mint and enter a scope, declare the pipeline's element slot in it (StreamPipelineMachinery.declareElementSlot(List, boolean, String, String, DebugInfo)), emit the pre-loop state of stages (StreamPipelineMachinery.generateStageSetup(List, String, DebugInfo)), run body (the loop or drain), then exit the scope - which drops the slot's last value.
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.
(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.

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

Modifier and Type	Method	Description
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.

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

Modifier	Constructor	Description
(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.
	Closing(String variable, ISymbol staticType, String staticTypeName, DebugInfo debugInfo)	A value already held in a variable.
	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.
(package private)	Evaluated(List<IRInstr> instructions, String primitiveResult, String expressionText, DebugInfo debugInfo)	Creates an instance of a Evaluated record class.
	OperationBodyPlan(OperationBodyPlan.Step entry, boolean hasBodyScope, DebugInfo bodyScopeDebugInfo, OperationBodyPlan.Step parameters, OperationBodyPlan.Step prologue, OperationBodyPlan.Step returning, OperationBodyPlan.Step body, OperationBodyPlan.Step bodyEnd, OperationBodyPlan.Step afterScope, OperationBodyPlan.Step exit, OperationBodyPlan.Step tail)	Creates an instance of a OperationBodyPlan record class.
	OrchestratorContext(GuardVariableDetails guardDetails, ReturnVariableDetails returnDetails, String outerScopeId, DebugInfo debugInfo)	Creates an instance of a OrchestratorContext record class.
(package private)	StageWrapParams(EK9Parser.StreamPartContext stageCtx, List<IRInstr> innerBody, DebugInfo debugInfo)	Creates an instance of a StageWrapParams record class.

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

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

Modifier and Type	Class	Description
final class	PanicLocationSuffix	THE " at file:line:col" suffix appended to a Panic message (PanicThrowInstrs), or "" when the location is unknown - hold one and use it.

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

Modifier and Type	Method	Description
DebugInfo	BinaryOperatorParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	BooleanExtractionParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	ComparisonParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	DirectionCheckParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	IncrementParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	LiteralParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	PromotionParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	ShortCircuitBlock.Operands.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	UnaryOperatorParams.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	VariableDetails.debugInfo()	Returns the value of the debugInfo record component.
DebugInfo	StrictAbsent.Observer.location()	Returns the value of the location record component.

Methods in org.ek9lang.compiler.phase7.support with parameters of type DebugInfo

Modifier and Type	Method	Description
void	CycleGuardOwner.addIfNeeded(IRConstruct construct, IScope scope, IRInstructionBuilder cInitBuilder, DebugInfo debugInfo, Ek9Types ek9Types)	THE step every _c_init generator calls (there are two: AbstractDfnGenerator and Scenario3SourceIRGenerator for a developer's parameterised generic): when the type's generated operators are guarded, declare the constant on the construct and make it in the _c_init being built.
List<IRInstr>	ConstantCopyOnAccessLoader.apply(ISymbol constantSymbol, String resultVariable, DebugInfo debugInfo)	Read the constant into resultVariable as a fresh copy.
String	PanicLocationSuffix.apply(DebugInfo debugInfo)
ConstantCopyOnAccessLoader.LoadedConstant	ConstantCopyOnAccessLoader.applyToNewTemp(ISymbol constantSymbol, DebugInfo debugInfo)	Read the constant into a freshly generated temp, returning both the instructions and that temp.
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.
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.
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.
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.
MemoryInstr	FunctionInstance.constructedAsValue(IRGenerationContext stackContext, FunctionSymbol functionSymbol, String resultVariable, DebugInfo debugInfo)	THE lowering of a function CONSTRUCTED as a value - countOf() of String, a parameterised generic function - to its singleton instance: a FUNCTION_INSTANCE, never an invocation.
void	CycleGuardOwner.declare(IRConstruct construct, DebugInfo debugInfo, Ek9Types ek9Types)	Declare the static field on the construct (not traced: it holds a constant that lives as long as the type).
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).
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.
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).
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>	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>	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.
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).
static LoopIterationCondition	LoopIterationCondition.inIterationScope(ScopedInstructionExecutor executor, DebugInfo debugInfo, Function<String, LoopIterationCondition.Evaluated> evaluator)	Evaluate a loop condition inside its own iteration scope.
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]).
IRInstr	CycleGuardOwner.load(String resultVar, IAggregateSymbol aggregate, DebugInfo debugInfo)	Load the constant for a guarded operator - a borrowed reference, neither retained nor released.
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, DebugInfo debugInfo)	Create the prologue with every instruction attributed to debugInfo.
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>	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>	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.
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().

Constructors in org.ek9lang.compiler.phase7.support with parameters of type DebugInfo

Modifier	Constructor	Description
	BinaryOperatorParams(String leftOperand, String rightOperand, String operator, ISymbol leftType, ISymbol rightType, ISymbol resultType, String resultTemp, String scopeId, DebugInfo debugInfo)	Creates an instance of a BinaryOperatorParams record class.
	BooleanExtractionParams(String booleanObjectVar, String resultTemp, DebugInfo debugInfo)	Creates an instance of a BooleanExtractionParams record class.
	ComparisonParams(String leftOperand, String rightOperand, String operator, ISymbol leftType, ISymbol rightType, ISymbol booleanType, String booleanObjectTemp, String primitiveBooleanTemp, String scopeId, DebugInfo debugInfo)	Creates an instance of a ComparisonParams record class.
	DirectionCheckParams(String directionTemp, String comparisonOperator, String zeroTemp, String booleanObjectTemp, String primitiveBooleanTemp, ISymbol integerType, ISymbol booleanType, String scopeId, DebugInfo debugInfo)	Creates an instance of a DirectionCheckParams record class.
	IncrementParams(String counterVar, String operator, ISymbol counterType, String scopeId, DebugInfo debugInfo)	Creates an instance of a IncrementParams record class.
	LiteralParams(String tempName, String literalValue, ISymbol literalType, DebugInfo debugInfo)	Creates an instance of a LiteralParams record class.
	Observer(String operator, DebugInfo location)	Creates an instance of a Observer record class.
	Operands(String targetVariable, OperandEvaluation left, String leftPrimitive, OperandEvaluation right, String resultTemp, CallDetails resultCall, String scopeId, DebugInfo debugInfo)	Creates an instance of a Operands record class.
	PromotionParams(ISymbol sourceType, String sourceVariable, DebugInfo debugInfo)	Non-escaping (scope-local) promotion — the common case (list/dict element, range bound, comparison operand).
	PromotionParams(ISymbol sourceType, String sourceVariable, DebugInfo debugInfo, boolean escaping)	Creates an instance of a PromotionParams record class.
	UnaryOperatorParams(String operand, String operator, ISymbol operandType, ISymbol resultType, String resultTemp, String scopeId, DebugInfo debugInfo)	Creates an instance of a UnaryOperatorParams record class.
	VariableDetails(String resultVariable, DebugInfo debugInfo)	Creates an instance of a VariableDetails record class.

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

Methods in org.ek9lang.compiler.phase7.synthesis that return DebugInfo

Modifier and Type	Method	Description
protected DebugInfo	AbstractSyntheticGenerator.createDebugInfo(ISymbol symbol)	Create debug info from a symbol's source token.

Methods in org.ek9lang.compiler.phase7.synthesis with parameters of type DebugInfo

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).
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.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, DebugInfo debugInfo, String unsetLabel, String scopeId)	Generate isSet guard check for a variable with branch to unset return.
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.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, 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.runtimeTypeCheck(String differentTypeLabel, DebugInfo debugInfo)	THE run-time-type check itself, the first step of the comparison: nothing when differentTypeLabel is null.

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

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

Modifier and Type	Method	Description
DebugInfo	SynthesisScope.debugInfo()	Returns the value of the debugInfo record component.

Methods in org.ek9lang.compiler.phase7.synthesis.support with parameters of type DebugInfo

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.
IRInstr	SyntheticMethodCallBuilder.buildCall(DebugInfo debugInfo)	The call instruction alone, for a caller that states the result's owner itself.
List<IRInstr>	SyntheticMethodCallBuilder.buildReturning(String returnVariable, DebugInfo debugInfo, String scopeId)	SyntheticMethodCallBuilder.buildReturning(String, SynthesisScope) with explicit debugInfo and scopeId.
List<IRInstr>	SyntheticMethodCallBuilder.buildVoid(DebugInfo debugInfo, String scopeId)	Build the IR instructions for a void method call using explicit debugInfo and scopeId.
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.

Constructors in org.ek9lang.compiler.phase7.synthesis.support with parameters of type DebugInfo

Modifier	Constructor	Description
	SynthesisScope(DebugInfo debugInfo, String scopeId)	A scope that returns nothing (a void body, or a stage of a larger body).
	SynthesisScope(DebugInfo debugInfo, String scopeId, String returnVariable)	Validate that scopeId is not null.