Package org.ek9lang.compiler.phase7.support


package org.ek9lang.compiler.phase7.support
  • Class
    Description
    Holds argument processing results for method/function calls: the temporary variable holding each evaluated argument and the resolved type of each argument.
    Data class to hold parameters for assign-if-unset generation.
    CONCERN: Binary operator invocation with memory management.
    Parameters for binary operator invocation.
    THE OperationBodyLocator of members declared in an aggregate's parts, matched by symbol identity (classes, records, traits, components).
    THE OperationBodyLocator of members declared in a service, matched by symbol identity: its methods first, then its service operations (a service has no aggregate parts).
    THE step from an evaluated condition to what a branch reads - use this, do not re-derive it.
    Parameters for boolean primitive extraction.
    Creates evaluation instructions for Boolean._ofFalse() static method call.
    Creates evaluation instructions for Boolean._not() method call.
    THE factories for the recurring CallDetails shapes in IR generation - hold one (private final CallDetailsFactory callDetailsFactory = new CallDetailsFactory();) and call it.
    THE parameter types of the constructor a dynamic class or a dynamic function is created through: one per captured variable, in capture order, named from the construct's OWN captured variables - exactly as FieldsFromCapture declares its fields, so the call and the constructor it calls cannot disagree.
    THE stores of a dynamic class's or dynamic function's captured values into its fields (DFN-6): each captured variable, in order, is a property of the construct - a slot its OBJECT owns - and takes its own reference to the value captured: SLOT_ASSIGN this.x, x [copy, init] (OwnershipStatements.propertyAssigned(String, String, boolean, DebugInfo)), lowered to STORE this.x, x; RETAIN this.x.
    THE OperationBodyLocator of the members of a monomorphised COPY, matched to their declarations in the generic's aggregate parts by source token: phase-6 type substitution clones each method and keeps its source token (the same object), so the token is what still links a clone to the declaration it came from.
    THE shared "promote a collection-literal element to the collection's resolved element type" step.
    What a value of one type needs to enter a slot of another (EXPR-11).
    CONCERN: Comparison evaluation with boolean primitive extraction.
    Parameters for comparison evaluation.
    THE definition of which callees are compiler↔runtime PLUMBING rather than part of the EK9 program.
    Record to group conditional evaluation instructions with the resulting condition name.
    Result of condition evaluation with primitive boolean extraction.
    THE shared "read a module-level constant" step - use this, do not re-derive a variant.
    The instructions reading a constant, and the variable now holding the fresh copy.
    THE members of a constrained enumeration (RedSuit as CardSuit constrain as "Hearts" or "Diamonds"): the base enum's values, in declaration order, whose name satisfies the constraint - each with its BASE ordinal.
    THE way a construct's field declarations are made - hold one and use it, never build a FieldCreator and a FieldsFromCapture by hand again: ConstructFieldDeclarations.addPropertiesAndCapturesTo(IRConstruct, IRGenerationContext, AggregateSymbol) for an aggregate (its properties, then its captures) and ConstructFieldDeclarations.addCapturesTo(IRConstruct, IRGenerationContext, ICanCaptureVariables) for a function (captures only).
    THE recording, in the IR, of an override's narrower (covariant) return - front-end rationalisation N07, Steve 2026-10-02: "this needs to be made clear at the IR generation level".
    THE per-type owner constant of the property-cycle guard (Contract 13 in EK9_BACKEND_IR_CONTRACTS.md) - hold one and use it, never a String literal built per call.
    THE load of a wrapper's delegate field, borrowed for the scope - shared by the constrained types (ConstrainedTypeInstrs) and the Scenario-2 wrappers (Scenario2WrapperHelper), which each had a byte-identical private copy (DFN-3, MONO-8).
    CONCERN: Direction check evaluation for polymorphic for-range loops.
    Parameters for direction check evaluation.
    Configuration for for-range loop direction (ascending vs descending).
    THE monomorphisation of a dynamic function or dynamic class declared inside a generic body - hold one at every site that generates or constructs one, never a variant.
    A simple record that can be used when processing expressions.
    Creates the appropriate Field object for the symbol and adds it to the construct.
    Accepts a ICanCaptureVariables (either a function or an aggregate).
    A field as STORE_FIELD describes it - the object, the field's name, the type that owns it, the field's type and its index (or OwnershipInstr.NO_FIELD_INDEX where STORE_FIELD looks it up by name).
    THE lowering of a function CONSTRUCTED as a value to its singleton instance - hold one and use it.
    THE member symbols of a function construct (IR tidy W3.3, DFN-5/MONO-4): a function - named, dynamic or a Scenario-3 parameterisation - is generated as a class with a constructor, a _call method and a ? operator, and these are the symbols of those three.
    CONCERN: Loop counter increment/decrement.
    Parameters for increment/decrement evaluation.
    Rather than smatter the Java code with 'stringy' constants for the IR, they are defined here.
    Converts the single IRInstr supplied by the supplier into a List with one element in.
    THE test for a BOUNDARY PRIMITIVE: a method on a real EK9 type that exists only for IR/code generation - _true, _false, _set, _of, _ofTrue, _ofFalse.
    THE test for a constructor of a type that only the compiler may create - Panic.<init> (Steve, decision 10, 2026-10-05; one of the three kinds of CompilerPlumbingCalls).
    THE reading of how a function call finds the function instance it invokes - hold one and ask it, never read the DELEGATE_CALL mark by hand.
    Creates evaluation instructions for _isSet() method calls.
    THE compiler-synthesised MEMBER set - _i_init, _c_init, _fieldSetStatus, _copyAccepts, _base (Steve, F3a 2026-10-08: one predicate, widened from the lifecycle pair) - hold one and ask it, never a second list.
    THE call shapes for the raw org.ek9.lang::List buffer that stream pipeline staging drains into - use these, do not hand-roll a fourth variant.
    Parameters for literal value loading.
    A simple record that can be used when processing literals.
    Record to group logical operation context information.
    THE loop condition in its own per-iteration scope (IR tidy FLOW-10): the scope is entered and left on every iteration so the condition's temporaries are released each time round.
    What an evaluator hands back from inside the iteration scope.
    CONCERN: Literal loading with memory management.
    Result of method resolution including cost analysis.
    Record to group operand evaluation instructions with the resulting operand name.
    THE operation-body locator (IR tidy plan DFN-1): where, in the parse tree, the body of one of a construct's methods or operators is written.
    THE search of an aggregate's method and operator declarations for the one whose recorded symbol matches - use this (through OperationBodyLocator, THE operation-body locator), never a third copy of the two loops.
    A declaration that matched.
    THE value-ownership statements of IR generation (D-O11, EK9_IR_OWNERSHIP_STAGE1_DESIGN.md §11) - hold one and call it, never build an OwnershipInstr by hand: each method states ONE ownership fact where a value is made, declared, stored or handed over, in the ownership form (OWN, DROP_AT_EXIT, SLOT_DECLARE, SLOT_ASSIGN, FIELD_ASSIGN).
    THE " at file:line:col" suffix appended to a Panic message (PanicThrowInstrs), or "" when the location is unknown - hold one and use it.
    THE single-source-of-truth for emitting the "construct and throw an org.ek9.lang::Panic" IR sequence - EK9's one representation of an uncatchable fatal invariant breach.
    THE IR name of a this / super primary reference (EXPR-10): IRConstants.THIS or IRConstants.SUPER.
    Processing details for primary reference generation (THIS and SUPER keywords).
    CONCERN: Boolean primitive extraction from EK9 Boolean objects.
    Extracts metadata from EK9 program symbols to create ProgramDetails objects for the PROGRAM_ENTRY_POINT_BLOCK.
    Represents a variable that has been promoted using the #^ operator.
    CONCERN: Type promotion call generation using the #^ operator.
    Parameters for type promotion invocation using the #^ operator.
    Result of parameter promotion processing.
    Triggers the expression processing with the given details.
    THE calls that run NO EK9 code and release nothing - so none can reassign a field or let go of a value a caller merely borrows (V-I, EK9_IR_OWNERSHIP_STAGE4_DESIGN.md §6): the boundary primitives (a primitive wrapper's _true, _of, ...; IsBoundaryPrimitive) and the property-cycle guard's enter/exit, which records identities in its own frames (ek9_cycle_guard.c: no vtable call, no retain or release).
    THE run-time-type check in front of a concrete type's sameness (D24 rule 3, Contract 22): values of different run-time types are never the same, so the comparison goes to its "different type" answer - == false, <> true, <=> unset - before anything else in it runs.
    THE single source of 'sanitized' parameter cleaning in IR generation - hold one and call it, do not re-derive it, and never clean at a call site.
    CONCERN: Temporary scope lifecycle management.
    A scoped body and the id of the scope it ran in (for sites that name that scope afterwards, for example as a case scope id).
    Memory management for CONSUMING a value that was already RETAIN'd by a producer.
    Extracts HTTP metadata from an EK9 service AggregateSymbol to produce a fully materialised ServiceRouteDetails.
    THE short-circuit Boolean block: a LOGICAL_AND_BLOCK or LOGICAL_OR_BLOCK built from an already evaluated LEFT operand (with its primitive), a RIGHT operand evaluated only when LEFT does not decide, and the result computation left._and(right) / left._or(right).
    The parts of one block.
    Determine if a variable should be registered in scope for cleanup.
    THE call shapes for the compiler-to-runtime helper types stream pipelines lower onto (Ek9Async, Ek9Group, Ek9Split, Ek9Join, Ek9Uniq, the tail buffer, Ek9Sort) - use these (hold one), do not hand-roll another; the sibling of ListBufferCalls, which owns the List buffer.
    THE compile-time half of strict-absent mode (Steve, decision 5, 2026-10-07: "a residual absence PANICS, always").
    What observed an absent value, and where: the operator, and the source location named in the Panic message.
    Locates the textBodyDeclaration parse context for a given text method symbol.
    THE single decision point for lowering a text constructor call.
    THE single source of truth for "does a call on this target need INVOKEINTERFACE?".
    THE name-keyed form of "is the type this CALL names externally linked?" - the value of CallDetails.isExternTarget for a site that holds a type NAME and not the type's symbol (IR lane F, Steve 2026-10-28).
    CONCERN: Unary operator invocation with memory management.
    Parameters for unary operator invocation.
    Just holds details for retaining and registering a target for memory management.
    Calls a supplier of main processing instructions and then adds in the memory management.
    Get the name of the variable suitable for use in the IR.
    THE step for an operand declared Any that may be a WRAPPER over a base value - a parameterised generic's wrapper (D60: DictEntry <=> Any) or a constrained type (D74: Age <=> Any).