All Classes and Interfaces
Class
Description
Common abstract base class for all specialized ASM generators.
Base class for assert expression generators (assertThrows, assertDoesNotThrow).
Result of building the assertion expression body.
Abstract base class for control flow bytecode generators.
Acts as a base for the main construct definitions.
The abstract base on most antlr listeners.
Base class for all IR generators providing common utilities for safer symbol access,
temporary variable creation, and type extraction.
C' (Steve, 2026-10-08): an ABSTRACT
$, $$ or #? declared on a type that HAS fields,
counting inherited ones, is an error (E07185), reported at the abstract operator.Does checks on the control part of a while loop to see if Optional/Result/Iterator are now safe via method access.
Once an expression has been assessed as being simple enough to process, this
consumer is called to mark the appropriate symbol(s) used in the expression as safe if the
appropriate methods are called.
Both AND/OR are very similar in processing, the only real differences are:
What operation to call and the op code to generate.
What operation to call and the op code to generate.
THE shared vocabulary for stream pipeline IR generation - extend this rather than re-deriving any
of these steps inside an individual stage.
Base class for synthetic operator generators.
An entered cycle guard: the variable holding the owner name, needed again by the matching exit.
Record bundling scope context with initialized instruction list.
Represents an abstract value in the value-tracking lattice for flow analysis.
Pulls out the common code for variable and variable-only declarations.
Validates that application blocks do not have too many registrations (E11042).
Emit error if there are too many arguments.
Validates class design patterns for Construct Misuse Detection (E11022-E11025).
Checks cognitive complexity at function/method/operator exit and emits error if too high.
Checks LCOM4 cohesion against thresholds and emits errors if exceeded.
Checks the combined complexity and statement count at function/method/operator exit.
Looks for the complexity value in the complexityCounter and adds the value to the
appropriate symbol.
Checks efferent coupling (Ce) against thresholds and emits errors if exceeded.
Checks expression complexity when a coalescing expression tree completes.
Checks inheritance depth (DIT) against thresholds and emits errors if exceeded.
Pops the injection count from the counter and stores it as squirrelled data on the symbol.
Validates DI injection design quality for components (E11040).
Validates DI injection design quality for a single callable (E11043).
Validates module-level cohesion against threshold and emits E11017 error if exceeded.
Functional interface to get the appropriate ErrorListener for a ParsedModule.
Validates module-level efferent coupling against threshold and emits E11016 error if exceeded.
Functional interface to get the appropriate ErrorListener for a ParsedModule.
Validates the number of constructs declared in a module against
MetricLimits.MODULE_SIZE and emits E11027 if exceeded.Checks nesting depth at function/method/operator exit and emits error if too deep.
Checks statement count at function/method/operator exit and emits error if too many.
Uses the symbol and scope management to traverse back up stack to determine if
the outer parent is a generic type or not and also if this symbol passed in is a generic type.
Just gets the left and right hand side of values in an expression.
Just gets both of the ternary expression parts (not the control).
Check that a symbol can be accessed issues error if not possible.
Common code of Aggregate Construct types.
Deals with the creation of various aggregate types.
Predicate to see if an aggregate mandated pure in its construction.
Support for taking one aggregate and manipulating the methods and the like to be applied
to another aggregate.
THE order of the members of an aggregate body (E01086, Steve 2026-10-11): properties first, then constructors and
methods, then operators (an explicit
operator, override operator or default operator X,
in any order among themselves), and a bare default operator as the LAST item of all.The first member of a body out of order.
E01086: the members of an aggregate body (class, record, trait, component, dynamic class) out of the order EK9
requires - properties, then constructors and methods, then operators, then at most one bare
default operator as the last item.Data structure to facilitate checks on methods on an aggregate.
Code quality metrics for a class, record, or component.
This is typically a 'class' or an interface type where it can include the definitions of new
properties.
An aggregate, but one that can have zero or more traits (like interfaces).
Enforces 'allow only' constraints on traits and classes (sealed type pattern).
Reviews all the modules and looks for all the 'Programs' that have been defined anywhere.
Checks that all the text bodies that are on the super are also present in the language variant.
Checks call sites for ambiguous positional arguments.
Emits the
Any-typed comparison bridge methods (_eq(Any) / _cmp(Any)) for
generated user aggregates.Search for a symbol of any category with the matching name.
Special type that is super of Aggregate and super of Function (if they don't have supers).
Search for a symbol of any types category with the matching name.
Check that an application definition is configured in an acceptable form.
Generates a single global
_Application JVM class from application registrations.Binding information for a service registration that has HTTP routes.
Creates the appropriate IR Construct for an application declaration.
Checks for the appropriate use of the APPLICATION of xyz on a method declaration.
Resolves each class in an 'allowingOnly' list (checking it is a suitable CLASS genus) and registers it
as an allowed extender of the supplied aggregate.
Resolves each trait in a 'traitsList' (checking it is a suitable CLASS_TRAIT to extend) and adds it
to the supplied aggregate.
Checks if the body of a method/operator is appropriate.
Checks if the body of a function is appropriate.
Holds argument processing results for method/function calls.
THE labelling of a call's positional arguments from the parameter names the compiler resolved -
use this, do not split an argument list by hand anywhere else.
The corrected text plus one note per call labelled;
notes empty means nothing moved.Automated Readability Index (ARI) adapted for source code.
Designed to capture the ASM specifics for byte code generation.
Specialized ASM generator for CREATE_ASPECT_PROXY instruction.
Generates a synthetic proxy class for aspect weaving.
Details for the CREATE_ASPECT_PROXY IR instruction.
Method signature information for proxy class generation.
High-level IR instruction for creating an aspect-woven proxy.
Validates assertDoesNotThrow expression and sets the return type to Void.
IR Generation for the assertDoesNotThrow expression.
EK9 assertDoesNotThrow expression - validates that an expression does not throw.
Validates assertPanic expression - the test-only counterpart to assertThrows that traps an
org.ek9.lang::Panic.IR Generation for the assertPanic expression.
EK9 assertPanic expression - asserts that the wrapped expression fires an
org.ek9.lang::Panic.Checks that the assert statement actually has a boolean result from the expression.
IR Generation for the assert statement.
Specialized ASM generator for AssertThrowsInstr processing.
Validates assertThrows expression - checks that the type argument extends Exception
and sets the return type of the expression to that exception type.
IR Generation for the assertThrows expression.
IR instruction for test-only assertion constructs that wrap expressions in try-catch.
EK9 assertThrows expression - captures an expected exception type and expression.
Used as simple one-liners to check a value and issue an illegal argument exception if empty.
Specialized generator for EK9 assign-if-unset (:=?).
Assign-if-unset generator using unified CONTROL_FLOW_CHAIN approach.
Data class to hold parameters for assign-if-unset generation.
Detects assign-if-unset statements (
:=?) that can never apply (E08095).Used to decouple checks from the grammar contexts.
Just really pulls up the appropriate symbol from the expression into this context.
Creates IR instructions for assignment expressions.
Checks the assignments for operator : := = and :=? that's all.
Used in the full resolution phase to check assignments.
Check the assignment to a variable can be a single assignment or a deep copy type assignment.
Process assignment statement: variable = expression
Uses RELEASE-then-RETAIN pattern for memory-safe assignments.
THE declared (target) type an
assignmentExpression is given to - use it, do not re-derive the walk.Designed to add in methods on the aggregate where the 'traits' use is 'traits by'.
The ek9 developer does not need to redeclare incoming or returning parameters for dynamic functions.
Supplies the compiler phases for the back end.
THE rewrite of a double-quoted String's text as a backtick String — use this; never re-derive it.
Test if a symbol is a BARE-defaulted operator, i.e.
Completes every bare 'default operator' once types are known, after every source has been through
EXPLICIT_TYPE_SYMBOL_DEFINITION (front-end audit FE74, F2).
THE test for a generic's bare type parameter
T itself, as opposed to a generic that HAS type parameters.Represents a basic block in the EK9 IR - a sequence of instructions with single entry and exit.
Factory for fairly basic symbols.
Simple bi-directional map for Strings.
THE reading of a binary or prefix
expression alternative for the phase-1 operand-parentheses checks -
E08269 (CoalescingOperandParenthesesOrError), E08273 (NotOperandParenthesesOrError) and E08274
(DoubleNegationOrError).Generates IR instructions for binary operations (e.g., addition, subtraction, comparison, etc.).
CONCERN: Binary operator invocation with memory management.
Parameters for binary operator invocation.
Holds one thing an application-block statement (a registration or a block statement) starts running: a call it
makes - a registration's constructor, a call in its arguments, an aspect's constructor - or a dynamic function or
class it creates.
Creates a suitable scope name for a token position.
Creates IR instructions for block statements.
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 IR
CallDetails for the non-virtual EK9 Boolean logical operators that the lowering
synthesises - _and, _or and ~.THE Boolean truth guard rule (Steve, 2026-10-07, decision D9.2) - use this, do not re-derive it.
Represents an unreachable program point — a contradiction in constraints.
The (object, primitive) Boolean vars naming a grouping stage's per-item boundary condition.
Builds a grouping stage's per-item boundary condition into the drain inner body.
Specialized IR instruction for control flow operations (BRANCH, BRANCH_TRUE, BRANCH_FALSE, ASSERT, RETURN).
Specialized ASM generator for BranchInstr processing.
The runtime tracker a bucketing stage accumulates into, and what it hands downstream.
Everything a buffering stage needs.
Just resolves a number of built-in types so that internal compiler code can be more explicit.
The built-in-type seed for the input-variation metric's denominator: the
TypeClassModel (class count + confidence) for each EK9 built-in.To be used in EK9 source code to assert that generated JVM bytecode matches expectations.
Checks if there are any directives that relate to @BYTECODE in the parsed module and validates
the generated JVM bytecode against expected output.
Executes generated EK9 bytecode within the current JVM.
Result of executing a generated EK9 program.
Restores the fallbacks a
BytecodeExecutor.redirectUncaptured(PrintStream, PrintStream) call displaced.Context for bytecode-generation control flow.
Dispatch case for FOR_RANGE_POLYMORPHIC three-way generation.
Normalizes JVM bytecode output from javap for stable test comparisons.
Functional interface to get the appropriate ErrorListener for a callable.
THE identity of a callable in the phase-5 call graph —
module::Aggregate.member(T1,T2) for
a method, module::Aggregate.member for any other aggregate member, and the plain
fully-qualified name for everything else.Metadata about a callable entity (function, method, operator, constructor, program).
Builder for CallableInfo to support incremental construction during AST traversal.
Context information needed for resolving method calls and constructing CallDetails.
Used with CallInstr, holds all the necessary details to make a call.
The four kinds of CALL - see the record javadoc.
Composable builder for creating CallDetails with cost-based method resolution and promotion support.
Result of building CallDetails including any promotion instructions needed.
Static factories for the recurring
CallDetails shapes in IR generation.Provides IR Call details for making a call to the EK9 Boolean type to call the _false() method.
Just provides the IR Call details for making a call to the Ek9 Boolean type to call the _true() method.
Supplies the call details to get a Boolean false value.
Represents an edge in the call graph from caller to callee.
Call graph for EK9 programs with bidirectional edges.
Collects call graph information during AST traversal in Phase 5 (PRE_IR_CHECKS).
Specialized IR instruction for method calls (CALL, CALL_VIRTUAL, CALL_STATIC, CALL_DISPATCHER).
Specialized ASM generator for CallInstr processing.
Generates IR instructions for function/method calls.
Metadata about method/function/operator calls that can be used by backends for optimization.
Extracts call metadata from symbols for use in IR generation.
Designed to deal with this following part of the EK9 grammar.
Details required for processing function calls in a context-aware manner.
Generate function invocation for a call stage.
Just re-uses the bulk of method symbol for when we want to make a symbol that is a call
to an actual method.
THE single source of truth for the descriptor OWNER and dispatch of a resolved call: the type where a
resolved method's body is actually emitted (its "defining type") and the virtual-dispatch decision.
Classification of call site types for call graph analysis.
Blocks direct assignment from sanitized parameters to local variables.
Pass 1 of the EK9 source formatter: Canonical Indentation.
Checks that gated system types are only used in publishable packages when the
corresponding capability has been declared.
Creates the sole synthetic constructor for dynamic classes.
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.Capture ownership by FRESHNESS (R-E, Steve 2026-10-06) - never by the named/unnamed syntax of the capture.
THE "is this symbol one of the variables a dynamic function or class captured?" - by IDENTITY, never by name.
THE phase-3 answer to "whose code is running here?" for a property field (a private property or a capture) -
shared by the access check (E06180 in
IdentifierReferenceOrError) and the "read it through a capture"
wording of an unresolved name inside a dynamic body (IdentifierReferenceOrError, IdentifierOrError).A field of the code around a dynamic body, and whether that body is a dynamic class's (else a function's).
Used to actually hold the captured symbols.
Just focuses on the ability to possible capture variables from an enclosing scope.
IR instruction for explicit type casting.
Specialized ASM generator for CastInstr processing.
CONCERN: Chained comparison evaluation for polymorphic for-range.
Parameters for chained comparison evaluation.
Single step in a
DeadlockChain's rationale trace.Deals with normal operators (i.e.
Checks that the use of the variable only if it has a web variable correlation is valid.
Checks that methods from a super and one or more traits do not conflict.
If the aggregate is a generic parameterised type this function triggers a check for duplicated methods.
Error when the definition of a service is invalid.
Error when the definition of a service operator is invalid.
Checks that a service operation has a security posture, either inherited from
its parent service or declared on the operation itself.
THE check that a service is written in its one form (Steve, 2026-10-11):
for before every URI - the
service's own (Items for :/items open) and each operation's (byId() as GET for :/{id},
operator += for :/) - and as before an HTTP verb.What an operator check needs: the operand, where the operator is used, and the operator search.
Ensures that a try statement/expression is used correctly in or out of an expression.
How trustworthy a type's value-class set is — the honesty tag for the input-variation metric.
Creates the appropriate IR Construct for a class declaration.
The debug-time reader of one class's EK9 source lines: the source it was compiled from (
SourceFile, the
.ek9 name) and every line any of its methods has code on (LineNumberTable).Decides whether a construct's modifier (
as open / as abstract) may legally be
toggled to a proposed state — the "declaration viability" of the modifier refactoring.The four modifier toggle modes.
Outcome of asking whether a class's modifier (
as open / as abstract) may be
changed — the "declaration viability" layer used to gate the class-modifier toggle tooling and
to decide whether the IDE should even offer the refactor.THE re-typing of members that were cloned from a template onto their new owner - use this, never a variant.
THE record of which constructor parameters a constructor KEEPS as a closeable property, and the deferred verdict
on every construction that hands such a parameter a value that is not new (R4 of the fresh-store rule, E81062).
R7 of the closeable ownership rules (Steve, 2026-10-05): closeability cannot be erased by a store (E81059).
If you hold it, you close it (E81067, Steve 2026-10-06, D8/C5): a class, record, component or dynamic class with
a closeable property - or a capture it owns (R-E) - must DECLARE its own
operator close:
default operator close or one it writes.The NAMED half of the closeable ownership rule (Steve, 2026-10-05): "A closeable value you never NAME is
owned by the statement that created it and closed when that statement finishes; a closeable value you
NAME must be declared as a try-with-resources resource." (E81056).
THE rule that a closeable type is never a type argument (E81061, Steve 2026-10-06, option A - strict).
Checks if a symbol should be tracked as a closeable resource.
R5 (Steve, 2026-10-05): a method, operator, function or dynamic function whose DECLARED return type is closeable
must return a NEW instance (E81057).
THE fresh-store rule for closeable SLOTS (R-A, Steve 2026-10-06, decisions D3 and D9, with R-D): every closeable
object has exactly ONE owner, so a closeable value may enter a slot that will close it only when nothing else
already owns it.
THE target of a compiler-generated
close call - try-with-resources, the closeable temporaries a
statement owns and the generated close chain all reach it through ResourceCloser.closeCall, so they
cannot name different owners or dispatch differently.The CALL's target type and how it is dispatched.
THE generated close chain in IR - use it, never build a property close by hand (Steve, 2026-10-06: "if you hold
it, you close it"; the C++/Swift destructor model).
Generates synthetic IR for
default operator close (_close): nothing but the generated close chain
(CloseChain, deciding through CloseSteps).The close operator is never called by EK9 code (E81060, Steve 2026-10-05, 2026-10-06).
THE decision of what a type's
operator close is responsible for - use it, never re-derive it.What a type's close closes, and the parent close it then calls.
E08269 (Steve, D6, 2026-10-07): a coalescing operator - the null coalescing
??, the Elvis ?:
and the comparison coalescing family <? <=? >? >=? - may not be an UNPARENTHESISED operand of a
DIFFERENT binary operator, nor take one as an operand.Used for variable forms of simple code flow analysis.
Designed to be used in a transient manner when interacting with variables.
Generate all type of aggregates, typically classes, components, records, etc.
SINGLE THREADED.
MULTI THREADED
Generate all constants that have been defined.
SINGLE THREADED
Preparation to generate code.
SINGLE THREADED
Optimise the generated code.
Tracks cognitive complexity within functions/methods/operators.
Tracks method-field relationships to calculate LCOM4 (Lack of Cohesion of Methods v4).
THE shared "promote a collection-literal element to the collection's resolved element type" step.
Represents a variable known to be a collection or container type with both SET/UNSET
and EMPTY/NON-EMPTY state tracked.
Pass 4 of the EK9 source formatter: Comment Interior Re-indentation.
Just for details that are common to all factories.
For use when looking to find common types.
Which common type
CommonTypeOrError is asked for.THE common-type deduction - for collections (List/Dict literals, ranges, stream 'cat') and for the
operators that SELECT one of their operands (?:, ??, <? <=? >? >=?, the ternary).
Given a list of symbols (normally variables), this code will get the type from each of those symbols.
Fixed set of constants that tend to be used to 'squirrel' away data - these are the keys.
Given a symbol, this check that the type that the symbol has can support the '<=>' operator.
Generates synthetic IR for the _cmp (<=>) operator.
Specialized generator for EK9 comparison coalescing operators (
<?, >?, <=?, >=?).CONCERN: Comparison evaluation with boolean primitive extraction.
The canonical vocabulary of EK9 comparison-operator glyphs, as named subsets, so that PRE_IR checks
reference a single source instead of hand-spelling (and silently diverging) their own switch/Set
each time.
Parameters for comparison evaluation.
Represents the whole program(s) that the developer is attempting to create.
Holds a reference to the name of the file being compiled a checksum of the
file and the date time last modified.
Check to see if any of the compilable sources have errors.
Populated in the compilable program and altered during each of the phases of compilation.
As and when sources are processed during each phase of the compilation.
For compiler, errors, warning and other information from the compiler.
Identifies the ordered set of compilation phases used in EK9.
Register this event listener with the compiler to pick up on
any warnings of errors during compilation.
Effectively a tuple for returning if the phase was a match for the required
compilation phase to be run to and if this phase ran ok.
One step of a compilation: it runs exactly ONE
CompilationPhase, and says which.Conceptual compiler.
Shared compiler surface for MCP tools, Oracle extractors, AI sessions, and the IDE.
A diagnostic entry from compilation, usable by any
CompilerAccess consumer.THE one statement of which error codes concern COMPILER DEVELOPMENT rather than writing a program (site-examples
spec §6, Steve 2026-10-11, Q5): E50200 to E50390, the codes the development directives report -
@Error,
@Resolved, @Complexity, @IR, @BYTECODE, @Probe, @Squirrelled,
@InputVariety, @Obligations and the rest.Our wrapper for an unchecked exception.
Used to drive how the compiler operates.
Marks the specific activity of a compiler phase.
THE definition of which callees are compiler↔runtime PLUMBING rather than part of the EK9
program.
Just expends the standard reporter to use the EK9Comp message prefix.
Evaluates a
ConstraintExpr against a compile-time-constant subject value, returning a
tri-state verdict.PASS = constraint satisfied; FAIL = provably violated; UNKNOWN = cannot determine statically.
Is the value of an expression KNOWN WHEN THE PROGRAM IS COMPILED - that is, made only from text written in the
source? Used by
UrlTextKnownAtCompileTimeOrError (E08275, decision U3 of
docs/architecture/EK9_URL_TYPE_DESIGN.md §0).Designed to give a broad indication of complexity, this is not true pure Cyclometric Complexity.
One popped region: its total complexity, and how much of that came from expressions.
To be used in EK9 source code to assert that a specific class or function has a particular level of complexity.
Checks if there are any directives that relate to complexity in the parsed module.
Creates the appropriate IR Construct for a component declaration.
Detects tautological and contradictory compound conditions using range algebra (E08086/E08087).
THE E11068 repair - a String built from three or more
+ parts - for every editing tool.The rewritten text and one note per rewrite;
notes empty means nothing moved.You may think why this mapping.
THE shared conceptual-to-concrete type replacement - use this, do not re-derive a variant.
Finds all concrete (non-abstract) subtypes of a given abstract aggregate type.
Sets
CONCURRENT_ENTRY_POINT = "TRUE" squirrelled data on function/method symbols
passed as the handler argument to stdlib thread-spawning calls
(TCP.accept, Signals.register).Propagates the
CONCURRENT_ENTRY_POINT = "TRUE" squirrelled marker transitively
along the call graph (Step 6b, slice 1).Record to group conditional evaluation instructions with the resulting condition name.
Result of condition and body generation: the condition case details
plus any post-loop instructions from stages like JOIN.
Record representing a single condition case within a CONTROL_FLOW_CHAIN.
Result of evaluating a condition expression (with optional guard variables).
Result of condition evaluation with primitive boolean extraction.
Result of evaluating a condition against abstract values.
Designed to encapsulate the fact that two token are in conflict for a Symbol.
Detects confusingly similar variable, parameter, and field names within the same scope.
Checks that either all parameters are named when making calls, or none are named at all.
Detects arithmetic expressions that always produce a constant result (E08083).
Detects coalescing expressions whose result is predetermined (E08094).
Detects comparisons where both operands are literals (E08082).
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.
Creates the appropriate IR Construct for a constant declaration.
Checks constant organization within a multi-file module and emits errors if constants are scattered.
Generates a per-module
_Constants JVM class from constant IRConstructs.A very simple type that holds a single distinct value.
Represents a variable known to hold a specific constant value.
THE recovery of the base type a CONSTRAINED type narrows — call this, do not re-derive it.
A constrained-type construction whose argument value is KNOWN at compile time and provably violates
the constraint is an error (E08260), not a runtime Panic.
THE shared resolver for a constrained-type construction site — a constructor call whose constructed
type is a
CLASS_CONSTRAINED aggregate carrying a constraint, together with its single
base-type argument symbol.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.Creates the appropriate IR Construct for a constrained type declaration.
THE place a constrained type (
Age as Integer constrain as ..., or a plain alias Coord as Point)
gets its base's constructors, methods and operators cloned onto it - in TYPE_HIERARCHY_CHECKS.A serializable model of a constrained-type constraint, captured in phase 3 and stored on the
constrained
AggregateSymbol so later phases (and module-cache reloads) can evaluate it
without the original parse tree.A boolean combination of two constraints.
A leaf: the implicit subject value compared against a literal via
operator
(default ==; != normalised to <>, matching phase 3 / IR lowering).THE shared reading of a constraint's literals as
magnitude + suffix — use this, do not
re-derive it.Decides whether a
constrain as expression can be satisfied by ANY value of its base type —
a declaration-site check, needing nothing but the constraint and the base.Immutable constraint state mapping variables to their abstract values.
Finds values a constrained type can actually hold, by PROBING the constraint rather than reading it —
the recovery path for when every value we knew how to guess turned out to be inadmissible.
THE shared fold of a
constrain as expression into the inclusive numeric window
[lo,hi] it narrows to — call this, do not re-derive it.THE display name of a construct - the name a person reads for it at RUN TIME (F2, Steve 2026-10-08, Contract 21 in
EK9_BACKEND_IR_CONTRACTS.md).The calls that ALWAYS run when a callable runs, collected for FE77's construction-recursion check (E08263) by
the phase-5 call-graph collector, in the same walk that builds the call graph.
A call to a resolved function, method, operator or constructor.
A constructor running its type's property initialisers (
_i_init).One always-run call.
What an always-run call reaches.
T() inside a generic - a construction of whatever type each parameterisation substitutes for
T.FE77: construction that can never complete (E08263).
THE steps a constructor of an aggregate takes before its own body - use this wherever those steps are generated
or modelled, so the generated code and the phase-5 call graph cannot disagree about what construction runs.
ONE file mapping every generated construct to a hash of the IR it was generated from.
THE resolver of phase-5 quality metrics for one operation, for every IR generator that registers a
function entry with
CoverageProbePlacer.The per-construct obligation rollup accumulated during the phase-5 walk of one callable body, then
squirrelled as
OBLIGATIONS_TOTAL/DISCHARGED/UNDISCHARGED at construct exit
(docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §2.1/§2.4).Checks that a specific constructor can be called on a particular type of Aggregate.
THE constructor call: every source call that constructs an object is lowered here, and nowhere else.
Walk 0 of PRE_IR_CHECKS — the "all-constructors initialise the field" pre-pass.
Extracts collection/container state information from constructor calls and literal expressions.
Inside a constructor body, 'this' must not be passed as an argument to any NON-PURE call.
Where generated bytecode goes, and where it is read back from.
The per-construct statement budget and human-readable construct label, keyed off the symbol kind.
Resolves the single nominal super type a construct extends, so backends can read it mechanically
from the IR (
IRConstruct.getSuperType()) rather than each re-deriving it from the symbol.A given construct from a specific source should be output to the targetFile.
THE single enumeration of the type references a construct makes through its signature —
super (
extends), traits (implements), field types (composes), method /
function parameter and return types (references), and closed-over captured-variable types
(captures).One signature-level type reference: the relationship
kind and the (raw) referenced type.The result of running the Symbolic/Contract engine (
SymbolicEngine) over one construct
(docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §3/§4.4/§6).A concrete input that violates an obligation — the witness a developer can paste into a test.
A branch proven dead (unreachable for every input) by a contradiction in its path condition.
An obligation the engine proved cannot fail within the bounded model — the green
✓ entry.Collects
CONTAINER_UNWRAP obligations from an object-access chain for the census — one per
Optional.get / Result.ok/error / Iterator.next call, discharged by
GUARD when the access is safe.Checks for the containing construct type and whether it is marked as abstract or not.
Main dispatcher for CONTROL_FLOW_CHAIN bytecode generation.
Record containing all information needed to create a CONTROL_FLOW_CHAIN instruction.
Unified IR generator for EK9 control flow operators using CONTROL_FLOW_CHAIN.
Unified IR instruction for all EK9 control flow constructs.
Checks that an expression used as a control (if/else if, while, do/while, a ternary) is a condition: a Boolean,
or a type that promotes to one with '#^'.
EK9 switch/try control type symbol - this can effectively return a value if it is configured
with returning part.
THE copy constructor of a type: a PUBLIC constructor taking exactly one argument of EXACTLY that type -
Step(Step).Generates synthetic IR for the _copy (:=:) operator.
Compiler self-verification directive (NOT an end-user feature) asserting that the Layer-2 symbolic
engine found a specific witnessing input for a construct
(docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §4).
Checks any
@Counterexample directives in the parsed module against the squirrelled Layer-2
witnesses (docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §4).Tracks efferent coupling (Ce) - the number of external types a construct depends on.
Used for checking covariance based on a variable.
Emits the covariant-return bridges an operation's IR asks for (
OperationInstr.getBridgeReturnTypes(),
front-end rationalisation N07).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".
Resolves the user-facing display name for a function/method symbol used in
coverage and quality reports.
Specialized ASM generator for CoverageFinalizeInstr processing.
Specialized IR instruction for coverage finalization (COVERAGE_FINALIZE).
Represents coverage information for a single function/method.
Coverage tracking modes that control how probe hits are recorded.
Represents complete coverage metadata for a compiled module.
Specialized ASM generator for CoverageProbeInstr processing.
Represents details about a single coverage probe placed in the IR.
Specialized IR instruction for coverage probe recording (COVERAGE_PROBE).
Places coverage probes at control flow points during IR generation.
Enumeration of coverage probe types placed at control flow points.
Emits the profiling exit handler that wraps profiled method bodies.
Specialized IR instruction for coverage module registration (COVERAGE_REGISTER).
THE registry of "dangerous values" per obligation kind for the Symbolic/Contract engine — the single
place that answers which concrete base-domain values would violate this obligation.
A synthetic call-graph edge representing thread-boundary-crossing dispatch
— passing a function as the handler argument to
TCP.accept,
Signals.register, or as a stage in cat ... | async.THE per-type owner constant of the property-cycle guard (Contract 13 in
EK9_BACKEND_IR_CONTRACTS.md) -
use this, never a String literal built per call.Validates that a module does not contain data clumps (E11053).
Tracks function/method/constructor parameter signatures for data clump detection (E11053).
An immutable (type, name) pair from a parameter, ordered for deterministic comparison.
One callable's parameter signature for data clump analysis.
Walk 3 of phase 5: dedicated AST walk for the data-race check (slice 1, step 7).
To be used in EK9 source code to assert the DATA-TOUCH verdict for a tracked parameter of the
callable on the next line — does this callable, or anything it calls, mutate the structure, and
does a reference to it escape? (design
docs/tooling/EK9_DATA_TOUCH_ANALYSIS_SPEC.md
§8.5).Full rationale for a single detected deadlock — either
E08252 (nested enter
on different lock identity) or E08253 (cross-thread same lock).Which slice of the generated debug information a
@DEBUG directive asserts against.To be used in EK9 source code to assert that ONE slice of the generated debug information for a
construct matches expectations.
Validates
@DEBUG directives: asserts that ONE slice of the generated debug information for
a construct (a DebugAspect) matches the expected golden.Debug information for IR instructions to enable source mapping and debugging.
Creates the debug information for the symbol provided.
Generates debug information for JVM bytecode.
Useful function that generates the decorated/internal name for generic types that have been
parameterized.
Given a symbol, this check that the type that the symbol has can support the '--' operator.
Record containing default case management information for CONTROL_FLOW_CHAIN constructs.
PRE_IR_CHECKS confirm-or-retract for the BARE
default operator comparison family.The generated copy of a closeable holder is refused (R-A, Steve 2026-10-06, decision D9; E81065).
Test if a symbol is externally implemented.
THE decision of which operator a GENERATED comparison is answered by - call this, do not re-derive it.
THE test of whether a type already has what a
default operator would give it - call this, do not
re-derive it.E01086 - a bare
default operator with something after it in the body.Checks that operators that have been 'defaulted' could actually be implemented.
A
defines <block> line (class, function, program, ...) at any indent but two.Just go through and define the symbols and scopes putting into the ParsedModule against the appropriate context.
After a this(...) call, the properties the delegated-to constructor sets have a value for the rest of the
delegating constructor - and only those.
To be used when checking if a variable Symbol is a function delegate and can accept a set of call arguments.
A Lexer, but one that delegates to the actual lexer that in plugged in.
Generates synthetic IR for trait delegation methods.
Generates synthetic IR for every comparison operator a type's <=> answers: <,
<=, >, >= - and == and <> whenever the type has its own
<=> (Steve, 2026-09-29: a defaulted comparison can never disagree with the type's ordering, so
a == b exactly when (a <=> b) == 0).De-Serializes a byte array back to compilable program.
Reports DI/AOP analysis to stderr when the
-di flag is set.Generates JVM bytecode for DICT_LITERAL IR instructions.
Details for the DICT_LITERAL IR instruction.
A single key-value pair in a dict literal.
Generates IR instructions for dict literal expressions.
IR instruction for dict literal construction with pre-sized allocation.
Creates/Updates an ek9 Dict (Dictionary/Map) of a specific types if the expressions are typed correctly.
Wraps the SHA 256 digest and the resulting byte array into objects,
so we can deal with check objects rather than raw bytes.
A Checksum.
Loads DI analysis guidance messages from individual .txt resource files listed in a manifest.
CONCERN: Direction check evaluation for polymorphic for-range loops.
Parameters for direction check evaluation.
Configuration for for-range loop direction (ascending vs descending).
Provides basic interface for the EK9 internal @ type directives.
Main() @Test - an annotation written after the declaration it marks, Java-and-Kotlin style.THE shared recovery of a symbol's generated
.class bytes for the back-end directive
listeners (@BYTECODE, @DEBUG).Just focuses on creating directives, these are used when testing EK9 source code.
Provides the listeners for directive checks.
THE one-line text of a directive mismatch (Steve, 2026-10-11, lane lang-syntax): which directive, its line, and
what the compiler actually found -
line 6: @Error: FULL_RESOLUTION: NOT_RESOLVED - the compiler found no
error on line 7 [E50230].Extracts the compilation phase or throws an illegal argument exception.
Finds the next line number from where a directive has been used.
Specification of a directive, all the common details used in a range of directives.
Extracts the 'spec' from the free format data in the directive.
Extracts the symbol category or throws an illegal argument exception.
Extracts the symbol name or throws an illegal argument exception.
To be used in EK9 source code, for things like internal tests
or compiler directives, instrumentation, reified type retention etc.
THE shared sink for directive-test
@IR/@IR_PARAMETERISED/@LLVM/@BYTECODE
UPDATE blocks emitted by the directive listeners when a golden mismatches.Shared helpers over an application's dependency-injection registrations, so the several DI checks
and the DI reporter derive the same view of what is registered rather than each re-spelling the
'filter component registrations, map to interface FQN' stream.
Detects discarded return values in bare statement calls (E11050, E11051, E11052, E11055).
Why an obligation is considered discharged (proven safe) by an existing analysis, or
DischargeReason.UNDISCHARGED when no analysis proves it — the discharge-detection order of
docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §2.3.Validates that no reachable type in a dispatcher's hierarchy resolves ambiguously
between two or more handlers at equal cost.
Validates that dispatchers on sealed traits have handlers for all permitted types.
Links a dispatcher entry point to the handlers its dispatch table can route to, so a call that
resolves to the entry point reaches the handler that actually runs.
Reports a dispatcher handler whose parameter type has no concrete form anywhere in the program,
so no value can ever have that runtime type and the handler is dead code that looks live.
THE single source of truth for the handler set of a dispatcher entry point.
THE single source of truth for "what types can actually arrive at this dispatcher parameter".
Validates that dispatcher handler parameter types are reachable from the base dispatch type's
hierarchy.
THE single source of truth for "which handler WINS for this concrete type".
A winning handler and the assignment cost it won at.
Specialized ASM generator for DISPATCH_TABLE instruction.
Details for the DISPATCH_TABLE IR instruction.
A single entry in the dispatch table mapping concrete type(s) to a handler method.
Generates precomputed dispatch tables for dispatcher methods during Phase 7 IR generation.
High-level IR instruction for a precomputed dispatch table.
THE shared "Pass 3" that prepends a DISPATCH_TABLE to every dispatcher operation of an aggregate.
Extracts doc comment text from HIDDEN channel tokens.
E08274 (Steve, 2026-10-08, C1, Q8, Q9): a negation is never applied to a negation -
not not b,
~~b, - -x, not ~b, - ~x, ~ -x and the same PARENTHESISED,
not (not b), ~(~b), -(-x), -(not b), are compile errors.THE E07901 repair - a double-quoted String holding
${ - for every editing tool.The rewritten text and one note per rewrite;
notes empty means nothing moved.A double-quoted String holding
${ is an error (E07901): a double-quoted String is never
interpolated, so "${count} items" prints those characters rather than the count.Specialized generator for EK9 do-while loops.
The evaluated
hasNext() condition of a drain loop: its own scope, the instructions that
compute it, and the primitive-boolean variable holding the answer.Detects when a second 'defines package' block appears in a module
and emits a dedicated error rather than a generic duplicate symbol message.
Resolves the variables to be captured and defines new variable symbols against the appropriate scopes.
Checks that a dynamic class does not used naming when used inside a generic type/function.
Creates the appropriate IR Construct for a dynamic class declaration (anonymous inline class).
THE monomorphisation of a dynamic function or dynamic class declared inside a generic body - use this at every site
that generates or constructs one, never a variant.
Checks if a dynamic function body is needed and provided, and that a body whose super returns a value can
actually return it (not every path throws - E07380, as for a named function; front-end audit FE65).
Creates the appropriate IR Construct for a dynamic function (anonymous closure).
Deals with handling any returning values in a dynamic function.
Dynamic Variables when captured have to either be identifiers in their own right,
but if they are some type of expression, method call, etc.
Classifies a call-graph edge by its threading semantics, per
EK9_CONCURRENCY_MODEL.md §5.2.This class provides an empty implementation of
EK9Listener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
EK9Visitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.Looks for Java classes that have been annotated with the annotations that allow them to be exposed
as 'extern' ek9 components.
Custom ClassWriter that doesn't require loading classes during frame computation.
The main EK9 compiler (HERE FOR COMPILER ENTRY).
THE predicate for "is this EK9 core" - the modules only the compiler bootstrap may define.
Responsibility of dealing with aspects of the ek9 directory structure.
Custom error strategy for EK9 that produces human-readable error messages.
THE single builder of an EK9 executable "fat" jar from a compiled project — extracted so the CLI
(
Ec.repackageTargetArtefact) and the IDE (PipelineRunner.buildForDebug) share ONE
packaging path and cannot drift (they had a private copy in the CLI only, which is why the IDE's
debug build produced no jar).Defines all exit codes used by the EK9 compiler and generated code.
THE marker line EK9 writes FIRST on stderr when EK9 ITSELF fails - the CLI, the compiler, or
the generated
ek9.Main entry point rejecting a program's arguments - e.g.THE source for EK9's word keywords, and for whether a keyword can still be used as a NAME.
Loads the language basics into a Compilable Program.
Original good for python but too pythonesque for EK9 -
needed reworking to remove # comment and tabs for indenting.
Just wraps up the creation of the EK9Lexer from an inputStream.
This interface defines a complete listener for a parse tree produced by
EK9Parser.Shared utility for parsing EK9 literals that the grammar supports
but standard Java parse methods do not handle directly.
THE single source of truth for EK9 literal types — the finite, closed set of
built-in types a literal can denote, and the canonical mapping from a parsed
EK9Parser.LiteralContext to its fully-qualified EK9 type name.THE closed taxonomy of EK9 compiler-generated method kinds carried by the
Ek9MethodKinds
class attribute (C.2), each with its debugger MethodDebugPolicy bitset.The versioned
Ek9MethodKinds class attribute (C.2): a per-method map of
(name, descriptor) -> Ek9MethodKind + MethodDebugPolicy bitset, letting the EK9
debug semantics layer decide step-filtering and frame re-presentation.One per-method record: the method (name, descriptor), the
Ek9MethodKind wire
kindCode, and its MethodDebugPolicy bitset.THE validator for an EK9 module name — use this, do not hand-roll a regex.
Orchestrates the EK9 source code formatting pipeline.
A cut down visitor that just deals with packages at a basic level.
Models a token that we need to create as a synthetic token.
Fixed and Known EK9 types that the compiler needs to know exist.
Used to cache built in types as they are so frequently used.
This interface defines a complete generic visitor for a parse tree produced
by
EK9Parser.Specialized generator for EK9 Elvis coalescing operator (:?).
Error if a construct and a reference conflict with each other.
Error when a reference is made, but it cannot be resolved.
To be called when an unreachable statement is encountered to emit an error.
Detects when a 'defines' block (class, function, trait, etc.) is empty
and emits a clear semantic error rather than letting it fail as a generic parse error.
Detects @Test programs that have no validation - neither assertions nor expected output files.
A single
MutexLock.enter(...) or MutexLock.tryEnter(...) call site
observed during analysis.Distinguishes the two variants of MutexLock acquisition: blocking
enter() vs non-blocking tryEnter().Generates synthetic IR for the enum _cmp (<=>) operator.
Generates synthetic IR for enum constructors (copy and String).
Generates synthetic IR for the enum _eq (==) operator.
Creates/Updates an enumerated type adding methods as appropriate.
Creates the appropriate IR Construct for an enumeration declaration.
Generates synthetic IR for the enum #< (first) and #> (last) operators.
Generates synthetic IR for the enum _hashcode (#?) operator.
Generates synthetic IR for the enum ++ (_inc) and -- (_dec) operators.
Generates synthetic IR for the enum _isSet (?) operator.
Generates the anonymous iterator class for enum iteration.
Generates synthetic IR for the enum iterator() method.
Specialized ASM generator for ENUM_ITERATOR_IMPL instruction.
Details for the ENUM_ITERATOR_IMPL IR instruction.
High-level IR instruction for generating enum iterator implementation.
Generates synthetic IR for the enum _json ($$) operator.
Generates synthetic IR for the enum _string ($) and _promote (#^) operators.
Generates synthetic IR for enum operators that accept a String parameter.
THE shared "is this an enumeration type (base or constrained)?" test for phase-7 IR generation — use
this rather than re-deriving a genus check per generator.
Generates synthetic IR for the _eq (==) operator.
Emits the JVM
equals(Object) / hashCode() methods for generated user aggregates that
declare value semantics, bridging them to the EK9 == (_eq) and #?
(_hashcode) operators via org.ek9.lang.HashSupport.Derives a type's
TypeVariety — its value-class count + confidence — for the
input-variation denominator (design §11.1).To be used in EK9 source code to assert that an error will be created.
Checks if there are any directives that relate to errors in the parsed module and tallies those up
with any errors held for the phase of compilation.
THE text-level reading of the
@Error: PHASE: CLASSIFICATION directive lines in an example SOURCE - for the
readers that show an error example to a person or a model, not for the compiler (which parses directives with the
grammar and checks them with ErrorDirectiveListener).THE loader of the error catalogue's examples (
errorExamples/<CODE>/, site-examples spec §6, decisions D2
and D11): for each error code a bad.ek9 that fails with exactly that code (its @Error directive is
kept in the source, where the gate reads it) and one or more good*.ek9 that fix it.One source of the catalogue.
One example of a code: a single file (
bad.ek9, good_open.ek9) or a directory (bad/,
good/) whose files compile together as one workspace.We need an error listener for the lexing parsing and also our own tree
visiting.
Fine detail of the error.
The type of the error.
The details of an error, position, etc.
What is the semantic nature of the error.
Escape analysis metadata for IR optimisation phase.
Escape level classification.
Lifetime scope classification.
Memory management for values that are ESCAPING their current scope.
Record containing evaluation variable management information for CONTROL_FLOW_CHAIN constructs.
Just wraps any exceptions in a runtime CompilerException.
Just catches exceptions and ignores them.
Checks that the symbol passed has a type and that the type is compatible with an EK9 Exception.
Detects call chains deeper than one level (E11069).
Checks for excessive type traversal in method chains (Law of Demeter).
Single source of truth for directory names that should be excluded from
workspace file walks, watch registrations, and glob-based source discovery.
Detects excluded keywords and emits clear educational error messages.
Represents a variable known to hold any value except a specific constant.
An exception that when caught at the very outer edge of the compiler will cause the application
to exit with a specific error code.
THE check for whether a
@Test program carries expected-output companion files — the
validation mechanism EK9 accepts INSTEAD of assertions.Tracks complexity of coalescing expression trees with depth-based multiplier.
Checks that an expression is a condition - a Boolean, or a type that promotes to one with '#^'
(
ControlIsBooleanOrError.isCondition(ISymbol, ISymbol), THE rule for every condition) - emitting
ONLY_COMPATIBLE_WITH_BOOLEAN otherwise.Ensures that 'expression' is now resolved and 'typed' or a not resolved error.
Generates ARC-safe assignment instructions for expression form control flow branches.
This listener just deals with expressions and the types that result from expressions.
While we don't add these in the scoped structures when compiling.
Creates IR instructions for expressions.
Useful in expressions to contain the left and right hand symbols.
A simple record that can be used when processing expressions.
Test if a symbol is externally implemented.
Facade that combines ANTLR parsing with the ExternSourceVisitor to generate
extern representations of EK9 source files.
Visitor that walks an EK9 parse tree and emits an extern source representation.
THE test for "is this symbol provided from OUTSIDE this workspace's EK9 source?" — a built-in, or any
member of an
extern construct.Extracts the literal an expression resolves to, or null if it is not a (possibly negated) literal.
Represents a field/property declaration in an EK9 construct (class, record, component, etc.).
Classifies fields in an aggregate as service-type (abstract/interface) or data-type (concrete).
Result of field classification for an aggregate.
Creates the appropriate Field object for the symbol and adds it to the construct.
THE rule of Q-COMPONENT-? (Steve, 2026-10-07): a type with NO fields, counting inherited ones, is set whenever it
is present.
Gives every class, component and service with no fields, counting inherited ones, its synthesised '?'
(
FieldlessIsSet, Q-COMPONENT-?, Steve 2026-10-07), after every source has been through
EXPLICIT_TYPE_SYMBOL_DEFINITION: supers are linked only then.Generates synthetic IR for the _fieldSetStatus() method.
Creates the synthetic
_fieldSetStatus method symbol used as an IR carrier.Accepts a ICanCaptureVariables (either a function or an aggregate).
Writes each generated class to its own file - the behaviour every jvm writer had inline.
Designed to abstract out all file handling for the compiler.
File-level metrics including ARI readability.
Gate the flowing element on a predicate:
filter continues downstream when the predicate is
true, reject when it is false.Generate a nested iterator loop for a flatten stage.
Detects conditions that are always true or always false based on data flow analysis (E08086/E08087).
Maps compiler error codes to their corresponding path in forAI.json.
Spellings carried over from other languages that EK9 writes one way and parses no other way.
Generates IR for for-in loops and expressions: for item in collection.
Deals with the for loop for phase 3, which is basically working out the type of the variable being iterated over
and ensuring that the expression is something that can be iterated over.
Does checks on both for loops and for range in terms of pre-flow and expressions (for loop).
Result of a formatting operation.
The state of the formatter after processing.
Predicate to determine if an expression is a Boolean logical operator (and/or)
with Boolean type operands.
When looking to calculate complexity of methods/functions it is important to
work out if parts of an expression are in some way conditional.
Generates IR for for-range loops and expressions using FOR_RANGE_POLYMORPHIC instruction.
Pulls the type from the 'range' into the loop variable, so it is correctly typed or emits an error.
JVM bytecode generator for FOR_RANGE_POLYMORPHIC IR instruction.
Specialized IR instruction for EK9 polymorphic for-range loops.
Dispatch case for ascending loops (direction < 0).
An extra condition evaluated at the top of every iteration, before the range test:
evaluation is
run, then the loop ends unless primitive is true.Dispatch case for descending loops (direction > 0).
Container for all three dispatch cases in a for-range loop.
Dispatch case for equal loops (direction == 0).
Non-executable metadata about the loop structure.
Scope identifiers for different parts of the loop structure.
Ensures that a for loop/for range statement/expression is used correctly in or out of an expression.
Deals with checking the 'for' statement/expression.
Coordinates for-statement IR generation by delegating to specialized generators.
Checks the for structure via the code analysers.
EK9 'for' type symbol - we need a scope because we declare a new variable as the loop variable.
Test if a (generic base function) symbol is forward-target dispatched: the closed set of extern
abstract function types a built-in invokes through the erased base
_call(Any...) path with
the argument held RAW — MutexKey (via MutexLock.enter) and Comparator (via
PriorityQueue.withComparator/Ek9Sort).A Boolean LEFT operand for a short-circuit AND: a FRESH SSA temp (loaded from an alloca-backed var)
plus its primitive.
Supplies just the front end of the compiler.
THE split of an example source into its
<?- ... -?> JSON front matter and its EK9 body - the one reader
of that format.Supplies all the phases for a full compilation from end to end.
Takes a fully qualified ek9 name and produces a name that is suitable for jvm use.
Takes a fully qualified ek9 name and produces a name that is suitable for llvm use.
Takes a fully qualified ek9 name and produces a name that is suitable for jvm internal use.
Takes a fully qualified ek9 name and produces a name that is suitable for llvm internal use.
Unified function call processor using CallDetailsBuilder for method resolution and promotion.
To be used when checking if a function can accept a set of call arguments.
Check is the data passed in enabled a delegate function to be resolved and if so return that Function.
Creates the appropriate IR Construct for a standalone function.
Generates synthetic IR for the function _isSet (?) operator.
Per-function summary of lock activity.
Code quality metrics for a single function/method.
Typically checks any returning values to see if they have now been initialised on a function.
Checks that the function correctly overrides the signature if it has a super.
Emits the function-singleton pattern: every named EK9 function has exactly one instance.
The inter-procedural summary of a callable (docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md
§3.4) — the facts about it a caller needs to reason across the call boundary without
re-analysing its whole body.
A single
require precondition: param OP literal, keyed to the parameter's position so
a call site can map it onto the matching argument.Scope for functions that are part of a module.
Search just for a matching function by name.
Provides fuzzy symbol search functionality using Levenshtein distance.
THE single source of truth for the gated-type → required-capability mapping and
its coverage rules.
Used to see if it is possible to resolve types, both simple and parametric.
THE fields a generated operator (
?, $, $$, ==, <=>, #?,
_fieldSetStatus) walks for one aggregate: its OWN properties, then the variables a dynamic class
captured (each becomes a field).Struct-style data holder for all Phase 7 IR generators and helpers.
THE test of whether a parameterised type made inside a generic's body is a dependent (generic-in-generic)
reference of that generic: it is parameterised, still generic in nature, and every bare type parameter it names
(at any depth:
List of List of T) is one of the generic's OWN type parameters.A generic type's inferring constructor must take exactly its type parameters, in the same order - that is
what lets 'Box(21)' infer 'Box of Integer'.
Used to model the scenario where a generic type has another dependent generic type used within it.
Widens a GENERIC construct's input-variety denominator to span the types it is actually
parameterised with (design D11/W5b).
THE mapping from a member of a MONOMORPHISED parameterised type back to the member of the GENERIC it
was substituted from.
THE shared decomposition of a (possibly parameterised) type symbol — use this; do not re-derive
the
instanceof PossibleGenericSymbol + getGenericType()/getTypeParameterOrArguments()
dance inline.To be used in EK9 source code to assert that a type can or cannot be resolved.
Checks if there are any directives that relate to @Genus in the parsed module and checks the
resolution through the symbol and its genus.
Attempts to locate an Trait by name.
Extracts the EXISTING variable a pre-flow assigns: the target of a blind assignment (
v := e()) or an
assign-if-unset (v :=? e()).Given a 'type' (the IAggregateSymbol passed in), see it would be possible to
iterator over it with some other type.
Used for file path matching GLOB not regex.
THE reader of guard CO-OCCURRENCE — which of a callable's parameters, or which FIELDS of one
parameter, the code tests together.
Parameters, or fields of one parameter, that a condition (and its enclosing conditions) test
together, with the provenance needed to re-check it later.
Evaluates conditions with optional guard variables for all control flow constructs.
Result of condition evaluation containing both instructions and primitive condition.
Orchestrates the common guard + scope + return variable pattern shared by
control flow generators (while, do-while, for-range, for-in, try-catch).
Context record passed to core generator lambdas.
Record containing guard variable management information for CONTROL_FLOW_CHAIN constructs.
E08270 (Steve, 2026-10-07, Q4): reading a
<- guard's variable in a LATER else if / else
block of the same if chain, before anything assigns it there.Predicate to check if an aggregate type has a close() operator defined.
Generates synthetic IR for the _hashcode (#?) operator.
Given a symbol, this check that the type that the symbol has can support the '#?' operator.
THE shared test for "is this type orderable?" - does it have a REAL
<=> operator, one it
declares itself or inherits from a real (user) super, as opposed to only the degenerate Any._cmp
that EVERY type inherits and which is not value ordering.THE shared test for "does this type have a REAL
<operator>?" - one it declares itself or
inherits from a real (user) super OR from a trait (its own, a super's, or a trait's trait), as opposed to only the degenerate Any.<operator> that
EVERY type inherits (e.g.Generate comparison and conditional wrapper for a head or skipping stage.
Checks the possible operation variable, literal or function for suitability for use with
'head', 'tail' and 'skip'.
Converts bytes to Hexadecimal and back.
Checks HTTP Access for service operations because some require HTTP_SOURCE, but others do not support it.
Interface for an aggregate, typically a class or something like that.
Really a Marker interface for generic classes and generic functions.
Interface for dynamic functions and classes so that dynamic variables can be captured.
Given an identifier, this consumer checks if it is a property of some aggregate.
Deals with the checking and setting initialised of the identifier.
Used for pure identifier resolution and recording.
THE check of a READ of a local or returning variable that may still be uninitialised (E08020): every grammar
position that loads a variable's value hands its read node here - this is the one consumer, do not write another.
Ensures that 'identifierReference' is now resolved and hangs together and is 'typed' or emit "not resolved" error.
Classifies where a lock-identity descriptor originates.
Does basic checks on the if condition to see if a Result/Optional access has been made safe.
Specialized generator for EK9 if/else statements.
Generates IR for if/else statements using CONTROL_FLOW_CHAIN.
Checks the IfStatement is valid or emits errors.
Deals with checking if all paths through if/else/else-if/else result in variables meeting criteria.
Interface to abstract FunctionSymbol away as concrete implementation.
Interface for main entry point visitors that generate target-specific main entry points
for EK9 programs (e.g., main methods for JVM, main functions for native binaries).
Used by functions and methods as they may return a symbol (variable).
Typically used with programs.
To be used in EK9 source code to assert that a type can or cannot be resolved as extending a type or function.
Checks if there are any directives that relate to @Implements in the parsed module and checks the
resolution through the symbol and its hierarchy.
Used to assist with determining the naming of symbol names.
A construction call that reaches a constructor which leaves properties without a value (E08264).
CONCERN: Loop counter increment/decrement.
Parameters for increment/decrement evaluation.
Given a symbol, this check that the type that the symbol has can support the '++' operator.
A stream whose source the compiler can PROVE infinite may not reach a stage that waits for the end of the stream
(E10050) - decision 15(a), phase 1.
Calculates the Depth of Inheritance Tree (DIT) for aggregate symbols.
THE rule for a sub-type that adds handlers to a dispatcher it inherits (front-end rationalisation D2, Steve
2026-10-02: "we have little choice but to do 'A'").
Gives each sub-type that adds a handler to an INHERITED dispatcher its synthesised entry point
(
InheritedDispatcher, front-end rationalisation D2), after every source has been through
EXPLICIT_TYPE_SYMBOL_DEFINITION: supers are linked and parameter types known only then.The body of a synthesised inherited-dispatcher entry point (front-end rationalisation D2): call the entry point it
overrides on the super, directly (a super call, never virtual), and return what that returns.
C2 fix 2 (Steve, 2026-10-08): a type that ADDS fields must declare its own
$, $$ and :=:
when it would otherwise INHERIT one (E07238), as E07235 already requires of ?.THE nearest operator ABOVE a type: the declaration a type would inherit, found by walking its super CLASS chain
(never its traits) and stopping at the first level that declares it.
Uses various components to load the Ek9 builtin types into a CompilableProgram.
An injected component is always set, so any check that it is set is always true - dead code that reads as
though the injection might not arrive (E08266).
Tracks injection counts within functions/methods/operators.
Detects circular dependencies in component injection chains per application (E08190).
THE components of an application that sit on a circular injection chain (E08190), as
InjectionCycleOrError
found them - and THE rule that E08190 suppresses E08200 for them (Steve, 2026-10-11): in a cycle no registration
order works, so "reorder registrations" is advice that cannot be followed.Validates ordering in application blocks (E08200).
Validates DI injection design quality across a construct's methods (E11041).
Parallel to
InjectionCounter, but tracks the DISTINCT injected component TYPE
(fully-qualified names) per scope rather than just the site count.Holds generated classes in memory instead of writing a file per construct.
Models the concept of an Intermediate Representation construct.
Used for double dispatch when visiting nodes.
One dimension captured by an
INPUT_CLASS_PROBE (design
EK9_INPUT_VARIATION_METRIC_DESIGN.md §5) — either a declared argument or the receiver as the
implicit p0 (§4.5).Specialised ASM generator for
InputClassProbeInstr — the input-variation numerator probe
(design EK9_INPUT_VARIATION_METRIC_DESIGN.md §5).Specialised IR instruction for the input-variation numerator (INPUT_CLASS_PROBE).
What this instruction is: an entry probe, or one edge of a §5.3 assert window.
The input-variation figures for one public construct, computed over its flattened leaf
dimensions (records decompose to fields; receiver-p0 included) — design §4.1 / §4.6.
Computes a public construct's input-variation
InputVarietyDenominator — the pairwise
opportunity space of its parameters (design §4.1).Records the input-variation figures — the 1-wise FLOOR (headline) and the pairwise DENOMINATOR
(ceiling) plus the per-leaf confidence — on each callable (method / function / operator),
squirrelled for the metrics / MCP surface next to
COMPLEXITY.To be used in EK9 source code to assert that a specific class, function or method has a
particular input-variation DENOMINATOR — the pairwise opportunity space its signature admits
(design
EK9_INPUT_VARIATION_METRIC_DESIGN.md §4.1, §11.5).Checks if there are any directives that relate to the input-variation denominator in the parsed
module, and validates them against the value the compiler squirrelled in phase 5.
True if the given parse node sits anywhere inside a 'require' or 'assert' statement.
Discriminator for the
CastInstr.instanceOf(String, String, String, InstanceOfKind, DebugInfo) IR instruction.Checks that variable only and variable declarations have symbols that have been referenced.
THE single-source-of-truth for registering per-module coverage AND profiling metadata into the
runtime singletons
parent-side — i.e.THE way to make the compiler fail INTERNALLY on demand (Steve, 2026-10-08): with
-Dek9.internalError.at=<PHASE> on the compiling JVM (a CompilationPhase name, e.g.Holds the details for creating and internal 'decorated name' for a generic type that has been
parameterised.
Given some sort of generic type a function or a type with a set of 'type parameters',
create a unique internal name for that combination.
Generates IR instructions for interpolated string expressions.
Phase C.3 of slice-2 deadlock detection — Phase 5 lock-order-cycle model.
Phase C.2 of slice-2 deadlock detection: compute per-function
mayEnter
summaries by composing direct enters with reachable enters via the call graph
and CrossThreadEdge list.A stack of integer counters, one per nested function/method/operator scope, accumulated during AST
traversal.
Error when the definition of an enumerated values could be invalid.
MULTI THREADED over sources.
Rather than smatter the Java code with 'stringy' constants for the IR, they are defined here.
In EK9 every construct becomes one of these nodes.
Static factory for creating complete tree of IR generators ONCE per construct.
Centralized context for IR generation within a single executable scope.
Deals with visiting all parts of the EK9 structure in a module (compilable source).
To be used in EK9 source code to check that the IR generated matches what is expected.
Checks if there are any directives that relate to @IR in the parsed module and checks the
resolution through the symbol and checks the IR that was generated.
THE normalisation applied to generated
@IR / @IR_PARAMETERISED golden content
before it is compared against - or emitted into - a directive body.Enumeration of different IR generation frame types.
Central state management for IR generation, following the proven SymbolsAndScopes pattern.
Stack-based scope, debug, and context management for IR generation.
MULTI THREADED
All symbols resolve and so should be able to create an intermediate representation.
Base class for all IR instructions in the EK9 intermediate representation.
Converts the single IRInstr supplied by the supplier into a List with one element in.
Stateful instruction builder that uses the IR generation context automatically.
Represents the Intermediate Representation of the EK9 code for a particular EK9 module.
Enumeration of all IR opcodes used in the EK9 intermediate representation.
SINGLE THREADED.
To be used in EK9 source code to check that the IR generated for parameterized types
(generic type wrappers) matches what is expected.
Checks if there are any directives that relate to @IR_PARAMETERISED in the parsed module
and validates the generated IR for parameterized type wrappers.
Represents a single frame on the IR generation stack.
Checks if a type has the $ 'toString' method or a 'promotion' #^ to a String method.
Concept of a scope where functions, methods and variables can be declared.
The main type of scope in use a block is just like a set of instruction inside an if block
or a while block whereas a non-block is as the whole class/function/component level.
For symbols that are both a pure symbol but can also define a scope.
Predicate to check if a source file path represents a development source.
THE "fresh value" predicate: true iff an expression evaluates to a NEW object - one nothing else holds a
reference to.
Predicate to determine if a symbol is a function delegate.
Predicate that returns true iff the symbol IS the
org.ek9.lang::MutexKey
generic function itself, or a parameterised form of it (e.g.Predicate that returns true iff the call's resolved target is a constructor of
MutexLock (or a parameterised MutexLock of T).Predicate that returns true iff the symbol IS the
org.ek9.lang::MutexLock
generic type itself, or a parameterised form of it (e.g.Given an aggregate and a symbol, this predicate checks if the symbol is a property/field of that aggregate.
Creates CallDetails for _isSet() method invocation.
Creates evaluation instructions for _isSet() method calls.
Generates synthetic IR for the _isSet (?) operator using AND (flattened-aggregate) semantics.
Checks that aggregates with properties/fields define their own '?' (isSet) operator.
Given a symbol, this check that the type that the symbol has can support the '?' operation.
Predicate that returns true iff the call's resolved target is a stdlib method
which invokes its function/handler argument on a different thread than the
caller.
Represents the concept of what functionality a Symbol should have.
Defines helpful and require methods to assist in the definition of the nature of a symbol.
Helper record for iterator setup results.
The internal model of a parse token - typically created.
Used in various ways to hold a token from the parse, so we can reference back to source code.
THE indentation-aware slicer for
javap -v -p -l output — the shared helper that both
BytecodeNormalizer (strip a section) and the @DEBUG directive (keep a section) build
on.Generate join (left-fold reduction) wrapper for a join stage.
For when we just need to read ek9 files and pull out bits and bobs
rather than actually compiling.
Why the last
JustParser.readSourceFile(File, Ek9SourceVisitor) returned false - so a caller says the right thing.Converts EK9 type names to JVM type descriptors.
Shared JVM opcode selection for the bytecode generators: primitive/reference local-variable
load/store opcodes and optimal integer-constant loading.
Shared construction of JVM method/constructor descriptors from already-JVM-internal type names.
Target for a Java virtual machine.
JVM internal type names and descriptors that the compiler uses when generating bytecode.
Specialized IR instruction for control flow labels (LABEL).
Specialized ASM generator for LabelInstr processing.
THE layout repairs - the faults in how a source is laid out rather than what it says, each with exactly one
reading and none able to change which code runs.
The repaired text and one note per repair; notes empty means nothing changed.
THE shared knowledge of EK9's LAYOUT tokens — INDENT / DEDENT / NL / EOF — and the one correction
every consumer of a parse-rule's END position needs because of them.
One field step in a
LeafPath — everything a backend needs to load that field from the value
on the stack, with no further symbol lookup.One scalar leaf dimension of a callable's input space, together with the field path walked to
reach it from the declared parameter (design EK9_INPUT_VARIATION_METRIC_DESIGN.md §4.5/§4.6).
Due to way Antlr does is class generation we need to make an interface to decouple to
enable debugging and alternatives.
Checks the left hand side and the right hand side for assignment compatibility.
Access the Symbol for the lhs of the preflow statement.
Compares two multi-line strings line-by-line for equality.
Pass 4 of the EK9 source formatter: Line Splitting.
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.Generates JVM bytecode for LIST_LITERAL IR instructions.
Details for the LIST_LITERAL IR instruction.
Generates IR instructions for list literal expressions.
IR instruction for list literal construction with pre-sized allocation.
Creates/Updates an ek9 list of a specific type if the expressions are typed correctly.
Generates JVM bytecode for EK9 literal values.
Extracts constant values from EK9 AST literal nodes.
Deals with generating the correct IR Instructions for processing any form of literal.
IR instruction for loading literal/constant values.
Specialized ASM generator for LiteralInstr processing.
Parameters for literal value loading.
A simple record that can be used when processing literals.
THE declared (target) type of a List or Dict literal - use it, do not re-derive the walk.
Checks for C++ target architecture.
Abstract Target for LLVM code output, can be for Go or C++ (with different Ek9 std library and
memory management.
Authoritative validator for EK9 locale identifiers used in
defines text for "<locale>"
blocks.Used in many ways via composition.
Metadata for a local variable needed for LocalVariableTable generation.
Generates deterministic internal names using SHA-256 hashing.
THE location of a symbol for a message: "on line 6 in 'filename.ek9'".
Extracts a string for the form "on line 6 in 'filename.ek9'".
Single source of truth for slice-2 deadlock analysis results.
Walk 4 of phase 5: data-collection walk for slice-2 deadlock detection
(Phase B.1 — intra-function scope).
Outbound-encapsulation check: data inside a
MutexLock must be purely contained —
the lock holds the only reference to its protected payload.Catalogue entry for a single lock identity tracked by the slice-2 deadlock analysis.
Tracks which physical
MutexLock object(s) a variable may currently
refer to at a given program point.How much the compiler's one program lock (
SharedThreadContext) is used and waited for - the measure of
what serialises the front end.One reading of the counters.
Workspace-wide lock-precedence graph used by Phase 5 cycle detection.
One observed nested-enter relationship between two distinct lock identities.
Wrapper for logging.
Defines the necessary structure for processing logical operations line AND/OR/XOR.
Specialized generator for EK9 logical operations (AND, OR) with short-circuit evaluation.
Record to group logical operation context information.
IR instruction for logical operations (AND/OR) with short-circuit capability.
The type of logical operation.
Detects logical tautologies and contradictions (E08085).
Encapsulates all data needed for generating a FOR_RANGE loop case (ascending or descending).
Shared helper for guard variable evaluation in control flow constructs.
Validates that a module does not contain repeated magic literals (E11065).
Detects bare literals used as operands in comparison, relational, matching,
and range expressions (E11064).
Tracks literal occurrences across files for repeated magic literal detection (E11065).
One recorded occurrence of a literal.
Generates the unified ek9.Main class that provides a standard Java entry point
for executing EK9 programs with automatic discovery and reflection-based invocation.
Contains all the information needed for target-specific visitors to generate main entry points.
JVM-specific main entry visitor that generates ek9.Main class with Java bytecode.
LLVM/C++ main entry visitor for generating native binary main entry points.
Locates the appropriate main entry visitor for the appropriate target architecture.
A bit of a catch 22, need to issue errors and the like when traversing an identifier in
some circumstances.
CONCERN: Literal loading with memory management.
Returns the appropriate operator text symbol for the expression.
Generate function call and pipeline item reassignment for a map stage.
Sets the
CONCURRENT_ENTRY_POINT = "TRUE" squirrelled marker on every
non-constructor, non-operator, concrete method of the supplied aggregate.There are times when it is necessary to compare a range of symbols to see
which is the best match.
An initial stuff for match results.
THE tolerant reader/writer for a symbol's measured
CommonValues.COMPLEXITY, for consumers that
treat "not measured" as zero rather than as an error.Specialized IR instruction for memory operations (LOAD, STORE, ALLOCA, REFERENCE).
Specialized ASM generator for MemoryInstr processing.
Loads alternative error messages and DI guidance from a zip file.
Single source of truth for which access modifier is legal on a method / operator / constructor
within a given aggregate genus.
Useful when attempting to traverse up stacks to find both the method and its parent aggregate.
Shared context for a method that must be coordinated across all generators.
THE debugger step-filter / frame-decoder policy bits carried per generated method by the
Ek9MethodKinds class attribute (C.2).Derives an
Ek9MethodKind for a compiler-generated method emitted through the IR funnel
(generateGeneralMethodFromIR / generateGeneralConstructorFromIR in
AsmStructureCreator).The debug-time reader of one class's
Ek9MethodKinds attribute (C.2): parses the class bytes
into a (method name + descriptor) -> Ek9MethodKind / MethodDebugPolicy
lookup.Per-class accumulator of
Ek9MethodKind entries, populated as methods are emitted and
turned into the Ek9MethodKinds class attribute just before visitEnd() (mirroring
how the SMAP is collected then attached).Just checks that named operator methods:
mod, rem, abs, sqrt, close, contains, matches, empty, length
are not being used as just method names.
To be used when resolving a method by name and call arguments within a specific scope (an aggregate).
Typically checks any returning values to see if they have now been initialised on a method.
Check overrides on methods.
Result of method resolution including cost analysis.
Simple record tuple to combine the scope to be searched and the method signature to be searched for.
Represents some type of method that exists on an aggregate type scope.
Quite a few option to a method search.
Create a MethodSearch symbol for an operation that could have a single expression or two expressions.
Models a set of result for a search for methods.
A single enforced quality/architecture metric limit, self-describing enough that BOTH the phase-5
checker that fires the error AND the MCP/IDE enquiry layer that reports headroom can read it from
the one place — see
MetricLimits for the registry and the rationale.How a measured value is compared against the limit.
A compound limit that fires only when an absolute cap AND a relative ratio are BOTH exceeded, and
only once the module is at least
minConstructs in size (small modules are naturally
disconnected and are exempt).A per-genus threshold table:
byGenus holds explicit limits, fallback covers genera
not listed, and exempt genera are not checked at all (so MetricLimit.GenusLimit.limitFor(SymbolGenus) is empty and
MetricLimit.GenusLimit.isOver(int, SymbolGenus) is always false for them).A gate on a fractional score rather than a count — E11020 multiplies a construct's complexity
ratio by its statement ratio and fires above 0.50, so neither operand is a limit in its own right
and the threshold cannot be an int.
A single-threshold limit with a comparator.
THE single source of truth for EK9's enforced complexity / coupling / cohesion /
dependency-injection metric limits — the exact thresholds the phase-5
Acceptable*OrError checkers fire on.Supplies the middle end phases for compilation..
Defines a module scope, the main concept for namespaces in EK9.
Tracks module-level cohesion by recording constructs and their intra-module type references.
Tracks module-level efferent coupling (Ce) - the number of distinct external modules
that a module depends on.
Goes through each module name and checks each of the parsedModules in that module name to check
there is only a single copy of that symbol in the whole module name space.
With EK9 it is possible to have multiple source files that are all in the same 'module'.
This is a very special scope, because the same 'module name' can be defined in
multiple files.
Detects which monomorphization scenario applies to a parameterized type.
The three monomorphization scenarios.
Used when trying to locate the current class or dynamic class, to be able
to check if access to fields or methods should be allowed, or even resolve methods without 'this' prefix.
Detects multiple arrow usage and emits clear educational error messages.
THE answer to "does this code run every time its enclosing body runs?", read from its position in the parse tree.
Checks if a symbol can be mutated, this is nothing to do with a pure context.
Item 5, step 1: the E08090 (NOT_REFERENCED) verdict FULL_RESOLUTION deferred, on a local initialised by a call and
afterwards only mutated in place, never read (
view <- config.get("server"); view :~: overrides).What PRE_IR_CHECKS needs, collected during Walk 1 (by
PreIRListener, every source in parallel), to decide
the E08090 verdicts FULL_RESOLUTION deferred (item 5):
every local marked NOT_REFERENCED_DEFERRED - initialised by a call, afterwards only mutated in
place, never read - with the expression it was initialised by (MutatedOnlyVariableOrError);
every user method, operator, function and dynamic function with a returning variable, with each expression
that variable is made to REFER to (its initialiser, every pointer assignment (pre-flows included), and through
an arm-shaped value the returning variable it yields), so ReceiverInteriorReturns can derive whether a
method returns (part of) its receiver and CloseableReturnOrError can require a closeable return to be
new - both reading ReturnSourceKind.
Shared across the parallel walk, so the queues are concurrent; the per-source state is in a MutatedOnlyVariables.Collector.A deferred local and the expression it was initialised by.
A user method, operator, function or dynamic function with a returning variable, and every expression that
variable is made to refer to.
A
MutexKey dynamic-function body — the lambda passed as the argument to
enter(...) or tryEnter(...).Inbound-encapsulation check on
MutexLock(...) constructor calls.Restricts the construction of
MutexLock to field initialisers on classes or
components.Rejects parameterising any generic (other than
MutexLock itself) with
MutexLock (or a parameterised MutexLock of T) as a type argument.Detects `throw` statements whose expression is a nested call (E11070).
Tracks nesting depth within functions/methods/operators.
The phase-5 pre-pass that marks iteration the compiler can PROVE never ends (decision 15(a), phase 1: the
infinite half).
THE no-argument constructor of a type, whatever its access -
Counter().THE check that a construct being defined in a user module does not take the name of a built-in construct
(E01090).
Checks that a name being defined at module scope does not differ ONLY by case from a name
already defined in that same module (across every construct kind - class, record, trait,
function, component, service, text, program, application and constant).
As it is possible to have a variable that is a delegate 'function',
it means that to call that function, the ek9 developer would use variable-name(parameters).
Just to enable viewing and printing of nodes.
THE check that an aggregate does not redeclare a property its super chain already declares - one rule
for records, classes, components and dynamic classes (traits cannot declare properties, E07075).
Examines all the service operations on a service and looks at the verbs used and the uri proto paths.
Checks for duplicated trait names on an aggregate.
Does a simple check (excluding any inheritance) for duplicated operations (methods, operators) on
any sort of Aggregate, i.e.
Every LOCAL variable of a module checked against the methods of the type it is declared in - its own, inherited and
from traits (see
NoNameCollisionOrError.errorsIfLocalNamedLikeAMethod(IAggregateSymbol, ISymbol)).Typically used for Constructors, but could be used in other contexts where a method
is not expected to return anything.
Designed to check if variable name and method names collide with Type/Function names.
Detects non-descriptive variable names (E11031).
THE single source of the variable names E11031 (NON_DESCRIPTIVE_VARIABLE_NAME) bans - and of everything published
about them.
One group of banned names with what is published about it.
Aimed at methods in services and a program (which is a method).
SINGLE THREADED, for the same reason as SymbolDefinition: the parallel machinery was removed
because definition serialises on the CompilableProgram lock.
A trait listed beside another listed trait that already has it -
with trait of LoudSpeaker, Speaker where
LoudSpeaker with trait of Speaker - is E02090 (Steve, 2026-10-11): the second name adds nothing, and it
used to surface in FULL_RESOLUTION as E06150 "method 'speak' on 'Speaker' and 'Speaker'", one trait named twice.THE check that a body which must return a value can do so: a scope whose every path ends in an exception has an
unreachable return (E07380).
Typically used in control expressions to check developer is not doing a while(true).
THE 'cannot call an abstract function or type' check (CANNOT_CALL_ABSTRACT_TYPE), with the located message.
Check not dispatcher methods.
Generates synthetic IR for the _neq (<>) operator.
Checks that the variable supplied (if not null and has a type), does not have a type that
is a genericTypeParameter.
THE single predicate for "does this super type need an EK9-style super-init call emitted by the IR?".
E08273 (Steve, 2026-10-07, P5; 2026-10-08, P6): word
not is never an UNPARENTHESISED operand of another
operator, except and, xor and or - so neither of any other binary operator (P5) nor of a
prefix operator (P6: ~not b, $ not b, #? not b, ...).Used where traits are implemented 'by' a variable.
To be used in EK9 source code to assert that a type can or cannot be resolved.
Checks if there are any directives that relate to @Resolved in the parsed module and checks the
non-resolution.
Specialized generator for EK9 null coalescing operator (??).
THE shared structural analysis for an
objectAccessExpression chain — use this, do not
re-derive the walk.This is the second part of the method/function chaining resolution and can be recursive via objectAccess.
In the case of specific variables of type like 'Result' and 'Optional' it is important to check
if the method being called needs a previous call to isOk or isError or just '?' before accessing
specific methods.
Creates IR instructions for object access expressions.
Result holder for each step in the chain processing.
Processes the Object Access start, this is the start of chained method/function calls.
Provability of the OBJECT that bears a field-rooted MutexLock at an enter
site — the answer to "can a single consistent global acquisition order be
proven for two locks sharing the same field declaration but reached through
this object?" (Stage-3 Phase 2/3b, deadlock detection).
An object cannot be used before it is fully constructed (E08061).
A single contract/partiality obligation found in a construct body, tagged with the analysis (if
any) that discharges it (docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §2.1).
Layer 1 of the Symbolic/Contract Scanner — the every-build obligation census
(docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §2).
The taxonomy of contract/partiality obligations the census counts, from what already exists in the
language and analysis (docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §2.2).
Compiler self-verification directive (NOT an end-user feature) asserting the obligation census
(docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §4) computed the expected tally for a
construct.
Checks any
@Obligations directives in the parsed module against the squirrelled obligation
census tally (docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §4).Public facade for on-demand IR generation from the IDE.
Record to group operand evaluation instructions with the resulting operand name.
Used for resolving operation calls on aggregates, which can include properties that are delegates to functions.
THE checks every method and operator declaration gets - call this, never the rules one by one
(front-end rationalisation F12/D5, Steve 2026-10-03).
Locates the Operation details context for a method - or throws a compiler exception.
Deals with the generation of the IR for OperationDetails.
An operation on some sort on a Construct.
Is the token a simple assignment, i.e.
An operator declaration written in another order than the grammar's
[override|default] operator <symbol>
[as] [pure] [abstract] (operatorDeclaration).Holds some high level details about an operator.
Designed to gather aspect of operator population.
Detects variable names that shadow operator keywords (E11032).
Enhanced mapping of EK9 operators to their metadata and method names.
Typically checks any returning values to see if they have now been initialised on an operator.
Maps EK9 operators to their syntactic position (prefix vs suffix/postfix).
THE correction of a custom operator's
as pure in source text the Oracle is about to
write - use this, do not re-derive the rule from a list of symbols.The corrected text plus one note per line changed;
notes empty means nothing moved.THE move of a prefix or suffix operator to its own side of a simple operand -
names$ to
$names, ?stored to stored? - for every editing tool.The rewritten text and one note per rewrite;
notes empty means nothing moved.THE shared "resolve the callee method on its target type" step for phase-7 synthesised call sites.
Provides a common set of operations for checking operators.
Defines the optimization levels available in the EK9 compiler.
Detects assertion statements that are not reachable from any @Test program.
Operating System support and generic stuff for directories and files.
Only use when code being checked prohibits use in outer generic context.
Returns File Object in the appropriate location for jvm output.
Creates the File Object in the appropriate location for llvm output.
Given a TargetArchitecture from the configFlags, this function will provide a function that
NAMES the File for a Construct.
Enhanced visitor that uses specialized ASM generators to produce JVM bytecode for IR constructs.
The visitor that produces llvm IR text, requires further processing for creation of '.o' files for a Construct.
Locates the appropriate IR node visitor for the appropriate target architecture.
THE parent declarations a method overrides - use this, do not re-derive it.
Checks for both abstract and override.
THE error listener that owns a symbol: the listener of the source file that DECLARES it.
THE "is this a property of the object whose code is running?" - use it, never re-derive it.
Extracts capability data from a package block and stores as squirrelled data on the Package symbol.
An immutable snapshot of EK9 main package directives.
THE rule for what a 'defines package' block may hold (E06260): which property NAMES a package defines, and the
SHAPE each one's value must have.
Reports a package property a package does not define, or one whose value is not of the shape it requires
(E06260), using the same rule (
PackageProperties) and message as the CLI's package pre-pass - which only
the CLI runs, so without this the LSP and MCP tools accepted name <- "myLib" and tags <- "x".Focus on the responsibility of packaging.
SINGLE THREADED
Take the final optimised generated code and package it in to some type of release vessel.
SINGLE THREADED
Complete any post-processing required.
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.Parameters declared the way other languages declare them, rewritten to EK9's one-per-line form.
Represents details about a program parameter for the PROGRAM_ENTRY_POINT_BLOCK.
Every parameterisation of a generic that exists in the program, so FE77 can apply a generic's construction steps
to each concrete parameterisation and find the concrete type a substituted one names.
THE E06210 repair for a generic constructed with its parentheses AFTER the type arguments -
List of
String(), Dict of (String, Integer)(), echo of Integer() - which has ONE reading,
List() of String (Steve, 2026-10-08, GENERIC CONSTRUCTION b).The rewritten text and one note per rewrite;
notes empty means nothing moved.Validates that parameterised function call arguments are compatible with substituted parameters.
Create a new parameterised symbol from a generic type and a set of type arguments.
To be used when trying to define/resolve a parameterised type.
Does the detailed for of checking a specific possible generic symbol.
Given a parent and a dependent generic type, check that all parameters have been provided with suitable
arguments, so that the Parameterized type can be used.
Locates the Operation details context for a parameterized method by matching sourceToken identity.
This will just create an Aggregate/Function 'parameterized type' of the 'generic type' with the 'type arguments'
But note it will have not - repeat NOT have - traversed the 'generic type' and cloned over the methods and
altered all the 'T', 'K', 'V' - 'type parameters' for each of the 'type arguments'
There is a separate function (TypeSubstitution) that does that.
Processes all parameterized types in a module to detect their monomorphization scenario
and generate appropriate IR.
Processes method call parameters to determine if promotion is required.
Used for checking parameter list types match.
Checks the number and types of the two sets of parameter list match exactly.
While we don't add these in the scoped structures when compiling.
Gets the immediate parent directory of the file.
Once we have parsed a module (source file) we need to keep track of the results.
Used to hold just the transient data that will be used by listeners and visitors and
SymbolsAndScopes.
Creates the lexer and parser and plugs in the listners.
To be used to construct a parser, with a lexer.
The parse failures that have MORE than one reading - so no rule rewrites them, but the caller is told the readings
(the SUGGEST tier of
docs/tooling/EK9_TOOLING_IMPROVEMENT_METHOD.md):
a % b - EK9 has mod (the result takes the divisor's sign) and rem (Java's %,
the dividend's sign); which one is meant is the writer's to say;
assert x, "message" - EK9's assert takes no message; dropping it loses what it said;
$name in a backtick String - ${name} interpolates, \$ is a literal dollar;
a misspelt keyword (esle, defins) - correcting it changes which code runs, and a word one edit
from a keyword is just as often a name (heads, sorts);
a block header with nothing indented under it - how far its body extends is a choice.
Find the ISymbol at a given token position by traversing the parse tree.
Can be MULTI THREADED.
Parses a bit of EK9 source as an
instructionBlock — a contiguous run
of block statements (the body of a method / function / loop / branch).The parse outcome: the block context (may be partial when there are errors)
and the error listener so callers can gate on a clean parse.
Just processes a bit of some EK9 source for a simple or generic type def, to return the context.
The relational path condition accumulated along a control-flow path — an orthogonal structure that
sits beside
ConstraintState and records facts between symbolic term names
(e.g.A single relational fact between two term names, e.g.
When searching for methods, this will be a percentage result of how well a method matched.
Checks, mechanically, that the compiler's phase boundaries mean what they say.
Abstract concept of a supplier of phases for a compilation.
Process the stream pipeline part, ensuring that it can be resolved.
Per-stage-boundary item variable plan.
Symbolic identity for a
MutexLock parameter whose underlying object
is unknown until resolved at a specific call site.THE value of a plain
"..." String literal - the only String form EK9 reads at compile time: a constant, a
constraint, a text's language, a service parameter's name.Where EK9 needs a String it can read at compile time - a constant, a constraint, a text's language, a service
parameter's name - only a plain
"..." literal will do (E07902).SINGLE THREADED
If the developer has employed any sort of 'native' plugin, then it will have been referenced
and trusted at earlier phases.
SINGLE THREADED
No-op at this stage.
THE rule for a copy (
:=:) through a super-typed reference (Steve, Q5b, 2026-10-08).Creates the DETACHED method symbols a copy owner's IR carries for a copy through a super-typed reference
(
PolymorphicCopy, Q5b): the generated _copyAccepts(target as Any) <- Boolean and one
:=: override per inherited :=:(Super) signature.Links a supertype method to the overrides that can actually run, so a call made through an
abstract/base declaration reaches the implementing body.
For Constrained Types, focus on checking it is possible to constrain the type and if so then
clones the appropriate methods/operators over and alters the types as appropriate.
You may think why this mapping.
Just holds a simple set of lists with the appropriate type arguments and their corresponding parameterizing
parameters.
Used as a base for a range of constructs that can be expressions.
Added as a common symbol type for both Functions and Aggregates that could possibly be
generic in nature and also be a parameterised type.
Just uses the name of a method in the search, to get a list of all possible method name.
What the bare-default and sameness post-passes at the end of EXPLICIT_TYPE_SYMBOL_DEFINITION act on, gathered in
ONE walk per source rather than one walk each.
A bare 'default operator' and the class, record, component or dynamic class that declares it.
SINGLE THREADED
Once full resolution has completed, additional checks need to be made.
Detects string concatenation chains with 3 or more parts and recommends
string interpolation instead (E11068).
THE single definition of "can this control-flow pre-flow skip the construct body?".
Checks that the pre-flow expressions are valid.
At this point all templates should be present and all symbols resolved.
Designed to do additional logic checks once everything has been resolved.
Ensures that 'primary' is now resolved and 'typed' or a not resolved error.
Generates IR instructions for primary references (THIS and SUPER keywords).
Processing details for primary reference generation (THIS and SUPER keywords).
CONCERN: Boolean primitive extraction from EK9 Boolean objects.
Specialized ASM generator for PrimitiveLiteralInstr processing.
IR instruction for loading primitive literal values (int, boolean, java.lang.String).
THE single builder for the "wrap a primitive/Java value into its EK9 object via a static
_of factory" IR sequence — Integer._of(int), String._of(java.lang.String),
Boolean._of(boolean) and the like.Checks that reveal() on Sensitive is only called from within a class or trait that is Privileged.
To be used in EK9 source code to assert that the Oracle query at a specific line
produces the expected JSON output.
Identifies which Oracle extractor a @Probe directive should validate against.
If any of its OWN methods is marked as 'dispatcher' then mark this class as a 'dispatcher'.
Checks what only a METHOD declaration can get wrong, in every method context: 'default' on a method that is not a
constructor, the access modifier, and the constructor rules.
Configures a dynamic class in terms of settings its super and configured traits.
Deals with handling any returning values in a dynamic function.
Configures the dynamic function with it's 'super', but also checks that the super can be used in the
way the EK9 source code has been defined.
Configures a function's 'super' in the most appropriate way.
Checks in the context to see if a returning variableDeclaration or a body is defined.
Designed to enable a developer to wrap lots of different type of
processing and expose any exceptions.
Constructs like methods and functions may or may not always return a value.
Configures the trait declaration and completes a number of checks on that trait once configured.
Check trait specifics on constructors/methods/operators, Allowing missing body but marking as abstract.
Adds various synthetic methods to type defined by the EK9 developer.
Checks for inferred declarations of variables in various contexts.
Checks on whether the '?' can be used as a modifier
then check the parent of this context.
Deals with variable only declarations.
Processes a variable declaration - attempts to resolve the variable type.
Deals with checking the 'while' or 'do/while control variable in the statement/expression.
Detects assertion statements that are reachable from non-test program entry points.
Specialized ASM generator for ProfilingEntryInstr processing.
Specialized IR instruction for profiling function entry (PROFILING_ENTRY).
Specialized ASM generator for ProfilingExitInstr processing.
Specialized IR instruction for profiling function exit (PROFILING_EXIT).
Check if this type being supplied to the test can be used as a program argument.
A program can only accept specific types of arguments to it.
Represents details about an EK9 program for the PROGRAM_ENTRY_POINT_BLOCK.
Creates the appropriate IR Construct for an Aggregate of type 'program'.
IR instruction containing all discovered programs and their metadata.
Visitor interface for specialized handling of ProgramEntryPointInstr.
Validates that program HTTP wiring is consistent with application service registrations.
Extracts metadata from EK9 program symbols to create ProgramDetails objects
for the PROGRAM_ENTRY_POINT_BLOCK.
Checks if there is any application associated with the program.
A program can only return an Integer (exit code).
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.
THE reading of a constructor's
CommonValues.LEAVES_PROPERTIES_UNSET mark: the
properties (declared without a value) it leaves unset, following its this(...) chain.Marks the types whose objects can reach themselves through their properties, so phase 7 guards only THEIR
generated operators against a cyclic object graph (Steve, 2026-10-05: the hybrid - a compile error on a
potentially cyclic type would reject every legitimate tree, a runtime guard on every type would tax the hottest
operator in the language).
THE reading of phase 5's property-cycle marks (
phase5/PropertyCycleMarker) - use this, never the
squirrelled data directly.Used for resolving and recoding of fields on specific types.
THE answer to "is this node inside a property's initialiser, and which properties of that type are set by then?"
Use this wherever a check depends on a property initialiser - do not re-walk the tree for it.
THE instance initialisation of a type's properties, in declaration order - the body of its
_i_init.THE property-type graph: which types an object of a given type can reach through its properties.
The three kinds of node - see the class javadoc.
One node, keyed by kind and fully qualified type name (value equality, as the shared Tarjan requires).
The size of the part of the graph that was reached - what the linearity test asserts on.
The two whole-program facts the graph needs: the concrete subtypes of a type, and every aggregate.
For doing pure checks on method and functions.
Checks if the pure modifier has been used correctly on methods and functions.
Just check that with in the current 'context' - if pure that the processing call is pure.
THE hint for a QUALIFIED name 'M::X' that did not resolve, when the X the user probably meant is only IMPORTED
with 'references' - by module M, or by the module the name is used in.
Central home for the code-quality metric limits that are SHARED across more than one check in this
phase.
Generates IR instructions for question operator (?) using unified SWITCH_CHAIN_BLOCK.
The two
? spellings beside QuestionMarkWithValue's Type?: value that never parse:
<- rtn as String?? - a declaration's ? written twice (a tool rendering '<- rtn as
T?' around a T? it was given, or a model doing the same): one ? is meant.THE repair of a declaration written with a
? AND a value - <- rtn as String?: String()
becomes <- rtn as String: String() - for every editing tool.The rewritten text and one note per rewrite;
notes empty means nothing moved.Specialized generator for EK9 question operator (?).
Single source of truth for "Did you mean?" / quick-fix suggestions across the
EK9 compiler, IDE, and AI tooling.
Shared helper for range iteration logic used by both for-range loops and stream for-range sources.
Parameters for case constructor (AscendingCase or DescendingCase).
Helper record to pass initialization data between methods.
Checks the Range and ensures that there a Symbol recorded against that context.
Represents a variable known to be within a numeric range [lo, hi].
THE "what does running this callable construct, and what does that construction run with no edge of its own" for
the dependency-injection checks that walk
CallGraph.getReachableIncludingReferences(Set, Function): DI completeness
(ReachableInjectionsOrError, E08210/E08220) and DI ordering (TransitiveInjectionOrderingOrError,
E08200).THE dependency-injection completeness check for programs (E08220, E08210): every injection that can run when a
program runs must be satisfiable - the program needs an application, and that application must register every
injected abstract component the program can reach.
THE incremental readability (ARI) scorer - feed it every token exactly once, in order,
then ask for the score.
Item 5, step 2: DERIVE, for user methods and operators, the RETAINS marker the built-ins declare - so a user
method that hands back one of its own properties follows the same rule as
JSON.get.The OBJECT that bears a field-rooted MutexLock at an enter site — i.e.
F1 (Steve, 2026-10-07): a record exists only to carry data, so a CONCRETE record with no fields, counting inherited
ones, is an error (E07237).
Creates the appropriate IR Construct for a record declaration.
THE symbol-identity walk over a parse-tree fragment for the compiler and the
mcp.oracle tools - use
this (moved down from compiler-services with SymbolWrites, 2026-10-04), never a
by-NAME walk (a regex over body text, getText().equals(name) on identifier nodes, a set of names).One identifier occurrence the compiler bound to a symbol.
Triggers the expression processing with the given details.
THE E50050 repair - a name declared a second time with
<- - where the second <- has ONE
reading, for every editing tool.A second declaration as the E50050 message names it - THE reading of that message for this repair and
for the MCP
RedeclarationHint: the name, the line declaring it again, the line that declared it first.The rewritten text and one note per rewrite;
notes empty means nothing moved.Detects comparisons of a Boolean expression with a Boolean literal (E08084).
Detects empty checks that are always true or always false based on data flow analysis (E08092/E08093).
Detects isSet checks that are always true or always false based on data flow analysis (E08088/E08089).
Detects when an override method/operator body is textually identical to the super (E11044).
THE E02090 repair - a trait listed beside another listed trait that already has it (
with trait of
LoudSpeaker, Speaker where LoudSpeaker with trait of Speaker) - which has ONE reading: delete the
redundant name (Steve, 2026-10-11).The rewritten text and one note per rewrite;
notes empty means nothing moved.THE reading of a statement that makes a local variable (never a property) refer to the SAME
object an expression evaluates to - a reference copy (an alias), never a value copy.
SINGLE THREADED - because we only want one reference shorthand for an item.
Checks that references within a references block are in alphabetical order.
Antlr listener for the references phase.
Which pass this walk performs.
Utility to determine if an ISymbol represents a reference-counted type
that should be included in the traceableFields list during initial IR generation.
Rather than just check if the actual ISymbols are the same, this code checks if two
symbols actually refer to the same source token from the same source file.
THE check of what a 'register' statement registers (decision 10, 2026-10-07).
Holds the data from a 'register' statement within an application block.
Stores registration data on the application symbol for both component and service registrations.
Designed to ensure consistent reporting as part of the command line
commands and executions.
To be used with operators on aggregates (except for the is-set ? operator, that has to deal with functions).
THE reader of
require preconditions — use this, do not re-derive one.Checks that the require statement actually has a boolean result from the expression.
IR Generation for the require statement.
Detects when a reserved keyword is used as an identifier and emits a clear error.
To be used in EK9 source code to assert that a type can or cannot be resolved.
Checks for resolutions directives.
Program-wide state for the per-phase symbol-resolution memo.
Used where traits are implemented 'by' a variable.
To be used in EK9 source code to assert that a type can or cannot be resolved.
Checks if there are any directives that relate to @Resolved in the parsed module and checks the
resolution.
A bit of a long-winded name, but this is really the second pass of the second phase of compilation.
This is a really critical point, because this attempts to ensure that ANY expression
results in a symbol that has been 'typed'.
Mainly used in the CompilableProgram for resolving or defining a new Parameterized type.
Used for resolving a function (by just name) or a variable that is a function delegate.
Check for valid function parameters.
Locate a possible call to an identifierReference, so some sort of call.
Resolves a method (by name and call arguments) within a given scope, emitting an error if it
cannot be resolved or is ambiguous.
Given a search for a method from an aggregate - and include supers/traits etc.,
this function will try and locate the method.
The bulk of the processing is in the abstract base.
The bulk of the processing is in the abstract base.
The bulk of the processing is in the abstract base.
This is a sort of hybrid resolver or definer function.
Used as an abstract base for parameterised types.
THE compiler-generated
close: the one place IR for closing a resource is built, so every route that
closes something names the same owner, the same method, the same metadata and the same failure rule.A value to close.
The region's first-failure variable, declared (null) BEFORE the region by
ResourceCloser.declareFirstFailure(ResourceCloser.FirstFailure, DebugInfo) - it must be definitely assigned where the region's handlers start.THE measurement of a window of compilation - a phase or a stage of one - used by the verbose
PHASE_METRICS
and *_STAGE lines so every window is measured the same way.THE backend-independent verifier of the ARC RETAIN/RELEASE/SCOPE balance invariant for the +1
ownership-transfer convention.
A single balance finding for one construct/operation.
PRE_IR_CHECKS use-site check for a RETRACTED bare default comparison operator.
Accesses the aggregate and gets just the 'default' operators defined on that aggregate (not any hierarchy).
Helper class for generating return block IR patterns.
Processes returningParam context from expression forms of control flow constructs.
Checks if return variables are initialised.
Enforces guard-first return ordering (E08055; docs/language-design/EK9_REQUIRE_RETURN_ORDERING_SPEC.md).
THE reading of what a call's RESULT may share with what it was called on - the return half of the
CommonValues.RETAINS declaration.THE classification of what a callable's returning variable is made to refer to - one of the
MutatedOnlyVariables.ReturningCallable.sources() collected in Walk 1.get the appropriate return type from functions, methods and function delegates and constructors.
Record containing return variable management information for CONTROL_FLOW_CHAIN constructs.
Loads rich error messages from individual .txt resource files listed in a manifest.
Provides rich error messages for AI-assisted development.
Designed to be extended by rules and checkers.
Extracts EK9 runtime classes (org.ek9.lang and ek9 packages) from the running JVM
and packages them into a versioned JAR file with SHA-256 checksum.
THE conjunct walk for Optional/Result/Iterator safe access (Steve, 2026-10-07, decision Q3) - use it, never
re-derive a variant.
One fact a conjunct proves:
access (ok/error/get/next) on symbol is safe.THE E08040 rule: an Optional/Result/Iterator that is proven safe to unwrap in the current scope must not be
re-pointed there, by ANY store - an assignment statement (
o: other, o :=? other) or a
construct's assignment pre-flow (if o := other then o?).THE single defence-in-depth chokepoint that makes a zero-length JVM exception-table entry impossible to
emit.
Marks specific types of variable of specific types (generic Result/Option) in a manner
that enables the compiler to check if access to certain methods is safe.
Tests specific types of variable of specific types (generic Result/Option) in a manner
that enables the compiler to check if access to certain methods is safe.
It may be that before calling this you have determined that 'isSet' has been called or you 'know' that
the value of the variable is present and set.
Checks to see if the type parameters are the same as the generic arguments.
THE vocabulary of B18 - "a type defines sameness once" - call this, do not re-derive it.
Completes every type's SAMENESS once types are known, after every source has been through
EXPLICIT_TYPE_SYMBOL_DEFINITION (B18 - a type defines sameness once).
B18 - a type defines SAMENESS once (Steve, 2026-09-30).
Checks for inappropriate use of 'sanitized' at function/method call sites.
Data holder for checking that an overriding declaration keeps every 'sanitized' parameter of the declaration it
overrides.
Checks for inappropriate use of 'sanitized' in expression parameters.
Checks for inappropriate use of 'sanitized' in variable declarations.
Checks that an overriding method or function keeps every 'sanitized' parameter of the declaration it overrides
(E07940).
THE single source of 'sanitized' parameter cleaning in IR generation - call this, do not re-derive it, and never
clean at a call site.
Validates that the 'sanitized' keyword is used correctly:
1.
IR instruction for sanitizing string values to prevent injection attacks.
Specialized ASM generator for SanitizeInstr processing.
Generates IR for Scenario 2 aggregate wrapper constructors, delegation, and function-accepting methods.
Generates IR for Scenario 2 wrapper equality operations.
Generates IR operations for Scenario 2 function type wrappers.
Shared utilities for Scenario 2 wrapper IR generation.
Generates IR for Scenario 2 delegation wrappers.
Generates IR for Scenario 3 (USER_DEFINED_SOURCE) parameterized types.
CONCERN: Temporary scope lifecycle management.
Represents a symbol that also has a scope.
Scope boundary information for tracking variable lifetimes.
Specialized IR instruction for scope management (SCOPE_ENTER, SCOPE_EXIT, SCOPE_REGISTER).
Specialized ASM generator for ScopeInstr processing.
Memory management for CONSUMING a value that was already RETAIN'd by a producer.
This stack object is only designed to be used when first parsing.
Just focussed on ensuring that scopes are correct push on to the scope stack.
Walks a callable's parse tree to collect the variable symbols accessible within it - the local
variables declared in its (possibly nested) instruction blocks, and the property fields of its
enclosing aggregate.
Detects hardcoded secrets in string literals at compile time (E11080-E11086).
Detects self-comparison expressions where both sides resolve to the same symbol (E08081).
THE reading of a statement that stores the object in one of its OWN properties -
me: this,
next := this, this.owner :=? this - a property of the object's own type that refers back to it.A statement that gives one of the object's own properties a dynamic function or class capturing 'this'.
The narrow 'produce a semantic diagnostic' surface of
ErrorListener.Can be a normal version number like 6.8.2-9 i.e 9 is the build number
Or can be for a feature like 6.1.6-specialFeature12-19 i.e.
Serializes a compilable program to a byte array, so it can be saved/reused as required.
Alters an 'Application' from being a general application to a service application when it registers a service.
THE service-form repair (Steve, 2026-10-11: one form each) - for every editing tool.
The rewritten text and one note per rewrite;
notes empty means nothing moved.Creates the appropriate IR Construct for a service declaration.
Deals with the creation of the service parts for the EK9 language.
Extracts HTTP metadata from an EK9 service
AggregateSymbol to produce
a fully materialised ServiceRouteDetails.Generates one
public static __op_<methodName> method per service route on the
service class.Typically checks any returning values to see if they have now been initialised on a service operation.
Scope for callable methods (operations) that are part of a Service.
A single service registration within an application.
Links the escaping-return-value contract of service operations into the call graph.
Complete route table for a single EK9 service.
Binding for a single parameter to its HTTP source.
A single service operation's HTTP route metadata.
THE normalisation of a service route's URI-template parameters for route-identity comparison — use
this, do not re-derive the
\{.*?} regex.Validates that every service declaration has a security posture: either 'open'
or 'constrain by X [and Y]'.
Represents a variable known to be either SET (has a meaningful value) or UNSET (declared but no value).
Looks at the returning param (if not null) and sets the symbol type as appropriate.
Shared IR-text rendering for the nested setup block of composite instructions
(LIST_LITERAL / DICT_LITERAL / STRING_INTERPOLATION).
The Generic T used in parametric types will exist but won't have any methods on yet.
The principal data-race check (slice 1, step 7): every mutation of shared state
inside a function/method marked
CONCURRENT_ENTRY_POINT must occur inside
a MutexLock.enter(...) callback.Concept here is to be able to protect raw java objects from multiple threaded access.
Generates IR instructions for Boolean AND operations using LOGICAL_AND_BLOCK pattern.
Generates IR instructions for Boolean OR operations using LOGICAL_OR_BLOCK pattern.
Determine if a variable should be registered in scope for cleanup.
Just a wrapper around java public private key processing.
THE "may this slot already hold a value here?" test for a slot that may be assigned AT MOST ONCE ON ANY PATH: a
closeable property in its own constructor, and a closeable returning variable declared unset (D3 extended to every
closeable slot, 2026-10-06).
THE shared cache of small non-negative int-to-String conversions — use this instead of
String.valueOf(int) / Integer.toString(int) when the result is squirrelled or
otherwise retained per symbol.Generates JSR-45 SMAP (Source Map) for debugging non-Java languages on the JVM.
Result of sorting a buffer and creating an iterator over the sorted result.
Result of sort transformation: the new iterator setup and the sort index.
Defines the concept of an EK9 source file.
THE decoder turning a compiler source-token identifier into a filesystem path — use this, do not
hand-roll the scheme strip.
Provides source line content for error display formatting.
Line-level helpers the text rules share: indentation, a line with its literals masked out, the top-level
comma split.
Determines whether a
CompilableSource corresponds to a given source file name.THE reader of the region and elide markers in a compiled example source (site-examples spec §3.4, decision D5) -
every page fragment is cut from a whole, compiled source through here; never parse the markers anywhere else.
A source with its markers removed, and the line each region starts on.
The kind of a marker line.
One marker line: whether it opens or closes, its kind, its name and its indentation.
THE source repair engine - the one place an EK9 source is repaired automatically, for every door:
ek9 -ff
and ek9_format (the TEXT layer), and the MCP editors, ek9_write_file, ek9_edit_file and
ek9_compile (the DIAGNOSTIC layer).One diagnostic-layer pass: the repaired text and one note per repair; notes empty means nothing moved.
The text layer's outcome.
THE source of a parse rule as the developer wrote it: the characters it spans in the char stream, spaces kept.
To be used in EK9 source code to assert that a specific squirrelled-data key is set
(to any non-null value) on a resolved symbol at the given compilation phase.
Processes
SquirrelledDirective directives.Used when duplicate symbols are found, where we need to add a placeholder.
Support for stack-oriented code generation.
A run of pipeline stages together with their pre-loop state - the two always travel as a pair,
positionally aligned, and are meaningless apart.
Result of stage initialization: pre-loop instructions and per-stage state.
Holds per-stage state for stateful pipeline stages.
The three things EVERY stream stage needs, whatever its shape: which stage it is, what runs
downstream of it, and the debug info to stamp on what it emits.
Result of wrapping stages: the per-iteration body and any post-loop instructions.
Tracks statement counts within functions/methods/operators.
Validates that the statement is OK and emits errors if this is not the case.
THE decision of which calls make a closeable value that the block statement making it OWNS - the unnamed half of
the closeable ownership rule (Steve, 2026-10-05): "A closeable value you never NAME is owned by the statement that
created it and closed when that statement finishes." The named half is
CloseableLocalOrError (E81056).The UNNAMED half of the closeable ownership rule (Steve, 2026-10-05): "A closeable value you never NAME is
owned by the statement that created it and closed when that statement finishes; a closeable value you NAME
must be declared as a try-with-resources resource." The named half is phase 5's E81056
(
CloseableLocalOrError).What
StatementOwnedCloseables.own(List, DebugInfo) found.THE mark that a call's closeable result is owned by the block statement that makes it, so that statement closes
it when it finishes (the unnamed half of the closeable ownership rule, Steve 2026-10-05).
THE F.3 step-filter decision core: turns a method's
MethodDebugPolicy bitset (from
MethodKindIndex.policyFor(String, String)) into the yes/no answers a JVM debugger needs while stepping and
building the call stack.Classifies a single step in a
DeadlockChain's rationale trace.Creates IR instructions for statements.
THE phase-5 reading of a STORE: a statement that makes a variable, property or returning variable refer to the
value an expression evaluates to.
Used in Stream assembly processing to check aggregate use validity.
The construct for a Stream statement/expression.
Processes/updates and checks that a stream assembly is actually viable in terms of types.
A stage that cannot stream: it must see the whole source before it can emit anything, so instead of
wrapping the loop body it REPLACES the pipeline - draining the source into a buffer pre-loop, then
emitting from that buffer through the remaining stages.
Just re-uses the bulk of method symbol.
Deals with working out what the type being 'catted' is.
THE demand rule of a stream pipeline:
head N bounds the PULL (decision 10, rule B) - use this, never
re-derive which heads gate a loop or how the gate is folded into a loop condition.A stream stage that inspects the flowing element WITHOUT changing it -
filter,
reject, tee.The buffered-emission engine: the stages that cannot stream, and the pipeline bodies they emit.
Now does the check/processing of the whole stream pipeline.
Process and ensure that the stream termination can function correctly.
Just deals with the creation of Streams parts.
Deals with working out what the type being "for'd" is.
Checks that the arguments in the function are compatible with the current pipeline type.
Used in Stream assembly processing to check function validity.
Checks a stream pipeline whose source is a
for carrying a pre-flow guard.Produces the loop body-tail after the iterator item is bound: stages + sink.
THE record of stream stage function operands that were EVALUATED once, before the pipeline, rather
than named - use it, do not re-derive which operands need evaluating.
The pipeline machinery shared by the orchestrator and the buffered-emission engine: draining a
source to an iterator, planning the per-stage item variables, building the stream loop, and
setting up per-stage pre-loop state.
Intended to model the pipeline flow in a streaming of cat or for loop though | and map etc.
A stream stage that CANNOT emit during the loop -
join, tail.What a pipeline is reading from: the iterator, the type of element it yields, and whether that
source can go on forever.
Discriminates a pipeline stage to its generator and nests the wraps.
THE classification of stream stages by what they need from the stream - use this, never a list of stage tokens of
your own.
The outcome of walking a pipeline's stages from a source that is not bounded.
A stream stage that TRANSFORMS the flowing element -
map, call, flatten.Generates IR for stream statement pipelines: source | stages | > terminal.
Now does the check/processing of the whole stream pipeline.
Process and ensure that the stream termination can function correctly.
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.
Outcome of a
StringConcatRewriter call.One refusal condition.
Editor primitive that rewrites a string-concatenation expression
(
"a" + var + "b") into the equivalent backtick interpolation
(`a${var}b`).A
+ chain rendered as a backtick String, or the first operand that cannot be one: set
rendered with the operand counts, or conflictKind/reason naming the refusal.Shared parse-tree primitives for selection-driven string-expression
editors.
Result of
StringExpressionClassifier.findEnclosingTextMethodDeclaration(ParseTree, int, int): the resolved
text-type and method names ready to feed straight into
ek9_edit_localized_text as textTypeName / methodName.Generates JVM bytecode for STRING_INTERPOLATION IR instructions.
IR instruction for string interpolation.
Represents a single part of an interpolated string.
Type of interpolation part.
THE strongly connected components of a directed graph (Tarjan, 1972) - use this wherever a phase needs the cycles
of a graph, never a private copy.
One strongly connected component.
Pass 2 of the EK9 source formatter: Structural Reordering.
Canonical ordering for module block types.
THE place a sub-type (a class, record or component that 'extends'/'is' a super) gets its generated public
no-argument constructor - after every source has been through EXPLICIT_TYPE_SYMBOL_DEFINITION, supers first.
A single ranked suggestion that the compiler can offer the user as a possible
replacement for an offending token.
Where the suggestion came from.
Checks for a type is resolved and is suitable genus and category.
Used with aggregates to check that if they have any properties that are not initialised at declaration
the developer has taken appropriate steps to ensure initialisation.
Checks for a type is resolved and is suitable to be extended from (in basic terms).
Every EK9 constructor chains to a super constructor: an explicit
super(...), an explicit
this(...) delegation, or - when neither is written - a hidden IMPLICIT super() to the
super's no-arg constructor.Resolves the JVM superclass of an EK9 construct and injects the
super(...) constructor call
when the IR does not already contain one.Only types of a specific genus can be used as constraints on the generic type 'T'.
Specialized generator for EK9 switch statements.
Generates short-circuit OR chains for multiple switch case expressions.
Result of comparison generation.
Specialized generator for EK9 switch expression form.
Ensures that a switch is used correctly in or out of an expression.
Deals with checking if the switch can be used as an expression and whether
the variable being switched on has the appropriate operators to meet the case criteria.
Generates IR for switch statements and expressions using CONTROL_FLOW_CHAIN.
Record to hold evaluation variable information.
Deals with checking if all paths through switch/case/default (return) result in variables meeting criteria.
EK9 switch statement - this can effectively return a value if it is configured with returning
part.
A bit of a beast.
Models information used in code analysis for various variable states.
Used when checking access to fields/properties and methods.
Typically used on symbols; so we know their broad use and type.
General utility class that searches in a scope for a symbol to check for duplicates.
SINGLE THREADED.
Just a factory for all types of EK9 symbol.
Returns the appropriate symbol from the symbol and scope management component.
Typically, used on aggregates because we might use a AggregateSymbol.
Only triggers the call the retrieve the appropriate symbol for the node.
SINGLE THREADED
The Layer-2 symbolic/contract verification pass
(docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §4.4).
The Layer-2 symbolic engine of the Symbolic/Contract Scanner (M3/M4) — it turns "this construct
carries undischarged obligations" (the M1 census verdict) into "here is the exact input that panics",
or proves no such input exists within the bounded model
(docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §3/§11.2/§12).
The M3 symbolic dead-branch analyzer: seeds a function's parameters as
SymbolicTermValue
terms, reads the relational facts off its require/if nodes into a PathCondition,
and reports a branch dead when its accumulated facts are unsatisfiable.The base (pre-branch) path condition and the verdict for the function's
if branch.Whether a branch is dead (unreachable for every input), and why.
A symbolic (named) term in the flow lattice — a fresh, unconstrained parameter or local carried as
itself instead of collapsing to
TopValue.Given some search criteria and a List of Symbols, this class will find the best match.
Checks if a symbol has been referenced or not (can be null - no error).
MULTI THREADED
Now try and check that all symbols used have a type.
Used as external helper to record symbols and scopes across the parser.
To be used to search for symbols in a Symbol table.
Can be used for a single Simple named search.
Just extracts the ISymbols from the expression contexts and issues not resolved errors if any are not present.
Function that extracts signature-qualified-name from a symbol.
We need to support simple things like classes which are unique per symbol table
Or the fully qualified class names like 'com.some.A and com.other.A' so they won't collide.
Given a list of arguments (ISymbols), go through and extract the types out.
Provides the PossibleGenericSymbol type of the symbol if it has been typed, or empty.
Just gets the type from a symbol, or throws a compiler exception if missing.
THE "where is this symbol written?" for the compiler's own analyses and the
mcp.oracle tools - use this,
never a by-name test such as body.contains("this." + name) or a set of assigned NAMES.One write.
THE parse-only check of a piece of EK9 text, for every repair: the syntax errors the ANTLR parser reports, no
symbol phase run.
A parse tree and the token stream it came from (HIDDEN-channel comments included).
One syntax error.
THE way a phase-7 SYNTHESISED call site obtains its
CallMetaDataDetails.Bundles the scope parameters that flow through synthetic operator generation methods.
Looks at the function and if it has no super function, attempts to work out what would be the
best super function generic type it could implement.
Some aggregates like classes, components, etc.
Fluent builder for generating method and constructor call IR instructions.
Main coordinator for synthetic operator generation.
THE names the compiler gives the parameters of constructors it SYNTHESISES - a constrained
type's, an enumeration's, a text's, a generic's required pair and its type parameters'.
Generate tail wrapper using an Ek9Tail circular buffer.
The target platform/technology for the compiler output.
Possible supported target output architectures.
Given a TargetArchitecture, this function will provide the Target for it.
THE rule for target-typed generic construction - use it, never add a second inference route
(Steve, 2026-10-08, GENERIC CONSTRUCTION a).
Generate tee side-pipe and continuation for a tee stage.
A Search for a TEMPLATE of a FUNCTION.
A Search for a TEMPLATE of a TYPE like a CLASS.
Represents the source of a temp variable for stack-oriented code generation.
The type of source for a temp variable.
Terminal color and symbol support with automatic capability detection.
Helper record for terminal sink setup results.
Similar to the if block check, but this is focused on the true part of the ternary expression.
Specialized generator for EK9 ternary operator.
Test directive for marking programs as tests, optionally anchoring one to a requirement and
declaring the exit code its program must end with.
THE answer to "is this a
@Test, and what execution group is it in?" — use this, do not
read the squirrelled key directly.Creates the IR Construct for the abstract base text class.
Locates the textBodyDeclaration parse context for a given text method symbol.
Generates IR for text body methods with implicit String return.
Creates the appropriate IR Construct for a text declaration.
Deals with the creation of Text parts from the EK9 language.
THE single decision point for lowering a
text constructor call.Extract the valid language value from the String literal or null and error.
One text rule of
SourceRepairs: given a source's lines and the parse failure the parser stopped on, the
rewrite that answers it - or null when this rule does not recognise the failure.A rule's rewrite: the new lines, and the note that says what was written and why.
Emits the bytecode for EK9 TEXT constructs: the abstract base type's no-arg constructor, its
static
_textFactory locale dispatcher, and the _isSet override on both the base
(unset fallback) and the locale variants (always set).The locale variants of a text, carried on the IR construct of the text's abstract base: THE list a back end lowers
the base's
_textFactory(language) dispatch from - JVM and LLVM alike.One locale of the text.
Check an assignment again 'super' use and some operators against 'this' use.
Just focus on resolving 'this' or 'super' in respect to a 'call'.
Checks and assigns type a 'this' or 'super' symbol, but only if it valid.
A PrintStream that delegates to thread-local outputs.
Specialized IR instruction for throwing exceptions (THROW).
Specialized ASM generator for ThrowInstr processing.
Generates IR for throw statements.
Checks that the throw statement actually throws and Exception type.
Converts a list of symbol using their friendly names in to a comma separated list.
Generates synthetic IR for the _json ($$) operator.
Listen as Tokens are consumed as they are pulled from the Lexer into the parser.
Typically used for locating the nearest token to some position in a source code file.
Pass 3 of the EK9 source formatter: Token Spacing.
Drives
ReadabilityAssessor over a whole lexer, for standalone and debug use - and to
list out tokens so that when building grammars out of tokens it is possible to see what is
being produced.Represents an unknown value — no information available about the variable.
Generates synthetic IR for the _string ($) operator.
THE unbalanced trailing bracket -
stdout.println(x)], stdout.println("few")} - for every
caller: the statements[] pre-pass, the MCP diagnostic repairs and ek9 -ff.Checks that a trait access like T1.xyz() - is allowed i.e.
THE single source of truth for "does a call on this target need INVOKEINTERFACE?".
Creates the appropriate IR Construct for a trait declaration.
Analyzes how traits are implemented in an aggregate to detect E11023 pattern
(missing 'by' delegation).
Result of analyzing trait implementation for potential missing 'by' delegation.
Check trait specifics on methods/operators.
Detects when multiple traits implemented by an aggregate have methods with the same signature.
Checks that traits do not have properties/fields.
Single element of a function's
mayEnter summary — an enter() site reachable
from this function via some call path, with the lock identities after parameter
substitution and the composed edge-kind of the reaching path.Post-parallel detector for transitive injection ordering validation (E08200), run once the call graph is built.
Gets the abstract methods and then resolves each to see what the resulting method would be.
Record representing the try block within a TRY_CATCH_FINALLY control flow chain.
Specialized generator for EK9 try/catch/finally statements.
Generates IR for try/catch/finally constructs using CONTROL_FLOW_CHAIN.
Ensures that a try statement/expression is used correctly in or out of an expression.
Deals with checking the try statement/expression.
Checks the try/catch/finally structure via the code analysers.
EK9 try statement - this can effectively return a value if it is configured with returning part.
Given a Symbol that is some form of type, check that it could receive some piped data.
A type's metric-side model for the input-variation denominator: its ordered set of distinct
ValueClassIds and how trustworthy that set is (ClassConfidence).Holds the coercions we can make from and to on types.
TO be used when checking the left hand side and the right hand side with specific operators.
Checks that any recursive type constraints on a type are valid.
Checks the covariance compatibility of two variables, this will traverse them to get their types.
Pass a string of an ek9 typeDef in and use the
EK9 parser to just handle the breaking up of a String of a TypeDef into
a structure and names.
Designed to be used in phase3 or after - FULL_RESOLUTION.
SINGLE THREADED - Run across sources to check for types, functions and traits for 'super loops'.
Checks that the symbols in list one and list two are each the same for the corresponding position in the list.o
Extracts the fully qualified type name from the symbol.
THE constraint of a generic's type parameter: the 'X' of
T constrain by X, or empty for an unconstrained
'T' - use this, never "does T have a super?".A generic's type parameter name must not resolve to ANYTHING (E01091) - not a built-in, not a construct of this
module (even one declared later), not a function, not a constant.
Final formatter pass that strips the implicit module-name prefix from
EK9 type references.
Check that the types of two symbol ar compatible with each other.
Accepts an aggregate or a function that has been parameterized with 'type arguments'.
A Search for a concrete actual TYPE like a RECORD or a CLASS for example.
The denominator input for a single parameter type: how many distinct value-classes it admits and
how trustworthy that count is.
Generates IR instructions for unary operations (e.g., unary minus, increment, decrement, etc.).
CONCERN: Unary operator invocation with memory management.
Parameters for unary operator invocation.
THE E01093 repair - a backtick String closed with a double quote,
`${count} items" - for every
editing tool.The rewritten text and one note per rewrite;
notes empty means nothing moved.A backslash-u in a String literal must be followed by exactly four hex digits (E07903).
THE E08180 repair on a RETURN declaration -
<- rtn as String with neither a value nor
? - for every editing tool.The rewritten text and one note per rewrite;
notes empty means nothing moved.Used to check if variables within code blocks when declared without being initialised, actually
get initialised before they are used.
Checks if a variable should be processed as a possible uninitialised variable.
Union-Find (Disjoint Set Union) data structure for O(n * alpha(n)) connected components.
Generate tracker call and conditional wrapper for a uniq stage.
Unique ID generator.
Checks to see if a variable has a specific generic type.
Checks to see if a property on an aggregate is safe to access.
Reports dependency-injection fields that cannot be satisfied at a given point, walking an
aggregate's own injection fields plus those of any aggregate types reachable through its property
field types and supers.
Detects unused captured variables in dynamic functions and classes (E11018).
Detects unused parameters in functions, methods, constructors, and service operations (E08091).
E08275:
Networking().urlOf(text) given text the compiler can know - decision U3 of
docs/architecture/EK9_URL_TYPE_DESIGN.md §0.Checks that if the aggregate is a generic class that the appropriate public constructors are in place.
Check if any dispatcher methods on the aggregate and ensure that they are valid.
Checks if a function extends another function and if it is abstract.
Validates literal values at compile time to catch semantically invalid literals
that the ANTLR lexer accepts structurally but that can never represent valid values.
Checks methods from various contexts, typically this is delegated to other functions.
If the Ek9 developer has used named parameters, then they must be validated.
Checks each operator: first its operator SEMANTICS - arguments, return type and purity, which need resolved types,
so this runs in phase 2 - then what every method and operator declaration is checked for
(
OperationDeclarationChecks, D5).Error when use of ParameterisedType has additional expression parameters in wrong context.
Checks the PATH value (if this is a path parameter) and ensures that the name appears in the path itself
on the operation.
Does a few checks on a PossibleGenericSymbol in terms of checking types and the generic type it is configured with.
Check that a service operation complies with EK9 rules and return types etc.
Error when a reference is attempted by the syntax is incorrect.
THE shared value-class vocabulary for the input-variation metric — one taxonomy, three consumers
(
docs/implementation/EK9_INPUT_VARIATION_CLASS_TAXONOMY.md):
the denominator counter (EquivalenceClassModel) — counts distinct ids per
type for the static opportunity space;
the runtime classifier (INPUT_CLASS_PROBE recorder) — places an actual runtime
value into one of these ids for the dynamic numerator (design §5);
the generator (EdgeValuePool, compiler-services) — holds representative
literals per id for ek9_generate_edge_case_tests.
Tracks variable values through control flow for tautological condition detection.
Generates JVM bytecode for variable load and store operations.
Checks on the assignment during a declaration and emits an error if not valid.
Checks that variable declarations is acceptable.
Creates IR instructions for variable declarations.
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.
Creates IR instructions for variable only declarations.
Focus on checking a variable only declaration, now that types are all known.
Accepts a variable only declaration and ensures the variable is recorded if appropriate, for transient flow checks.
Models a variable.
Compiler self-verification directive (NOT an end-user feature) asserting the Layer-2 symbolic
verdict for a construct (docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §4).
Checks any
@Verified directives in the parsed module against the squirrelled Layer-2
verdict (docs/tooling/EK9_SYMBOLIC_SCANNER_IMPLEMENTATION_SPEC.md §4).Decides whether a member's visibility may legally be changed to a proposed access modifier -
the "declaration viability" of a
change_visibility refactoring.Outcome of asking whether a member's visibility (access modifier) may be changed to a proposed
value - the "declaration viability" layer used to gate the
change_visibility tooling and
to decide whether the IDE should even offer the refactor.Does a simple check (excluding any inheritance) for visibility rules on methods/operators on
aggregates.
Groups all the data needed to format a visual error display.
Formats compiler errors in a visual style similar to Rust/Elm compilers.
THE rule that
Void is never the type of a value (E10011, the formal specification's
WF-VOID-RESTRICTION).Checks if a symbol's type is Void and emits E10010 if so.
Specialized generator for EK9 while loops.
Does checks on the control part of a while loop to see if Optional/Result/Iterator are now safe via method access.
Ensures that a while do/while statement/expression is used correctly in or out of an expression.
Deals with checking the 'while' or 'do/while statement/expression.
Generates IR for while and do-while loops and expressions using CONTROL_FLOW_CHAIN.
Checks the while statement via the code analysers.
EK9 'while' or 'do/while' type symbol - we need a scope because we can declare new variables as part of the
pre-flow semantics.
The bounded-model witness materialiser for the Symbolic/Contract scanner (M3): given an obligation
expressed as a predicate over a candidate input, enumerate the representative value-classes of a
type and return the first input that violates it — a concrete counterexample.
A concrete counterexample: which value-class it came from, its EK9-source literal, and its value.
Designed to represent one or more source files that are part of a workspace.
Very simple wrapper for binary contents.
Just a common base directory and a list of files with that common base.