Uses of Interface
org.ek9lang.compiler.symbols.IAggregateSymbol

Packages that use IAggregateSymbol

Package	Description
org.ek9lang.compiler.common	Common parts of processing that can be reused across various phases.
org.ek9lang.compiler.phase2	F - Resolution of Explicitly Defined Type Symbols - at this point phase3 processing should have defined most of the explicitly defined symbols, so they should be resolvable.
org.ek9lang.compiler.phase3	G - Full Symbol Resolution can now take place.
org.ek9lang.compiler.phase4	H - Generic/Parameterised types can have their methods checked when used in specific contexts.
org.ek9lang.compiler.phase5	I - PRE Intermediate Representation generation checks.
org.ek9lang.compiler.phase5.construction
org.ek9lang.compiler.phase7	K - Intermediate Representation Generation.
org.ek9lang.compiler.phase7.generator
org.ek9lang.compiler.phase7.support
org.ek9lang.compiler.phase7.synthesis	Synthetic operator and method generation for EK9.
org.ek9lang.compiler.search	Used primarily to hold structures that are related to searching for symbols.
org.ek9lang.compiler.support	Contains critical general components used in the Ek9Compiler listeners.
org.ek9lang.compiler.support.closeables
org.ek9lang.compiler.support.conceptual
org.ek9lang.compiler.support.copy
org.ek9lang.compiler.support.operators
org.ek9lang.compiler.support.sameness
org.ek9lang.compiler.symbols	This is the main source of EK9 Symbols used within the compiler.

Uses of IAggregateSymbol in org.ek9lang.compiler.common

