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.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.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	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	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) Map<IAggregateSymbol, ParsedModule>	PostPassSites.samenessDeclaredIn()	The aggregates whose sameness is completed (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	IsPropertyOfAggregate	Given an aggregate and a symbol, this predicate checks if the symbol is a property/field of that aggregate.
(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	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.
boolean	IsPropertyOfAggregate.test(IAggregateSymbol aggregate, ISymbol possibleProperty)

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(ISymbol ek9Any, ErrorListener errorListener, Map<IAggregateSymbol, List<MethodSymbol>> accessedMethodsByT)	Create the check.

Uses of IAggregateSymbol in org.ek9lang.compiler.phase5

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.
(package private) FieldClassifier.FieldCounts	FieldClassifier.classify(IAggregateSymbol aggregate, EK9Parser.TraitsListContext traitsListContext)	Classify all fields of an aggregate.
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, String methodName)	Check if a specific method (by name) has a conflict across traits.

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.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, DebugInfo debugInfo, List<IRInstr> instructions, boolean sourceUnbounded)
(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.

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, String collectionVar, IAggregateSymbol collectionType)	Creates an instance of a IteratorSetup record class.
(package private)	TerminalSetup(String variable, IAggregateSymbol type, MethodSymbol resolvedPipeMethod, ISymbol consumesType, boolean promotionRequired)	Creates an instance of a TerminalSetup record class.

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

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

Modifier and Type	Method	Description
static Optional<IAggregateSymbol>	EnumTypeHelper.baseEnumOf(IAggregateSymbol type)	The base enum aggregate when type is a CONSTRAINED enum (i.e.
static Optional<IAggregateSymbol>	EnumTypeHelper.baseEnumOf(ISymbol type)	Convenience for callers holding an ISymbol: the base enum when it is a constrained enum type.

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

Modifier and Type	Method	Description
static Optional<IAggregateSymbol>	EnumTypeHelper.baseEnumOf(IAggregateSymbol type)	The base enum aggregate when type is a CONSTRAINED enum (i.e.
static boolean	EnumTypeHelper.isConstrainedEnum(IAggregateSymbol type)	True if type is a constrained enum (a base enum returns false).
static boolean	EnumTypeHelper.isEnumeration(IAggregateSymbol type)	True if type is an enumeration TYPE — a base enum or a constrained enum.
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 boolean	AbstractSyntheticGenerator.isAnyType(IAggregateSymbol type)	Check if the given type is the Any type.
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.

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
(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	NoDuplicateOperationsOrError	Does a simple check (excluding any inheritance) for duplicated operations (methods, operators) on any sort of Aggregate, i.e.

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>	ConstructionSteps.implicitSuper()	Returns the value of the implicitSuper record component.
static List<IAggregateSymbol>	OverriddenDeclarations.parentsOf(IAggregateSymbol aggregate)	The parents a method can override: the super class, then each trait.

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

Modifier and Type	Method	Description
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.
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.
void	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)
static 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.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.
MethodSymbol	AggregateManipulator.createToJsonSimpleOperator(IAggregateSymbol aggregateSymbol)	Create operator for json.
static 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).
static DefaultedComparisonDelegate.Resolver	DefaultedComparisonDelegate.forAggregate(IAggregateSymbol aggregate, ISymbol ek9Any)	DefaultedComparisonDelegate.of(IAggregateSymbol, MethodSymbol, ISymbol) for the operators of ONE aggregate, for a caller that asks about each of them in turn: the type's facts - whether it has its own comparator or a hand-written ==, and which <=> and == serve it - are worked out at most once, not once per operator.
static String	CallableIdentity.forInstanceInit(IAggregateSymbol aggregate)	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.
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)
static boolean	DefaultedComparisonDelegate.hasHandWrittenEquality(IAggregateSymbol aggregate)	True when the developer wrote an == that takes the type itself (not a defaulted one).
static boolean	DefaultedComparisonDelegate.hasOwnComparator(IAggregateSymbol aggregate, ISymbol ek9Any)	True when the aggregate has its own REAL <=> that takes itself - hand-written, or defaulted (and not retracted) over fields that can all really be ordered.
static Optional<MethodSymbol>	Sameness.inheritedSameness(IAggregateSymbol aggregate, ISymbol ek9Any)	The concrete sameness this 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.
static boolean	Sameness.isDerivedComparison(IAggregateSymbol owner, MethodSymbol operator)	True for a <> < <= > >= comparing the owner with itself - always generated from the sameness, never written.
static boolean	Sameness.isSamenessOperator(IAggregateSymbol owner, MethodSymbol operator)	True for a <=> or == comparing the owner with itself - a declaration of its sameness.
static boolean	Sameness.isSelfComparison(IAggregateSymbol owner, MethodSymbol operator)	True for an operator taking exactly one argument of a type the owner is assignable to.
static List<ISymbol>	OverriddenDeclarations.narrowedReturnTypes(IAggregateSymbol aggregate, MethodSymbol method)	The return types of the (non-private) parent declarations this method overrides with a NARROWER - covariant - return, one per distinct type.
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.
static ISymbol	ConstrainedBase.of(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).
static Optional<MethodSymbol>	DefaultedComparisonDelegate.of(IAggregateSymbol aggregate, MethodSymbol operator, ISymbol ek9Any)	The operator a generated comparison delegates to, resolved on the type (its own, a super's or a trait's).
static List<MethodSymbol>	OverriddenDeclarations.of(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.
static Optional<MethodSymbol>	InheritedDispatcher.overriddenEntryPoint(IAggregateSymbol aggregate, MethodSymbol entryPoint)	The super's entry point that a sub-type's entry point overrides: the super's effective dispatcher method with exactly the same signature.
static List<IAggregateSymbol>	OverriddenDeclarations.parentsOf(IAggregateSymbol aggregate)	The parents a method can override: the super class, then each trait.
static Optional<MethodSymbol>	DefaultOperatorCoverage.servingOwnOperator(IAggregateSymbol aggregate, String operator)	The type's own operator that already serves default operator <operator>, if any.
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.
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.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()
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	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)