Classes in org.ek9lang.compiler.common that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
class	AggregateHasPureConstruction	Predicate to see if an aggregate mandated pure in its construction.
final class	CloseOperatorOf	THE close operator of an aggregate: the one operator close a call to close resolves to (its own, or inherited), or empty when it has none.
final class	HasCloseOperator	Predicate to check if an aggregate type has a close() operator defined.
final class	HasRealComparator	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.
final class	HasRealOperator	THE shared test for "does this type have a REAL &lt;operator&gt;?" - 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.&lt;operator&gt; that EVERY type inherits (e.g.

Methods in org.ek9lang.compiler.common that return IAggregateSymbol

Modifier and Type	Method	Description
IAggregateSymbol	MethodAndAggregateData.aggregateSymbol()	Returns the value of the aggregateSymbol record component.

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

Modifier and Type	Method	Description
boolean	HasRealComparator.allPropertiesOrderable(IAggregateSymbol aggregate)	THE test that every property of the type has a REAL <=> (HasRealComparator.test(IAggregateSymbol)) - so a BARE default operator's <=> over them survives.
Optional<MethodSymbol>	CloseOperatorOf.apply(IAggregateSymbol aggregate)
Optional<ISymbol>	HasRealOperator.declaredAt(IAggregateSymbol level)	The operator this one LEVEL declares (not its supers or traits), if any.
boolean	AggregateHasPureConstruction.test(IAggregateSymbol aggregateSymbol)
boolean	HasCloseOperator.test(IAggregateSymbol aggregate)
boolean	HasRealComparator.test(IAggregateSymbol type)
boolean	HasRealOperator.test(IAggregateSymbol type)

Constructors in org.ek9lang.compiler.common with parameters of type IAggregateSymbol

Modifier	Constructor	Description
	MethodAndAggregateData(MethodSymbol methodSymbol, IAggregateSymbol aggregateSymbol)	Creates an instance of a MethodAndAggregateData record class.

Uses of IAggregateSymbol in org.ek9lang.compiler.phase2

Classes in org.ek9lang.compiler.phase2 that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
(package private) final class	MarkMethodsAsConcurrentEntryPoint	Sets the CONCURRENT_ENTRY_POINT = "TRUE" squirrelled marker on every non-constructor, non-operator, concrete method of the supplied aggregate.
(package private) final class	NoDuplicatedServicePathsOrError	Examines all the service operations on a service and looks at the verbs used and the uri proto paths.
(package private) final class	SyntheticConstructorCreator	Some aggregates like classes, components, etc.
(package private) final class	VisibilityOfOperationsOrError	Does a simple check (excluding any inheritance) for visibility rules on methods/operators on aggregates.

Methods in org.ek9lang.compiler.phase2 that return IAggregateSymbol

Modifier and Type	Method	Description
IAggregateSymbol	PostPassSites.DefaultOperatorSite.aggregate()	Returns the value of the aggregate record component.

Methods in org.ek9lang.compiler.phase2 that return types with arguments of type IAggregateSymbol

Modifier and Type	Method	Description
(package private) Map<IAggregateSymbol, IToken>	PostPassSites.bareDefaultTokens()	The 'default' token of an aggregate's bare 'default operator' (the last one, if it has several).
(package private) Set<IAggregateSymbol>	PostPassSites.dynamicClasses()	The dynamic classes among PostPassSites.samenessDeclaredIn: their captures are known only in FULL_RESOLUTION.
(package private) Map<IAggregateSymbol, ParsedModule>	PostPassSites.samenessDeclaredIn()	The aggregates whose sameness is completed (not built-in, not Java-backed), in walk order, with their module.
(package private) Map<IAggregateSymbol, ParsedModule>	PostPassSites.servicesDeclaredIn()	The services (not built-in, not Java-backed), in walk order, with their module.

Methods in org.ek9lang.compiler.phase2 with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
void	MarkMethodsAsConcurrentEntryPoint.accept(IAggregateSymbol aggregate)
void	NoDuplicatedServicePathsOrError.accept(IAggregateSymbol service)
void	SyntheticConstructorCreator.accept(IAggregateSymbol aggregate)
void	VisibilityOfOperationsOrError.accept(IAggregateSymbol aggregate)

Constructors in org.ek9lang.compiler.phase2 with parameters of type IAggregateSymbol

Modifier	Constructor	Description
(package private)	DefaultOperatorSite(EK9Parser.DefaultOperatorContext ctx, IAggregateSymbol aggregate, ParsedModule parsedModule)	Creates an instance of a DefaultOperatorSite record class.

Uses of IAggregateSymbol in org.ek9lang.compiler.phase3

Classes in org.ek9lang.compiler.phase3 that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
(package private) final class	GetIteratorType	Given a 'type' (the IAggregateSymbol passed in), see it would be possible to iterator over it with some other type.
(package private) final class	NoteTypeParameterOrdered	Records, on a conceptual T, that the body being resolved compares its values with <=> (item <=> other.item over item as T?) - one ordering step (D89, D91 step 4).
(package private) final class	OperationCallOrError	Used for resolving operation calls on aggregates, which can include properties that are delegates to functions.
(package private) final class	RetrieveDefaultedOperators	Accesses the aggregate and gets just the 'default' operators defined on that aggregate (not any hierarchy).
(package private) final class	SuperConstructorAccessOrError	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.
(package private) final class	TraverseAbstractMethods	Gets the abstract methods and then resolves each to see what the resulting method would be.

Methods in org.ek9lang.compiler.phase3 that return IAggregateSymbol

Modifier and Type	Method	Description
IAggregateSymbol	AggregateMethodData.aggregate()	Returns the value of the aggregate record component.
IAggregateSymbol	StreamAggregateCheckData.aggregateSymbol()	Returns the value of the aggregateSymbol record component.

Methods in org.ek9lang.compiler.phase3 with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
void	NoteTypeParameterOrdered.accept(IAggregateSymbol owner, MethodSymbol operator)	Record the step when owner is a bare T and operator is its <=>.
void	SuperConstructorAccessOrError.accept(IAggregateSymbol aggregate)
void	TraverseAbstractMethods.accept(IAggregateSymbol aggregateSymbol, Consumer<MethodSymbol> actionToTake)
Optional<ISymbol>	GetIteratorType.apply(IAggregateSymbol aggregate)
ScopedSymbol	OperationCallOrError.apply(EK9Parser.OperationCallContext ctx, IAggregateSymbol aggregate)
List<MethodSymbol>	RetrieveDefaultedOperators.apply(IAggregateSymbol aggregate)
(package private) CommonValues	GetIteratorType.determineIterationPattern(IAggregateSymbol aggregate)	Determine which iteration pattern an (already-confirmed iterable) aggregate uses.

Constructors in org.ek9lang.compiler.phase3 with parameters of type IAggregateSymbol

Modifier	Constructor	Description
(package private)	AggregateMethodData(IToken location, IAggregateSymbol aggregate, MethodSymbol methodSymbol)	Creates an instance of a AggregateMethodData record class.
(package private)	StreamAggregateCheckData(org.antlr.v4.runtime.Token errorLocation, IAggregateSymbol aggregateSymbol, ISymbol symbolType)	Creates an instance of a StreamAggregateCheckData record class.

Uses of IAggregateSymbol in org.ek9lang.compiler.phase4

Constructor parameters in org.ek9lang.compiler.phase4 with type arguments of type IAggregateSymbol

Modifier	Constructor	Description
(package private)	ParameterisedTypeOrError(Ek9Types ek9Types, ErrorListener errorListener, Map<IAggregateSymbol, List<MethodSymbol>> accessedMethodsByT, Function<PossibleGenericSymbol, Optional<ISymbol>> definedParameterisation)	Create the check.

Uses of IAggregateSymbol in org.ek9lang.compiler.phase5

Classes in org.ek9lang.compiler.phase5 that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
(package private) final class	MarkedNeverEndingHasNext	The reason a dynamic class (or closed class) never ends - its effective hasNext()'s NEVER_ENDING_ITERATION mark, made by NeverEndingIterationMarker - if it has one.
(package private) final class	PropertyFieldsOf	An aggregate's own property fields, in declaration order, as an unmodifiable list.

Methods in org.ek9lang.compiler.phase5 that return IAggregateSymbol

Modifier and Type	Method	Description
IAggregateSymbol	TraitImplementationAnalyzer.TraitAnalysis.trait()	Returns the value of the trait record component.
(package private) IAggregateSymbol	PropertyTypeGraph.typeOf(PropertyTypeGraph.Node node)	The aggregate a node stands for (not for ANY).

Methods in org.ek9lang.compiler.phase5 that return types with arguments of type IAggregateSymbol

Modifier and Type	Method	Description
(package private) List<? extends IAggregateSymbol>	PropertyTypeGraph.allAggregates()	Every aggregate in the program - where the roots are chosen from.
List<? extends IAggregateSymbol>	PropertyTypeGraph.TypeUniverse.allAggregates()	Every aggregate in the program.
List<? extends IAggregateSymbol>	PropertyTypeGraph.TypeUniverse.concreteSubtypesOf(IAggregateSymbol type)	Every concrete aggregate that extends or implements the type, transitively.

Methods in org.ek9lang.compiler.phase5 with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
(package private) void	CohesionTracker.accountForDefaultOperators(IAggregateSymbol aggregate)	Account for default operators which implicitly access all fields.
(package private) List<TraitImplementationAnalyzer.TraitAnalysis>	TraitImplementationAnalyzer.analyzeTraitsWithoutDelegation(IAggregateSymbol aggregate, EK9Parser.TraitsListContext traitsListContext)	Analyze traits implemented WITHOUT 'by' delegation to detect potential E11023 patterns.
Optional<String>	MarkedNeverEndingHasNext.apply(IAggregateSymbol aggregate)
List<ISymbol>	PropertyFieldsOf.apply(IAggregateSymbol aggregate)
(package private) FieldClassifier.FieldCounts	FieldClassifier.classify(IAggregateSymbol aggregate, EK9Parser.TraitsListContext traitsListContext)	Classify all fields of an aggregate.
List<? extends IAggregateSymbol>	PropertyTypeGraph.TypeUniverse.concreteSubtypesOf(IAggregateSymbol type)	Every concrete aggregate that extends or implements the type, transitively.
PropertyTypeGraph.Node	PropertyTypeGraph.fieldsOf(IAggregateSymbol aggregate)	The node for the fields of an object of exactly this type - what a root, or a cycle member, is.
List<AggregateSymbol>	ConcreteSubtypeFinder.findAllSubtypes(IAggregateSymbol baseType)	Find all aggregate types (both abstract and concrete) that have the given base type in their type hierarchy.
List<AggregateSymbol>	ConcreteSubtypeFinder.findConcreteSubtypes(IAggregateSymbol abstractType)	Find all concrete (non-abstract) aggregate types that have the given abstract type in their type hierarchy.
(package private) Set<String>	TraitMethodConflictDetector.findConflictingMethodSignatures(IAggregateSymbol aggregate)	Find method signatures that appear in multiple traits implemented by this aggregate.
(package private) boolean	TraitMethodConflictDetector.hasConflict(IAggregateSymbol aggregate, MethodSymbol method)	Check if a specific method has a conflict across traits.
(package private) boolean	TraitMethodConflictDetector.hasConflictForTrait(Set<String> conflictingSignatures, IAggregateSymbol trait)	Check if any of the conflicting signatures is one of the given trait's own methods.
(package private) Set<String>	ReachableInjections.membersOf(IAggregateSymbol aggregate)	Every method and operator of a type, its supers' and its traits' included.

Constructors in org.ek9lang.compiler.phase5 with parameters of type IAggregateSymbol

Modifier	Constructor	Description
(package private)	TraitAnalysis(IAggregateSymbol trait, String traitName, int traitMethodCount, int overriddenMethodCount, boolean hasCompatibleField, String compatibleFieldName)	Creates an instance of a TraitAnalysis record class.

Constructor parameters in org.ek9lang.compiler.phase5 with type arguments of type IAggregateSymbol

Modifier	Constructor	Description
(package private)	SharedTypeClosure(ConcreteSubtypeFinder subtypeFinder, Predicate<IAggregateSymbol> keepsOwnDomain)

Uses of IAggregateSymbol in org.ek9lang.compiler.phase5.construction

Methods in org.ek9lang.compiler.phase5.construction that return IAggregateSymbol

Modifier and Type	Method	Description
IAggregateSymbol	ConstructionEdges.InstanceInitTarget.aggregate()	Returns the value of the aggregate record component.

Constructors in org.ek9lang.compiler.phase5.construction with parameters of type IAggregateSymbol

Modifier	Constructor	Description
	InstanceInitTarget(IAggregateSymbol aggregate)	Creates an instance of a InstanceInitTarget record class.

Uses of IAggregateSymbol in org.ek9lang.compiler.phase7

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

Modifier and Type	Method	Description
IAggregateSymbol	ConstrainedTypeShape.baseType()	Returns the value of the baseType record component.

Constructors in org.ek9lang.compiler.phase7 with parameters of type IAggregateSymbol

Modifier	Constructor	Description
(package private)	ConstrainedTypeShape(AggregateSymbol constrainedType, String constrainedTypeName, IAggregateSymbol baseType, String baseTypeName, EK9Parser.ConstrainTypeContext constraint)	Creates an instance of a ConstrainedTypeShape record class.

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

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

Modifier and Type	Method	Description
IAggregateSymbol	IteratorSetup.collectionType()	Returns the value of the collectionType record component.
IAggregateSymbol	BucketTracker.producesType()	Returns the value of the producesType record component.
IAggregateSymbol	IteratorSetup.type()	Returns the value of the type record component.
IAggregateSymbol	TerminalSetup.type()	Returns the value of the type record component.

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

Modifier and Type	Method	Description
(package private) SortSetup	StreamEmissionEngine.applySortToCollection(List<EK9Parser.StreamPartContext> stages, IteratorSetup iteratorSetup, ISymbol elementType, IAggregateSymbol collectionType, org.antlr.v4.runtime.tree.ParseTree probeSite, DebugInfo debugInfo, List<IRInstr> instructions)
List<IRInstr>	CloseChain.closeOperator(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	The body of a type's close followed, on every path, by its generated chain.
List<IRInstr>	CloseChain.constructionFailure(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	A constructor's work after its construction call, with the chain run only if it fails.
List<IRInstr>	CloseChain.constructionFailureInOwnScope(List<IRInstr> body, IAggregateSymbol aggregate, DebugInfo debugInfo)	CloseChain.constructionFailure(List, IAggregateSymbol, DebugInfo) in a scope of its own (SCOPE_ENTER/SCOPE_EXIT around it), so what the region registers has an entered scope to be released by: a generated constructor has no body scope, and a written one's region sits after its body scope has been left (or, after an explicit super(...), inside it).
(package private) String	IterationSourceLowering.enumInstanceForIteration(IAggregateSymbol enumType, DebugInfo debugInfo, List<IRInstr> instructions)	An unset instance of an enumeration type, made by its default constructor, in a fresh managed temp.
(package private) List<IRInstr>	StreamPipelineMachinery.generatePipelineItemBinding(String iteratorVar, IAggregateSymbol iteratorType, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, boolean rawIterator)	Generate: pipelineItem = iterator.next() Follows ForInGenerator.generateLoopVariableBinding() pattern.
boolean	CloseChain.isEmpty(IAggregateSymbol aggregate)	True when a close of this type generates nothing.
(package private) String	IterationSourceLowering.iteratorOf(IAggregateSymbol sourceType, String sourceVar, IAggregateSymbol iteratorType, DebugInfo debugInfo, List<IRInstr> instructions)	sourceVar.iterator() into a fresh managed temp, typed iteratorType.
(package private) String	CoverageSourceName.ofAggregate(IAggregateSymbol aggregate)	The aggregate's source-level name - the generic it parameterises when it is a monomorphisation, otherwise its own name.
(package private) String	IterationSourceLowering.sourceValue(EK9Parser.ExpressionContext sourceCtx, IAggregateSymbol sourceType, DebugInfo debugInfo, List<IRInstr> instructions)	The source's value in a fresh managed temp: the enumeration instance (IterationSourceLowering.enumInstanceForIteration(IAggregateSymbol, DebugInfo, List)) or the evaluated expression.

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

Modifier	Constructor	Description
(package private)	BucketTracker(String variable, String helperType, IAggregateSymbol producesType)	Creates an instance of a BucketTracker record class.
(package private)	IteratorSetup(String variable, IAggregateSymbol type, IAggregateSymbol collectionType)	Creates an instance of a IteratorSetup record class.
(package private)	TerminalSetup(String variable, IAggregateSymbol type, MethodSymbol resolvedPipeMethod, ISymbol consumesType)	Creates an instance of a TerminalSetup record class.

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

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

Modifier and Type	Method	Description
List<IRInstr>	CycleGuardOwner.initialise(IAggregateSymbol aggregate, String tempVar, DebugInfo debugInfo)	Make the constant, once, in the type's _c_init.
IRInstr	CycleGuardOwner.load(String resultVar, IAggregateSymbol aggregate, DebugInfo debugInfo)	Load the constant for a guarded operator - a borrowed reference, neither retained nor released.
static ConstrainedEnumSubset	ConstrainedEnumSubset.of(AggregateSymbol constrainedType, IAggregateSymbol baseEnum)	The subset of baseEnum admitted by constrainedType's constraint.

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

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

Modifier and Type	Method	Description
protected String	AbstractSyntheticGenerator.differentTypeLabel(IAggregateSymbol owner, MethodSymbol operator)	The "different run-time type" label of a generated sameness comparison that needs THE run-time-type check (SamenessTypeCheck, D24 rule 3, Contract 22), else null - and then nothing is generated for it, so a comparison that needs no check keeps exactly its IR.
protected boolean	AbstractSyntheticGenerator.isAnyType(IAggregateSymbol type)	Check if the given type is the Any type.
protected Optional<MethodSymbol>	AbstractSyntheticGenerator.nearestSuperOperator(IAggregateSymbol aggregateSymbol, String operatorName)	THE super operator a generated operator calls: the NEAREST declaration above the type, across the whole super chain (NearestOperatorAbove, never Any's), when it has a body.
protected String	AbstractSyntheticGenerator.servingOperatorParameterTypeName(IAggregateSymbol aggregate, String jvmMethodName)	The parameter type of the operator that actually serves this <op> other when other is this aggregate too - THE descriptor a synthesised delegation (<> to ==, < and the rest to <=>) must call.
protected String	AbstractSyntheticGenerator.superCallOwner(IAggregateSymbol aggregateSymbol, String operatorName)	The fully qualified name of the type that OWNS the nearest super operator - the type a generated super call names (Contract 19).
protected String	AbstractSyntheticGenerator.superCallParameterTypeName(IAggregateSymbol aggregateSymbol, String operatorName)	The fully qualified name of the parameter type the nearest super operator DECLARES - the argument type a generated CALL (Owner)super._x(param) names, read off the operator that serves the call (as OperatorTargetMethodResolver.declaredParameterTypes(ISymbol, String, List) does for every other synthesised call), never assumed to be the owner: Exception's <=> takes Any, and a default operator <=> on a sub-type of it named Exception._cmp(Exception) - a NoSuchMethodError at run time (D56).
protected boolean	AbstractSyntheticGenerator.superContributesRepresentation(IAggregateSymbol aggregateSymbol, String operatorName)	Does this type's super contribute to its '$' / '$$'? Only when the NEAREST operator above it (AbstractSyntheticGenerator.nearestSuperOperator(IAggregateSymbol, String)) can render something: never an abstract one (nothing to call), a hand-written one always may (it is honoured, whatever it returns), a GENERATED one only when its owner's chain has fields to render (HasFieldsIncludingInherited).

Uses of IAggregateSymbol in org.ek9lang.compiler.search

Methods in org.ek9lang.compiler.search with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
MatchResults	FuzzySymbolSearch.findSimilarMethods(IAggregateSymbol aggregate, String methodName)	Search for methods with names similar to the target method name in the given aggregate and its super aggregates.
MatchResults	FuzzySymbolSearch.findSimilarProperties(IAggregateSymbol aggregate, String propertyName)	Search for properties with names similar to the target property name in the given aggregate.

Uses of IAggregateSymbol in org.ek9lang.compiler.support

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

Modifier and Type	Class	Description
final class	CapturedPropertiesRecorder	Records what the captures of a dynamic class are to its constructors (phase 3 only, once the capture constructor is decided).
(package private) class	CheckAndPopulateOperator	Deals with normal operators (i.e.
final class	CheckForDuplicateOperationsOnGeneric	If the aggregate is a generic parameterised type this function triggers a check for duplicated methods.
final class	ConstrainedBase	THE recovery of the base type a CONSTRAINED type narrows — call this, do not re-derive it.
final class	ConstrainedEnumerationBase	The base enumeration of a CONSTRAINED enumeration (RedSuit as CardSuit constrain as ...); empty for a base enumeration and for anything not enumeration-based.
final class	ConstrainedEnumerationBase	The base enumeration of a CONSTRAINED enumeration (RedSuit as CardSuit constrain as ...); empty for a base enumeration and for anything not enumeration-based.
final class	ConstructorProperties	THE properties a constructor of aggregate is responsible for: for a dynamic class its captures first (they live in the capture scope, not the class's own symbol table), then its DeclaredProperties.
final class	CopyConstructor	THE copy constructor of a type: a PUBLIC constructor taking exactly one argument of EXACTLY that type - Step(Step).
final class	DeclaredProperties	THE properties a type DECLARES itself, the property half of the fields an object of it carries (the other half, for a dynamic class, is CapturedVariables).
final class	DefaultedComparisonDelegate	THE decision of which operator a GENERATED comparison is answered by - hold one and use it, do not re-derive it.
final class	DefaultOperatorCoverage	THE test of whether a type already has what a default operator would give it - hold one and apply it, do not re-derive it.
final class	FieldlessIsSet	THE rule of Q-COMPONENT-? (Steve, 2026-10-07): a type with NO fields, counting inherited ones, is set whenever it is present.
final class	HasFieldsIncludingInherited	THE "does this type have any fields, counting inherited ones?" (Steve, 2026-10-07, Q-COMPONENT-?): its own fields (GeneratedOperatorFields - properties and a dynamic class's captures) or any property of a super, all the way up.
final class	HasPropertyCycle	THE reading of phase 5's property-cycle mark (phase5/PropertyCycleMarker): can an object of this type reach itself through its properties? Hold one and ask it - never the squirrelled data directly.
final class	InheritedSlotCount	The slots an aggregate's super chain occupies before its own properties in the flat field layout (FieldSlots): each super's properties, up to the first extern base, which adds its native footprint (ExternFootprint) and ends the walk.
final class	InstanceInitIdentity	The call-graph identity of an aggregate's property initialisers - module::Aggregate._i_init(), the method the generated code runs them in, and the name a stack trace shows.
final class	IsEnumerationType	THE "is this an enumeration TYPE, a base enumeration or a constrained one?" - IsEnumeration, or a constrained type over an enumeration (ConstrainedEnumerationBase).
final class	LeftOutOfHash	THE "must a generated #? on this type leave this field out?" - the reading of phase 5's property-cycle marks (phase5/PropertyCycleMarker) for the hash (Contract 13).
final class	NoArgumentConstructor	THE no-argument constructor of a type, whatever its access - Counter().
final class	NoDuplicateOperationsOrError	Does a simple check (excluding any inheritance) for duplicated operations (methods, operators) on any sort of Aggregate, i.e.
final class	OverriddenDeclarations	THE parent declarations a method overrides - hold one and apply it, do not re-derive it.
final class	OverriddenEntryPoint	THE super's dispatcher entry point that a sub-type's entry point overrides: the super's effective dispatcher method with exactly the same signature - what a synthesised InheritedDispatcher entry point calls.
final class	OwnProperty	THE "is this a property of the object whose code is running?" - use it, never re-derive it.
final class	ProgramOfBody	THE reading of a program's body - use it, never a private "_main" test.
final class	TypeParameterConstraint	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?".
final class	TypeParameterConstraint	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?".

Fields in org.ek9lang.compiler.support with type parameters of type IAggregateSymbol

Modifier and Type	Field	Description
(package private) final Function<IAggregateSymbol, String>	CheckAndPopulateOperator.messageFor

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

Modifier and Type	Method	Description
Optional<IAggregateSymbol>	ConstrainedEnumerationBase.apply(IAggregateSymbol type)
Optional<IAggregateSymbol>	ProgramOfBody.apply(ISymbol symbol)	The program whose body this symbol is - empty for anything else.
Optional<IAggregateSymbol>	TypeParameterConstraint.apply(IAggregateSymbol t)	The type this 'T' was constrained by, or empty when it is unconstrained (or not yet set up).
Optional<IAggregateSymbol>	ConstructionSteps.implicitSuper()	Returns the value of the implicitSuper record component.

Methods in org.ek9lang.compiler.support with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
void	CapturedPropertiesRecorder.accept(IAggregateSymbol dynamicClass, List<ISymbol> capturedVariables)
void	CheckForDuplicateOperationsOnGeneric.accept(IToken errorLocationToken, IAggregateSymbol aggregate)
void	NoDuplicateOperationsOrError.accept(IToken errorLocationToken, IAggregateSymbol aggregate)
void	NoDuplicateOperationsOrError.acceptImplementedOnly(IToken errorLocationToken, IAggregateSymbol aggregate)	The duplicate check over the construct's IMPLEMENTED (non-abstract) methods only - for a text locale variant.
void	AggregateManipulator.addAllSyntheticOperators(IAggregateSymbol t)	Add all possible synthetic operators to the aggregate.
void	AggregateManipulator.addCaptureConstructorIfRequired(IAggregateSymbol aggregateSymbol, List<ISymbol> capturedVariables)	THE capture constructor of a dynamic class (IsCaptureConstructor): the constructor whose parameter types are EXACTLY the capture types, in order.
MethodSymbol	AggregateManipulator.addComparatorOperator(IAggregateSymbol aggregateSymbol, String comparatorType, Optional<ISymbol> returnType)	Adds a form of a comparison operator.
void	AggregateManipulator.addComparatorOperator(IAggregateSymbol aggregateSymbol, IAggregateSymbol arg0, String comparatorType, Optional<ISymbol> returnType)	Adds a form of a comparison operator.
void	AggregateManipulator.addConstrainingTypeConstructors(IAggregateSymbol t, IAggregateSymbol constrainingType)	Clone the constraining type's constructors onto a constrained 'T', so T can be constructed with the same arguments (implemented as a call to the super).
MethodSymbol	AggregateManipulator.addConstructor(IAggregateSymbol t)	Create a new constructor for the aggregate with no params.
MethodSymbol	AggregateManipulator.addConstructor(IAggregateSymbol aggregateSymbol, List<ISymbol> constructorArguments, boolean synthetic, boolean markedPure)
void	AggregateManipulator.addConstructorIfRequired(IAggregateSymbol aggregateSymbol, List<ISymbol> constructorArguments, boolean synthetic)	Add a new constructor if not present, marked as synthetic.
boolean	OperationFactory.addMissingDefaultOperators(EK9Parser.DefaultOperatorContext ctx, IAggregateSymbol aggregate)	A bit of a beast this method.
boolean	SymbolFactory.addMissingDefaultOperators(EK9Parser.DefaultOperatorContext ctx, IAggregateSymbol aggregate)	A bit of a beast this method.
void	AggregateManipulator.addMutatingVoidOperator(IAggregateSymbol aggregate, String operatorName)	Creates a public mutating operator that takes no arguments and returns void.
void	AggregateManipulator.addPurePublicReturnSameTypeMethod(IAggregateSymbol aggregate, String methodName)
MethodSymbol	AggregateManipulator.addPurePublicSimpleOperator(IAggregateSymbol aggregateSymbol, String methodName, Optional<ISymbol> returnType)	Adds a simple operator, that is 'pure' (no side effects) and accepts no parameters, but just returns a value.
void	AggregateManipulator.addSyntheticConstructorIfRequired(IAggregateSymbol aggregateSymbol)	Add a synthetic constructor, if a constructor is not present.
void	AggregateManipulator.addSyntheticConstructorIfRequired(IAggregateSymbol aggregateSymbol, List<ISymbol> constructorArguments)	Add a synthetic constructor, if a constructor is not present.
MethodSymbol	CheckAndPopulateOperator.apply(EK9Parser.OperatorDeclarationContext ctx, IAggregateSymbol aggregate)
ISymbol	ConstrainedBase.apply(IAggregateSymbol aggregate)	The base type aggregate constrains, or null when it has no such constructor (so it is not a constrained type, or the compiler did not synthesise one).
Optional<IAggregateSymbol>	ConstrainedEnumerationBase.apply(IAggregateSymbol type)
List<ISymbol>	ConstructorProperties.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	CopyConstructor.apply(IAggregateSymbol type)	The public copy constructor of type, if it has one.
List<ISymbol>	DeclaredProperties.apply(IAggregateSymbol aggregateSymbol)	The aggregate's own properties - none for an enumeration, whose values are constants, not fields.
DefaultedComparisonDelegate.Resolver	DefaultedComparisonDelegate.apply(IAggregateSymbol aggregate, ISymbol ek9Any)
Optional<MethodSymbol>	DefaultOperatorCoverage.apply(IAggregateSymbol aggregate, String operator)	The type's own operator that already serves default operator <operator>, if any.
String	InstanceInitIdentity.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	NoArgumentConstructor.apply(IAggregateSymbol type)	The no-argument constructor of type, if it has one (private, protected or public).
List<MethodSymbol>	OverriddenDeclarations.apply(IAggregateSymbol aggregate, MethodSymbol method)	Every parent declaration with exactly this method's signature - at most one per parent - private ones included: a private parent member is not inherited, so not overridden, and the caller decides what that means.
Optional<MethodSymbol>	OverriddenEntryPoint.apply(IAggregateSymbol aggregate, MethodSymbol entryPoint)
Optional<IAggregateSymbol>	TypeParameterConstraint.apply(IAggregateSymbol t)	The type this 'T' was constrained by, or empty when it is unconstrained (or not yet set up).
int	InheritedSlotCount.applyAsInt(IAggregateSymbol aggregate)
List<MethodSymbol>	DispatcherHandlers.collectFor(IAggregateSymbol aggregate, MethodSymbol dispatcher)	The handlers for dispatcher on aggregate: every non-abstract, non-constructor, non-operator, non-dispatcher method across the inheritance chain with the same name and arity.
void	OperationFactory.completeBareDefaultOperators(EK9Parser.DefaultOperatorContext ctx, IAggregateSymbol aggregate)	Completes a bare 'default operator' once types are known - THE second half of OperationFactory.addMissingDefaultOperators(EK9Parser.DefaultOperatorContext, IAggregateSymbol).
void	SymbolFactory.completeBareDefaultOperators(EK9Parser.DefaultOperatorContext ctx, IAggregateSymbol aggregate)	Completes a bare 'default operator' once types are known: the self-typed defaults a same-NAME operator taking a different argument hid from phase 1 (FE74, F2).
void	OperationFactory.completeFieldlessIsSet(IAggregateSymbol aggregate)	Gives a type with no fields, counting inherited ones, its synthesised '?' (Q-COMPONENT-?, Steve 2026-10-07): present means set.
void	SymbolFactory.completeFieldlessIsSet(IAggregateSymbol aggregate)	Gives a type with no fields, counting inherited ones, its synthesised '?' (Q-COMPONENT-?).
void	OperationFactory.completeSameness(IAggregateSymbol aggregate, IToken bareToken)	THE completion of a type's sameness once types are known (B18 - a type defines sameness once; Steve, 2026-09-30).
void	SymbolFactory.completeSameness(IAggregateSymbol aggregate, IToken bareToken)	Completes a type's sameness once types are known (B18).
MethodSymbol	AggregateManipulator.createMutatingVoidOperator(IAggregateSymbol aggregateSymbol, String operatorName)	Creates a mutating void operator with no parameters.
MethodSymbol	AggregateManipulator.createMutatorOperator(IAggregateSymbol aggregateSymbol, String operatorType)	Create an operator of the name supplied.
MethodSymbol	AggregateManipulator.createMutatorOperatorReturnVoid(IAggregateSymbol aggregateSymbol, String operatorType)	Create an operator of the name supplied.
MethodSymbol	AggregateManipulator.createOperator(IAggregateSymbol aggregateSymbol, String operatorType, boolean isPure)	Create an operator of the name supplied.
MethodSymbol	AggregateManipulator.createPureAcceptSameTypeOperatorAndReturnType(IAggregateSymbol aggregateSymbol, String comparatorType, Optional<ISymbol> returnType)	Creates a pure method with an argument the same as the main type.
MethodSymbol	AggregateManipulator.createPureArgumentOperatorAndReturnType(IAggregateSymbol aggregateSymbol, IAggregateSymbol arg0, String comparatorType, Optional<ISymbol> returnType)	Creates a pure method with an argument of a different type as the main type.
MethodSymbol	AggregateManipulator.createPurePublicReturnSameTypeMethod(IAggregateSymbol aggregateSymbol, String methodName)
MethodSymbol	AggregateManipulator.createPurePublicSimpleOperator(IAggregateSymbol aggregateSymbol, String methodName, Optional<ISymbol> returnType)	Just creates a public operator with the name specified.
List<MethodSymbol>	DispatcherHandlers.entryPointsOf(IAggregateSymbol aggregate)	THE dispatcher entry points of an aggregate: every non-operator method marked as dispatcher, drawn from the FULL inheritance chain.
boolean	NoNameCollisionOrError.errorsIfLocalNamedLikeAMethod(IAggregateSymbol aggregate, ISymbol symbol)	A LOCAL variable may not take the name of a method of the type it is declared in (its own - private included - or one it inherits or takes from a trait, unless that one is private and so unreachable here): total <- total() means a value on the left and a call on the right, and with the local in scope a bare 'total()' no longer reaches the method (it surfaced as E50010 'type not resolved', 2026-10-01).
List<MethodSymbol>	AggregateManipulator.getAllPossibleDefaultOperators(IAggregateSymbol aggregate)	Provides all the possible default operators.
(package private) List<MethodSymbol>	OperatorFactory.getAllPossibleDefaultOperators(IAggregateSymbol aggregate)
(package private) List<MethodSymbol>	OperatorFactory.getAllPossibleSyntheticOperators(IAggregateSymbol aggregate)
Optional<MethodSymbol>	AggregateManipulator.getDefaultOperator(IAggregateSymbol aggregate, String operator)	If the operator provided can be defaulted then a Method symbol with the correct signature will be returned.
(package private) MethodSymbol	OperatorFactory.getDefaultOperator(IAggregateSymbol aggregate, String operator)
MethodSymbol	OperationFactory.newOperator(EK9Parser.OperatorDeclarationContext ctx, IAggregateSymbol aggregate)	Create a new aggregate that represents an EK9 operator, uses a method for this.
MethodSymbol	SymbolFactory.newOperator(EK9Parser.OperatorDeclarationContext ctx, IAggregateSymbol aggregate)	Create a new aggregate that represents an EK9 operator, uses a method for this.
boolean	AggregateManipulator.superHasAccessibleNoArgConstructor(IAggregateSymbol aggregateSymbol)	THE test of whether an implicit super() from this aggregate can reach its super: true when there is no real super (none, or the implicit Any), or the super has a no-argument constructor that is not private.
boolean	FieldlessIsSet.test(IAggregateSymbol aggregate)	Is this a type that gets the synthesised '?': a class (dynamic classes included), component or service with no fields, counting inherited ones, and no '?' of its own or from any super or trait (other than Any's).
boolean	HasFieldsIncludingInherited.test(IAggregateSymbol aggregateSymbol)
boolean	HasPropertyCycle.test(IAggregateSymbol aggregate)
boolean	IsEnumerationType.test(IAggregateSymbol type)
boolean	LeftOutOfHash.test(IAggregateSymbol owner, ISymbol field)	Must a generated #? on this type leave this field out?
boolean	OwnProperty.test(ISymbol candidate, IAggregateSymbol aggregate)	True when candidate is one of aggregate's own declared properties - by identity, never by name.
void	AggregateManipulator.updateToConstrainBy(IAggregateSymbol t, IAggregateSymbol constrainingType)	This is the idea where a 'T' is constrained to only be a type or a subtype of that type.

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

Modifier	Constructor	Description
	ConstructionSteps(Optional<IAggregateSymbol> implicitSuper, boolean runsInstanceInit)	Creates an instance of a ConstructionSteps record class.

Uses of IAggregateSymbol in org.ek9lang.compiler.support.closeables

Classes in org.ek9lang.compiler.support.closeables that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
final class	ChainedCloses	Every type a close of this type reaches through its chain - the static types of the closed fields and the owner of the parent close - for the call graph (each is called by the generated close).
final class	ClosedProperties	The fields the type's close closes, in acquisition order: owned captures (OwnedCaptures), then own closeable properties - never an injected one, nor the delegate a by-delegation proxy close forwards to (the exclusions are listed on CloseSteps).
final class	CloseStepsOf	THE generated chain of a type's close (CloseSteps): what it closes (ClosedProperties) and the parent close it then calls (ParentClose).
final class	DeclaredClose	The close operator this type declares itself, if any: own scope, not abstract, not a delegation proxy.
(package private) final class	OwnCloseOperator	The no-argument close operator in the type's own scope, whatever it is (abstract, proxy or written).
final class	OwnedCaptures	The captures a dynamic class owns: each one PRE_IR_CHECKS marked as a fresh closeable (R-E).
final class	ParentClose	The close of the nearest super CLASS that has one, when it is not abstract.

Methods in org.ek9lang.compiler.support.closeables with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
List<MethodSymbol>	ChainedCloses.apply(IAggregateSymbol aggregate)
List<ISymbol>	ClosedProperties.apply(IAggregateSymbol aggregate)
CloseSteps	CloseStepsOf.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	DeclaredClose.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	OwnCloseOperator.apply(IAggregateSymbol aggregate)
List<ISymbol>	OwnedCaptures.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	ParentClose.apply(IAggregateSymbol aggregate)

Uses of IAggregateSymbol in org.ek9lang.compiler.support.conceptual

Classes in org.ek9lang.compiler.support.conceptual that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
final class	IsComparedByCoalescing	THE "does the generic's body select between values of this conceptual T with a comparison coalescing operator" (NoteCoalescingComparison).
final class	NoteCoalescingComparison	THE note that the generic's body selects between values of its conceptual T with <? or >? (D24 Q4 REVISED).
final class	NoteIfConceptual	THE note of an operator the body used on owner, but only when owner IS a conceptual type parameter - a concrete type needs no deferred check.
final class	TypeParametersUnder	THE conceptual parameters a (non-bare) parameterisation is built on, each once; for a generic template (named in its own body) its own type parameters.

Methods in org.ek9lang.compiler.support.conceptual that return types with arguments of type IAggregateSymbol

Modifier and Type	Method	Description
List<IAggregateSymbol>	TypeParametersUnder.apply(ISymbol type)

Methods in org.ek9lang.compiler.support.conceptual with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
void	NoteCoalescingComparison.accept(IAggregateSymbol conceptualT)
void	NoteIfConceptual.accept(IAggregateSymbol owner, MethodSymbol operator)
void	NoteOrderingUse.note(IAggregateSymbol owner, MethodSymbol operator, boolean writtenAsAnOperatorCall)	Note the ordering use, when the operator is an ordering operator.
boolean	IsComparedByCoalescing.test(IAggregateSymbol conceptualT)

Uses of IAggregateSymbol in org.ek9lang.compiler.support.copy

Classes in org.ek9lang.compiler.support.copy that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
final class	CopyNeedsRuntimeCheck	THE "can a copy into this owner meet an object of a different class?" - only when the owner may have sub-types.
(package private) final class	CopyOwnerGenus	Is the aggregate of a genus that can own a copy: the extensible data-carrying aggregates (a trait is an interface, and has no fields to copy).
final class	HasGeneratedSelfCopy	THE "is the aggregate's self copy GENERATED" (SelfCopy, IsGeneratedCopy).
final class	InheritedCopySignatures	THE inherited :=:(Super) signatures a GENERATED copy owner overrides (Q5b, PolymorphicCopy): every :=: declared up its super CLASS chain (AllOperatorsAbove) whose single parameter is a super type of the owner - one per distinct parameter type, nearest first - unless the owner itself already declares that signature.
final class	IsCopyOwner	THE "is this aggregate a copy OWNER" - does it declare its own :=: taking itself (SelfCopy)? E07238 guarantees a class adding fields is one (PolymorphicCopy).
final class	NeedsCopyAccepts	THE "does the owner get a _copyAccepts?" (PolymorphicCopy).
final class	SelfCopy	THE self copy of an aggregate: the :=: it declares in its OWN scope that takes the aggregate itself (PolymorphicCopy).

Methods in org.ek9lang.compiler.support.copy with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
List<MethodSymbol>	InheritedCopySignatures.apply(IAggregateSymbol owner, ISymbol ek9Any)
Optional<MethodSymbol>	SelfCopy.apply(IAggregateSymbol aggregate)
boolean	CopyNeedsRuntimeCheck.test(IAggregateSymbol owner)
boolean	CopyOwnerGenus.test(IAggregateSymbol aggregate)
boolean	HasGeneratedSelfCopy.test(IAggregateSymbol aggregate)
boolean	IsCopyOwner.test(IAggregateSymbol aggregate)
boolean	NeedsCopyAccepts.test(IAggregateSymbol owner, ISymbol ek9Any)

Uses of IAggregateSymbol in org.ek9lang.compiler.support.operators

Classes in org.ek9lang.compiler.support.operators that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
final class	AlwaysSetWhenPresent	THE "is a value of EXACTLY this type always set - its '?' the one synthesised for a field-less type (IsSynthesisedIsSet, Q-COMPONENT-?), answering true?" Read by phase 5's value tracker (F3, Steve 2026-10-07): s <- FieldlessType() then if s? is provably true (E08088), as Integer() is provably unset.
final class	DeclaredOperator	THE operator of one name a type declares in its OWN scope, preferring the overload that takes the type itself when there are several (ExactSingleParameter) - and otherwise ANY overload (a zero-argument $ or ? has no parameter to match).
final class	HasAuthoredIsSet	THE "does the author's source give this type its OWN '?'" - hand-written, default operator ? or the bare default operator - for tools that edit source (adding a type's first field must also add a '?', E07235).
final class	NarrowedReturnTypes	THE return types of the (non-private) parent declarations a method overrides (OverriddenDeclarations) with a NARROWER - covariant - return, one per distinct type (N07, phase 7's covariant bridges).
final class	NearestAbove	THE nearest declaration above an aggregate that a level test finds - asked of each super class in turn, nearest first (SuperClassChain).
final class	NearestAbove	THE nearest declaration above an aggregate that a level test finds - asked of each super class in turn, nearest first (SuperClassChain).
final class	OperatorDeclarationSite	THE place a missing operator belongs when NOTHING above an aggregate declares it (Q4, Steve 2026-10-08): the nearest super class that HAS fields of its own - the root of the data decides whether its fields are exposed (R4) - or, when no super class has fields, the topmost one (the hierarchy's root below Any).
final class	OperatorDeclarationSite	THE place a missing operator belongs when NOTHING above an aggregate declares it (Q4, Steve 2026-10-08): the nearest super class that HAS fields of its own - the root of the data decides whether its fields are exposed (R4) - or, when no super class has fields, the topmost one (the hierarchy's root below Any).
final class	OperatorOwner	THE type that declares an operator - its OWNER, which a generated super call names (Contract 19, NearestOperatorAbove).
(package private) final class	SuperClassChain	The super CLASS chain above an aggregate, nearest first - the walk every "operator above" question shares (NearestOperatorAbove).
(package private) final class	SuperClassChain	The super CLASS chain above an aggregate, nearest first - the walk every "operator above" question shares (NearestOperatorAbove).

Methods in org.ek9lang.compiler.support.operators that return IAggregateSymbol

Modifier and Type	Method	Description
IAggregateSymbol	OperatorOwner.apply(MethodSymbol operator)

Methods in org.ek9lang.compiler.support.operators that return types with arguments of type IAggregateSymbol

Modifier and Type	Method	Description
Optional<IAggregateSymbol>	OperatorDeclarationSite.apply(IAggregateSymbol aggregate, ISymbol ek9Any)
List<IAggregateSymbol>	SuperClassChain.apply(IAggregateSymbol aggregate)

Methods in org.ek9lang.compiler.support.operators with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
Optional<MethodSymbol>	DeclaredOperator.apply(IAggregateSymbol aggregate, String operatorName)
List<ISymbol>	NarrowedReturnTypes.apply(IAggregateSymbol aggregate, MethodSymbol method)	Empty for a method that overrides nothing or keeps every parent's return type.
Optional<MethodSymbol>	NearestAbove.apply(IAggregateSymbol aggregate, Function<IAggregateSymbol, Optional<MethodSymbol>> declaredOn)
Optional<IAggregateSymbol>	OperatorDeclarationSite.apply(IAggregateSymbol aggregate, ISymbol ek9Any)
List<IAggregateSymbol>	SuperClassChain.apply(IAggregateSymbol aggregate)
List<MethodSymbol>	AllOperatorsAbove.of(IAggregateSymbol aggregate, String operatorName, ISymbol ek9Any)	Every declaration above, nearest level first.
Optional<MethodSymbol>	NearestOperatorAbove.of(IAggregateSymbol aggregate, String operatorName, ISymbol ek9Any)	The nearest operator called operatorName declared ABOVE the aggregate, never Any's: Any declares ? $ $$ #? == <=> for every type, which says nothing about a hierarchy's data.
Optional<MethodSymbol>	NearestSelfComparisonAbove.of(IAggregateSymbol aggregate, String operatorName, ISymbol ek9Any)	The nearest self-comparison above, if any.
boolean	AlwaysSetWhenPresent.test(IAggregateSymbol aggregate)
boolean	HasAuthoredIsSet.test(IAggregateSymbol aggregate)

Method parameters in org.ek9lang.compiler.support.operators with type arguments of type IAggregateSymbol

Modifier and Type	Method	Description
Optional<MethodSymbol>	NearestAbove.apply(IAggregateSymbol aggregate, Function<IAggregateSymbol, Optional<MethodSymbol>> declaredOn)

Uses of IAggregateSymbol in org.ek9lang.compiler.support.sameness

Classes in org.ek9lang.compiler.support.sameness that implement interfaces with type arguments of type IAggregateSymbol

Modifier and Type	Class	Description
(package private) final class	ComparedFieldsOf	The fields a generated <=> walks for one type: its properties and, for a dynamic class, its captures (GeneratedOperatorFields; D62 - a capture is a field, not a property).
(package private) final class	DeclaredOrderingAbove	The nearest concrete <=> above the type that compares its level with itself, read from the methods as DECLARED - a retracted one included (getAllNonAbstractMethodsInThisScopeOnly does not filter the retraction), so OrderingAvailability.orderingSurvives(MethodSymbol, ISymbol) gives the same answer whichever types phase 5 has already visited.
(package private) final class	DeclaredOrderingAt	The concrete <=> this one LEVEL declares comparing itself with itself, read as DECLARED (a retracted one included), preferring the one taking exactly the level.
final class	DeclaredSameness	THE sameness a type itself declares (B18) - its own non-abstract <=> comparing it with itself, else its == - hand-written or defaulted, never one GENERATED from it (IsGeneratedFromSameness).
final class	HasHandWrittenEquality	THE "did the developer write an == that takes the type itself" (not a defaulted one).
final class	HasOwnComparator	THE "has the aggregate its own REAL <=> that takes itself" - hand-written, or defaulted (and not retracted) over fields that can all really be ordered.
final class	InheritedSameness	THE sameness a type INHERITS - from its super chain (stopping before Any) or any of its traits (its own, a super's, a trait's trait) - if any, sealed or not.
final class	IsDerivedComparison	THE "is this a comparison B18 generates from the sameness?": a <> < <= > >= comparing the owner with itself (IsSelfComparison) - always generated, never written.
final class	IsHierarchyWideSameness	THE "is the sameness this type declares ONE sameness for its whole hierarchy?" (D24 rule 1).
final class	IsSamenessOperator	THE "is this a declaration of its owner's sameness?" (B18): a <=> or == comparing the owner with itself (IsSelfComparison).
final class	IsSelfComparison	THE "does this operator compare its owner with ITSELF?" of B18 (Sameness): an operator taking exactly one argument of a type the owner is assignable to.
final class	MayMixRuntimeTypes	THE test behind E07187 (D24 Q4 REVISED, Steve 2026-10-20): can two values of this type be of DIFFERENT run-time types whose <=> is UNSET? Then <? and >? have no lesser or greater value to select, and an unset value cannot be built to stand in for one (a T() may be set, absent, private or abstract, and would run developer code).
final class	MixingKind	For a message: how a type for which MayMixRuntimeTypes holds can have values of different run-time types - "a trait", or "an abstract" / "an open" followed by "class", "record" or "component".
final class	NearestSamenessAbove	THE sameness a type would inherit through its super CLASS chain (D24 follow-up Q5, Steve 2026-10-20): the nearest concrete <=> comparing its owner with itself (NearestSelfComparisonAbove) - the super is ORDERED - else the nearest such == - the super is EQUATABLE only.
final class	NearestSurvivingSamenessAbove	THE sameness a type that declares none of its own gets from its super CLASS chain once PRE_IR_CHECKS has run (D55): NearestSamenessAbove, but a <=> that does not survive (OrderingAvailability.orderingSurvives(MethodSymbol, ISymbol)) is passed over for the nearest == - the super is EQUATABLE only.
final class	NeedsRuntimeTypeCheck	THE test of whether a sameness comparison - the type's == or <=>, hand-written or generated, or a generated ==/<> answered by its <=> - needs the run-time-type check in front of it (D24 rule 3, Contract 22): values of different run-time types are never the same.
final class	OverriddenSamenessSignatures	THE inherited sameness signatures a type with its own sameness OVERRIDES (D24 rule 3; N07 - the object decides, never the reference): for each of == and <=> the type declares taking exactly itself, every same-named comparison above it on its super CLASS chain (AllOperatorsAbove) that takes a type the owner is assignable to and that the owner does not declare itself (OwnOperatorTaking).
final class	RetractWithdrawnBareOrdering	THE retraction step (D55/D58/D62): when OrderingAvailability.bareOrderingRetracted(IAggregateSymbol, ISymbol) says the type's bare ordering is withdrawn, mark each of its bare ordering operators (<=>, <, <=, >, >=) DEFAULT_OPERATOR_RETRACTED, which the type's method set then filters out, so none is generated.
final class	SealedSameness	THE SEALED sameness a type inherits (D24 rule 1) - one written by hand on an abstract base or a trait above it (IsHierarchyWideSameness) - if any.
final class	SortOwnerAbove	THE sort owner of a type (D52 residual, Steve 2026-10-21, option a): the type a stream sort groups its values by before comparing any two with <=>.
final class	WhyNotOrderable	THE wording of why a type has no <=> although it asked for one with the bare default operator (D58): the field whose type cannot be ordered, the type declaring it and - only where that is a super - that a sub-type follows its super.

Methods in org.ek9lang.compiler.support.sameness that return IAggregateSymbol

Modifier and Type	Method	Description
(package private) IAggregateSymbol	SamenessAbove.declaringType(IAggregateSymbol level)	The type whose declarations a level of the walk reads: a parameterised type's generic, else the type itself.
IAggregateSymbol	SamenessAbove.Found.level()	Returns the value of the level record component.
IAggregateSymbol	UnorderedProperty.owner()	Returns the value of the owner record component.

Methods in org.ek9lang.compiler.support.sameness with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
boolean	OrderingAvailability.allPropertiesOrderable(IAggregateSymbol aggregate, ISymbol ek9Any)	THE "can every property of this type be ordered?" (OrderingAvailability.isOrderable(IAggregateSymbol, ISymbol) for each property's type) - what a bare default operator's <=> needs of its own fields.
List<ISymbol>	ComparedFieldsOf.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	DeclaredOrderingAbove.apply(IAggregateSymbol owner, ISymbol ek9Any)
Optional<MethodSymbol>	DeclaredOrderingAt.apply(IAggregateSymbol level, ISymbol ek9Any)
Optional<MethodSymbol>	DeclaredSameness.apply(IAggregateSymbol owner)
Optional<MethodSymbol>	InheritedSameness.apply(IAggregateSymbol aggregate, ISymbol ek9Any)
String	MixingKind.apply(IAggregateSymbol type)
Optional<MethodSymbol>	NearestSamenessAbove.apply(IAggregateSymbol owner, ISymbol ek9Any)
Optional<MethodSymbol>	NearestSurvivingSamenessAbove.apply(IAggregateSymbol owner, ISymbol ek9Any)
List<MethodSymbol>	OverriddenSamenessSignatures.apply(IAggregateSymbol owner, ISymbol ek9Any)
Boolean	RetractWithdrawnBareOrdering.apply(IAggregateSymbol aggregate, ISymbol ek9Any)
Optional<MethodSymbol>	SealedSameness.apply(IAggregateSymbol aggregate, ISymbol ek9Any)
Optional<String>	SortOwnerAbove.apply(IAggregateSymbol aggregate)	The display name of the hierarchy-wide <=>'s owner above the type.
String	WhyNotOrderable.apply(IAggregateSymbol type, ISymbol ek9Any)
boolean	OrderingAvailability.bareOrderingRetracted(IAggregateSymbol owner, ISymbol ek9Any)	THE retraction decision for a type's BARE ordering family (<=> < <= > >= added by the bare default operator): its own bare <=> decides for the whole family through OrderingAvailability.orderingSurvives(MethodSymbol, ISymbol); without one (the ordering family alone, beside a hand-written <=>) the type's own properties decide.
(package private) boolean	OrderingAvailability.constrainedOverRetractedOrdering(IAggregateSymbol owner, ISymbol ek9Any)	Is this a constrained type whose base's bare ordering is withdrawn? Its copied ordering operators are then withdrawn with it: a constrained type offers exactly the operators its base has (M1).
(package private) IAggregateSymbol	SamenessAbove.declaringType(IAggregateSymbol level)	The type whose declarations a level of the walk reads: a parameterised type's generic, else the type itself.
(package private) Optional<SamenessAbove.Found>	SamenessAbove.first(IAggregateSymbol aggregate, Predicate<IAggregateSymbol> skip, Predicate<IAggregateSymbol> ownerTest)	The first sameness above aggregate whose declaring type passes ownerTest, passing over each level skip holds for.
boolean	OrderingAvailability.isOrderable(IAggregateSymbol type, ISymbol ek9Any)	THE "is this type orderable?" behind HasRealComparator: the nearest <=> it declares or inherits (super chain before Any, then its traits) that survives (OrderingAvailability.orderingSurvives(MethodSymbol, ISymbol)).
Optional<MethodSymbol>	OwnOperatorTaking.of(IAggregateSymbol owner, String name, ISymbol parameterType)	The owner's own non-abstract operator of this name taking exactly that one type, if any.
boolean	OrderingAvailability.orderingWithdrawn(IAggregateSymbol type, ISymbol ek9Any)	Does a use that needs the type's <=> without naming it (sort, <?, a range) rely on an ordering that is not there: a withdrawn bare <=> (OrderingAvailability.withdrawnOrdering(IAggregateSymbol, ISymbol)) or a DictEntry whose key cannot be ordered (OrderingAvailability.unorderedDictEntryKey(ISymbol, ISymbol))? THE test of phase 5's RetractedComparatorUseOrError; WhyNotOrderable words it.
boolean	HasHandWrittenEquality.test(IAggregateSymbol aggregate)
boolean	HasOwnComparator.test(IAggregateSymbol aggregate, ISymbol ek9Any)
boolean	IsDerivedComparison.test(IAggregateSymbol owner, MethodSymbol operator)
boolean	IsHierarchyWideSameness.test(IAggregateSymbol owner)
boolean	IsSamenessOperator.test(IAggregateSymbol owner, MethodSymbol operator)	True for a <=> or == comparing the owner with itself - a declaration of its sameness.
boolean	IsSelfComparison.test(IAggregateSymbol owner, MethodSymbol operator)	True for an operator taking exactly one argument of a type the owner is assignable to.
boolean	MayMixRuntimeTypes.test(IAggregateSymbol type, ISymbol ek9Any)
boolean	NeedsRuntimeTypeCheck.test(IAggregateSymbol owner, MethodSymbol operator)
(package private) boolean	TakesItself.test(IAggregateSymbol aggregate, MethodSymbol method, String operatorName)
Optional<MethodSymbol>	OrderingAvailability.withdrawnOrdering(IAggregateSymbol type, ISymbol ek9Any)	THE "does a use of this type's <=> rely on an ordering that is withdrawn?" (D58, Steve 2026-10-21): the nearest <=> declared on the type or above it - the one phase 3 resolved the use to - is one the bare default operator added, and it does not survive (OrderingAvailability.orderingSurvives(MethodSymbol, ISymbol)).

Method parameters in org.ek9lang.compiler.support.sameness with type arguments of type IAggregateSymbol

Modifier and Type	Method	Description
(package private) Optional<SamenessAbove.Found>	SamenessAbove.first(IAggregateSymbol aggregate, Predicate<IAggregateSymbol> skip, Predicate<IAggregateSymbol> ownerTest)	The first sameness above aggregate whose declaring type passes ownerTest, passing over each level skip holds for.

Constructors in org.ek9lang.compiler.support.sameness with parameters of type IAggregateSymbol

Modifier	Constructor	Description
(package private)	Found(IAggregateSymbol level, MethodSymbol operator)	Creates an instance of a Found record class.
	UnorderedProperty(IAggregateSymbol owner, ISymbol property)	Creates an instance of a UnorderedProperty record class.

Uses of IAggregateSymbol in org.ek9lang.compiler.symbols

Classes in org.ek9lang.compiler.symbols that implement IAggregateSymbol

Modifier and Type	Class	Description
class	AggregateSymbol	This is typically a 'class' or an interface type where it can include the definitions of new properties.
class	AggregateWithTraitsSymbol	An aggregate, but one that can have zero or more traits (like interfaces).
class	AnyTypeSymbol	Special type that is super of Aggregate and super of Function (if they don't have supers).

Methods in org.ek9lang.compiler.symbols that return types with arguments of type IAggregateSymbol

Modifier and Type	Method	Description
List<IAggregateSymbol>	AggregateWithTraitsSymbol.getAllowedExtenders()
default List<IAggregateSymbol>	IAggregateSymbol.getDirectSupertypes()	THE direct supertypes of this aggregate: its super aggregate (when it has one), then its traits.
Optional<IAggregateSymbol>	AggregateSymbol.getSuperAggregate()
default Optional<IAggregateSymbol>	IAggregateSymbol.getSuperAggregate()
List<IAggregateSymbol>	AggregateWithTraitsSymbol.getTraits()	Get the traits that this aggregates implements.
default List<IAggregateSymbol>	IAggregateSymbol.getTraits()

Methods in org.ek9lang.compiler.symbols with parameters of type IAggregateSymbol

Modifier and Type	Method	Description
void	AggregateWithTraitsSymbol.addAllowedExtender(IAggregateSymbol extenderSymbol)	For use with constraining types to be limited to a declared set.
boolean	AggregateSymbol.hasImmediateSuper(IAggregateSymbol theSuper)
boolean	AggregateWithTraitsSymbol.hasImmediateTrait(IAggregateSymbol trait)	Does this aggregate have the trait passed in as an immediate trait.
boolean	AggregateWithTraitsSymbol.isAllowingExtensionBy(IAggregateSymbol extenderSymbol)	Is the extender allowed to implement this aggregate (normally a trait).
boolean	AggregateWithTraitsSymbol.isDelegatedTrait(IAggregateSymbol traitSymbol)	Is this one of the traits this aggregate lists with a delegate.
boolean	AggregateSymbol.isImplementingInSomeWay(IAggregateSymbol aggregate)
boolean	AggregateWithTraitsSymbol.isImplementingInSomeWay(IAggregateSymbol traitSymbol)
default boolean	IAggregateSymbol.isImplementingInSomeWay(IAggregateSymbol aggregate)	Only really used by aggregates that can have one or more traits.
boolean	AggregateSymbol.isInAggregateHierarchy(IAggregateSymbol theAggregateToCheck)	Does the aggregate passed in exist in this type hierarchy.
boolean	IAggregateSymbol.isInAggregateHierarchy(IAggregateSymbol theAggregateToCheck)
void	AggregateSymbol.setSuperAggregate(IAggregateSymbol baseSymbol)
default void	IAggregateSymbol.setSuperAggregate(IAggregateSymbol superAggregateSymbol)

Method parameters in org.ek9lang.compiler.symbols with type arguments of type IAggregateSymbol

Modifier and Type	Method	Description
void	AggregateSymbol.setSuperAggregate(Optional<IAggregateSymbol> superAggregate)	Set the 'super' of this type.
default void	IAggregateSymbol.setSuperAggregate(Optional<IAggregateSymbol> superAggregate)