Uses of Class
org.ek9lang.compiler.symbols.MethodSymbol

Packages that use MethodSymbol

Package	Description
org.ek9lang.compiler.common	Common parts of processing that can be reused across various phases.
org.ek9lang.compiler.phase1	E - Initial Symbol definition by traversing the 'ANTLR' - 'AST'.
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.phase7	K - Intermediate Representation Generation.
org.ek9lang.compiler.phase7.calls
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.retention
org.ek9lang.compiler.support.sameness
org.ek9lang.compiler.symbols	This is the main source of EK9 Symbols used within the compiler.

Uses of MethodSymbol in org.ek9lang.compiler.common

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

Modifier and Type	Class	Description
class	AppropriateBodyOrError	Checks if the body of a method/operator is appropriate.
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.
class	ContextSupportsAbstractMethodOrError	Checks for the containing construct type and whether it is marked as abstract or not.
final class	IsOrderingOperator	THE ORDERING operator family test: <, <=, >, >= and <=> - each delegates (directly, or via DerivedComparisonGenerator) to <=>, so each needs the receiver AND every field type to be orderable.
final class	OperationDeclarationChecks	THE checks every method and operator declaration gets - call this, never the rules one by one (front-end rationalisation F12/D5, Steve 2026-10-03).
class	OverrideOrAbstractOrError	Checks for both abstract and override.
class	ProcessTraitMethodOrError	Check trait specifics on constructors/methods/operators, Allowing missing body but marking as abstract.
class	TraitMethodAcceptableOrError	Check trait specifics on methods/operators.

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

Modifier and Type	Method	Description
MethodSymbol	MethodAndAggregateData.methodSymbol()	Returns the value of the methodSymbol record component.

Methods in org.ek9lang.compiler.common that return types with arguments of type MethodSymbol

Modifier and Type	Method	Description
Optional<MethodSymbol>	CloseOperatorOf.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	ScopeStack.traverseBackUpStackToEnclosingMethod()	Navigate back up the scope stack to find the first enclosing method (there may not be one).

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

Modifier and Type	Method	Description
void	AppropriateBodyOrError.accept(MethodSymbol methodSymbol, EK9Parser.OperationDetailsContext ctx)
void	ContextSupportsAbstractMethodOrError.accept(MethodSymbol methodSymbol, org.antlr.v4.runtime.ParserRuleContext ctx)
void	OperationDeclarationChecks.accept(MethodSymbol operation, org.antlr.v4.runtime.ParserRuleContext declaration)	Check a method or operator declaration.
void	OverrideOrAbstractOrError.accept(MethodSymbol methodSymbol)
void	ProcessTraitMethodOrError.accept(MethodSymbol method, EK9Parser.OperationDetailsContext ctx)
void	TraitMethodAcceptableOrError.accept(MethodSymbol method, EK9Parser.OperationDetailsContext ctx)
String	OperatorMap.resolvedMethodName(MethodSymbol methodSymbol)	THE canonical resolver from an operator MethodSymbol to its backend method name, arity-aware (splits "-" into _negate/_sub by the symbol's own parameter count — see OperatorMap.getForward(String, int)).
boolean	IsOrderingOperator.test(MethodSymbol operator)

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

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

Uses of MethodSymbol in org.ek9lang.compiler.phase1

Classes in org.ek9lang.compiler.phase1 that implement interfaces with type arguments of type MethodSymbol

Modifier and Type	Class	Description
(package private) final class	MethodNotOperatorOrError	Just checks that named operator methods: mod, rem, abs, sqrt, close, contains, matches, empty, length are not being used as just method names.
(package private) final class	NoMethodReturnOrError	Typically used for Constructors, but could be used in other contexts where a method is not expected to return anything.
(package private) final class	NonExtendableMethodOrError	Aimed at methods in services and a program (which is a method).
(package private) final class	NotDispatcherMethodOrError	Check not dispatcher methods.
(package private) final class	ProcessCommonMethodsOrError	Checks what only a METHOD declaration can get wrong, in every method context: 'default' on a method that is not a constructor, the access modifier, and the constructor rules.
(package private) final class	ValidMethodOrError	Checks methods from various contexts, typically this is delegated to other functions.

Methods in org.ek9lang.compiler.phase1 with parameters of type MethodSymbol

Modifier and Type	Method	Description
void	MethodNotOperatorOrError.accept(MethodSymbol methodSymbol)
void	NoMethodReturnOrError.accept(MethodSymbol methodSymbol, EK9Parser.MethodDeclarationContext ctx)
void	NonExtendableMethodOrError.accept(MethodSymbol methodSymbol, EK9Parser.MethodDeclarationContext methodDeclarationContext)
void	NotDispatcherMethodOrError.accept(MethodSymbol method, EK9Parser.MethodDeclarationContext ctx)
void	ProcessCommonMethodsOrError.accept(MethodSymbol method, EK9Parser.MethodDeclarationContext ctx)
void	ValidMethodOrError.accept(MethodSymbol method, EK9Parser.MethodDeclarationContext ctx)

Uses of MethodSymbol in org.ek9lang.compiler.phase2

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

Modifier and Type	Class	Description
(package private) final class	ProgramArgumentsOrError	A program can only accept specific types of arguments to it.
(package private) final class	ProgramReturnOrError	A program can only return an Integer (exit code).
(package private) final class	ValidOperatorOrError	Checks each operator: first its operator SEMANTICS - arguments, return type and purity, which need resolved types, so this runs in phase 2 - then what every method and operator declaration is checked for (OperationDeclarationChecks, D5).

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

Modifier and Type	Method	Description
void	ProgramArgumentsOrError.accept(IToken token, MethodSymbol methodSymbol)
void	ProgramReturnOrError.accept(IToken token, MethodSymbol methodSymbol)
void	ValidOperatorOrError.accept(MethodSymbol methodSymbol, EK9Parser.OperatorDeclarationContext ctx)

Uses of MethodSymbol in org.ek9lang.compiler.phase3

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

Modifier and Type	Class	Description
(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	ResolveMethodOnAggregateOrError	Resolves a method (by name and call arguments) within a given scope, emitting an error if it cannot be resolved or is ambiguous.
(package private) final class	ResolveMethodOrError	Given a search for a method from an aggregate - and include supers/traits etc., this function will try and locate the method.
(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	ThisOrSuperCallOrError	Just focus on resolving 'this' or 'super' in respect to a 'call'.
(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 MethodSymbol

Modifier and Type	Method	Description
MethodSymbol	ResolveMethodOnAggregateOrError.apply(MethodOnAggregateData data)
MethodSymbol	ResolveMethodOrError.apply(IToken errorLocation, MethodSearchInScope searchOnAggregate)
MethodSymbol	ThisOrSuperCallOrError.apply(EK9Parser.CallContext ctx)
MethodSymbol	AggregateMethodData.methodSymbol()	Returns the value of the methodSymbol record component.

Methods in org.ek9lang.compiler.phase3 that return types with arguments of type MethodSymbol

Modifier and Type	Method	Description
List<MethodSymbol>	RetrieveDefaultedOperators.apply(IAggregateSymbol aggregate)

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

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 <=>.

Method parameters in org.ek9lang.compiler.phase3 with type arguments of type MethodSymbol

Modifier and Type	Method	Description
void	TraverseAbstractMethods.accept(IAggregateSymbol aggregateSymbol, Consumer<MethodSymbol> actionToTake)

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

Modifier	Constructor	Description
(package private)	AggregateMethodData(IToken location, IAggregateSymbol aggregate, MethodSymbol methodSymbol)	Creates an instance of a AggregateMethodData record class.

Uses of MethodSymbol in org.ek9lang.compiler.phase4

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

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 MethodSymbol in org.ek9lang.compiler.phase5

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

Modifier and Type	Class	Description
(package private) final class	PropertiesLeftUnset	THE reading of a constructor's CommonValues.LEAVES_PROPERTIES_UNSET mark: the names of the properties (declared without a value) it leaves unset, following its this(...) chain, as a message shows them; empty when it sets them all.
(package private) final class	PropertiesLeftUnsetNames	The names of the properties a constructor leaves unset, as a set; empty when it sets them all.

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

Modifier and Type	Method	Description
Optional<String>	PropertiesLeftUnset.apply(MethodSymbol constructor)
Set<String>	PropertiesLeftUnsetNames.apply(MethodSymbol constructor)
(package private) CloseableArgumentKeeping.Fate	CloseableArgumentKeeping.fateOf(MethodSymbol target, int index)	What the constructor does with the argument given at index.
(package private) void	CloseableArgumentKeeping.forwards(MethodSymbol constructor, int fromIndex, MethodSymbol target, int toIndex)	The constructor passes its own parameter at fromIndex to target at toIndex: if the target keeps it, so does this constructor.
(package private) void	CloseableArgumentKeeping.forwardsOpen(CloseableArgumentKeeping.Holder from, MethodSymbol target, int toIndex)	The variable is passed on, whole, to target's parameter: if that keeps it, so does this callable.
(package private) boolean	TraitMethodConflictDetector.hasConflict(IAggregateSymbol aggregate, MethodSymbol method)	Check if a specific method has a conflict across traits.
(package private) void	CloseableArgumentKeeping.keeps(MethodSymbol constructor, int index)	The constructor stores its parameter at index in a closeable property of the object it constructs.
(package private) void	CloseableArgumentKeeping.notFresh(MethodSymbol target, int index, ErrorListener errorListener, IToken location, String argument)	A construction is given a closeable value that is not new at index: an error when the constructor keeps that parameter.

Uses of MethodSymbol in org.ek9lang.compiler.phase7

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

Modifier and Type	Method	Description
(package private) MethodSymbol	Scenario2WrapperHelper.findOriginalMethodOnGenericTemplate(MethodSymbol method)	The generic template's method a wrapper method was cloned from - READ what phase 6 encoded, never re-derived.

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

Modifier and Type	Method	Description
protected List<MethodSymbol>	AggregateDfnGenerator.withFieldSetStatusCarrier(AggregateSymbol aggregateSymbol)	The aggregate's own methods, plus the synthetic _fieldSetStatus carrier if it needs one.

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

Modifier and Type	Method	Description
(package private) MethodSymbol	Scenario2WrapperHelper.findOriginalMethodOnGenericTemplate(MethodSymbol method)	The generic template's method a wrapper method was cloned from - READ what phase 6 encoded, never re-derived.
(package private) void	Scenario2EqualityGenerator.generate(IRConstruct construct, MethodSymbol method)	Generate an equality operation that handles wrapper-to-wrapper comparison.
(package private) void	Scenario2AggregateWrapperGenerator.generateConstructorOperation(IRConstruct construct, MethodSymbol method, String baseTypeName)	Generate constructor that creates the delegate instance.
(package private) void	Scenario2AggregateWrapperGenerator.generateDelegationOperation(IRConstruct construct, MethodSymbol method, String baseTypeName)	Generate a delegation operation for a single method.
(package private) void	Scenario2AggregateWrapperGenerator.generateFunctionAcceptingMethod(IRConstruct construct, MethodSymbol method, String baseTypeName)	Generate inline implementation for methods that accept function wrapper types.
(package private) List<String>	Scenario2WrapperHelper.getBaseMethodParameterTypes(MethodSymbol method)	Get the parameter types from the BASE generic type's method, not the substituted version.
(package private) String	Scenario2WrapperHelper.getBaseMethodReturnType(MethodSymbol method)	Get the return type from the BASE generic type's method, not the substituted version.
(package private) boolean	Scenario2AggregateWrapperGenerator.isCallbackInvocationMethod(MethodSymbol method)	Detect callback-invocation methods: methods whose contract is "invoke the supplied function on the contained value".
(package private) boolean	Scenario2EqualityGenerator.isEqualityOperation(MethodSymbol method)	Check if a method is an equality operation that needs special argument handling.

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

Modifier and Type	Method	Description
(package private) void	DispatchTablePass.generate(Map<MethodSymbol, OperationInstr> operationsMap, AggregateSymbol aggregateSymbol, SharedThreadContext<CompilableProgram> compilableProgramAccess)

Uses of MethodSymbol in org.ek9lang.compiler.phase7.calls

Methods in org.ek9lang.compiler.phase7.calls with parameters of type MethodSymbol

Modifier and Type	Method	Description
static ChainedCallDispatch	ChainedCallDispatch.of(MethodSymbol toBeCalled, String receiverTemp, ISymbol receiverType, boolean isExplicitTraitTypeRef, boolean isSuperCall, IRGenerationContext stackContext)	Decide how a chained call to toBeCalled on receiverType is dispatched.

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

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

Modifier and Type	Method	Description
MethodSymbol	TerminalSetup.resolvedPipeMethod()	Returns the value of the resolvedPipeMethod record component.

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

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

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

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

Modifier and Type	Class	Description
class	TextBodyDetailContextOrError	Locates the textBodyDeclaration parse context for a given text method symbol.

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

Modifier and Type	Method	Description
MethodSymbol	FunctionMemberSymbols.call(FunctionSymbol function, IFunctionSymbol signature)	The function's _call method: pure and abstract as the function is, with the parameters and the return of signature - the function itself, or a dynamic function's super function.
MethodSymbol	FunctionMemberSymbols.constructor(FunctionSymbol function, boolean pure, List<ISymbol> parameters)	The function's constructor, returning the function's own type.
MethodSymbol	FunctionMemberSymbols.isSet(FunctionSymbol function, ISymbol booleanType)	The function's ? operator: pure, returning Boolean rtn - a function is always set.
MethodSymbol	MethodResolutionResult.methodSymbol()	Returns the value of the methodSymbol record component.

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

Modifier and Type	Method	Description
EK9Parser.TextBodyDeclarationContext	TextBodyDetailContextOrError.apply(MethodSymbol method, EK9Parser.TextDeclarationContext ctx)
Optional<EK9Parser.OperationDetailsContext>	BodiesInAggregateParts.bodyOf(MethodSymbol method)
Optional<EK9Parser.OperationDetailsContext>	BodiesInServiceDeclaration.bodyOf(MethodSymbol method)
Optional<EK9Parser.OperationDetailsContext>	ClonedBodiesInAggregateParts.bodyOf(MethodSymbol method)
Optional<EK9Parser.OperationDetailsContext>	OperationBodyLocator.bodyOf(MethodSymbol method)	The written body of method, or empty when it has none to generate from.

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

Modifier	Constructor	Description
	MethodResolutionResult(MethodSymbol methodSymbol, double matchPercentage, boolean requiresPromotion)	Creates an instance of a MethodResolutionResult record class.

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

Classes in org.ek9lang.compiler.phase7.synthesis that implement interfaces with type arguments of type MethodSymbol

Modifier and Type	Class	Description
final class	FieldSetStatusSymbolGenerator	Creates the synthetic _fieldSetStatus method symbol used as an IR carrier.
final class	PolymorphicCopySymbolGenerator	Creates the DETACHED method symbols a copy owner's IR carries for a copy through a super-typed reference (PolymorphicCopy, Q5b): the generated _copyAccepts(target as Any) <- Boolean and one :=: override per inherited :=:(Super) signature.
final class	SamenessOverrideSymbolGenerator	Creates the DETACHED method symbols a type with its own sameness carries for a comparison through a super-typed reference (D24 rule 3, OverriddenSamenessSignatures): one == or <=> override per inherited signature taking a super.

Methods in org.ek9lang.compiler.phase7.synthesis that return types with arguments of type MethodSymbol

Modifier and Type	Method	Description
Optional<MethodSymbol>	FieldSetStatusSymbolGenerator.apply(AggregateSymbol aggregateSymbol, ISymbol bitsType)	Create the detached _fieldSetStatus carrier for this aggregate, if it should have one.
List<MethodSymbol>	PolymorphicCopySymbolGenerator.apply(AggregateSymbol aggregateSymbol, Ek9Types ek9Types)	The detached carriers for this aggregate - empty for a still-generic template and for anything that is not a copy owner needing them.
List<MethodSymbol>	SamenessOverrideSymbolGenerator.apply(AggregateSymbol aggregateSymbol, Ek9Types ek9Types)	The detached overrides for this aggregate - empty for a still-generic template and for a type with no sameness of its own below another.
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.

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

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.
(package private) List<IRInstr>	CloseGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _close operator IR for the given aggregate.
(package private) List<IRInstr>	CompareGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _cmp operator IR for the given aggregate.
(package private) List<IRInstr>	CopyGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _copy operator IR for the given aggregate - its own :=:(Owner), or the override of an inherited :=:(Super) signature (PolymorphicCopy, Q5b; told apart by the parameter type).
(package private) List<IRInstr>	DelegationGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate delegation IR for a synthetic delegation method.
(package private) List<IRInstr>	DerivedComparisonGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate IR for a derived comparison operator.
(package private) List<IRInstr>	EnumConstructorGenerator.generate(MethodSymbol constructorSymbol, AggregateSymbol aggregateSymbol)	Generate a parameterized enum constructor.
List<IRInstr>	EnumFirstLastGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the #< or #> operator for an enumeration.
(package private) List<IRInstr>	EnumIncrementDecrementGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the ++ or -- operator for an enumeration.
List<IRInstr>	EnumIteratorGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the iterator() method for an enumeration.
(package private) List<IRInstr>	EnumPrimitiveOperatorGenerator.generate(EnumPrimitiveOperatorGenerator.Shape shape, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)
(package private) List<IRInstr>	EnumStringParamGenerator.generate(String operatorName, MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate a String-param comparison operator for an enumeration.
(package private) List<IRInstr>	EqualsGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _eq operator IR for the given aggregate.
(package private) List<IRInstr>	FieldSetStatusGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the _fieldSetStatus method IR for the given aggregate.
List<IRInstr>	FunctionIsSetGenerator.generate(MethodSymbol methodSymbol, FunctionSymbol functionSymbol)	Generate the _isSet operator IR for the given function.
(package private) List<IRInstr>	HashCodeGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _hashcode operator IR for the given aggregate.
(package private) List<IRInstr>	InheritedDispatcherGenerator.generate(MethodSymbol entryPoint, AggregateSymbol aggregateSymbol)
(package private) List<IRInstr>	IsSetGenerator.generate(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the _isSet operator IR for the given aggregate.
(package private) List<IRInstr>	NotEqualsGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _neq operator IR for the given aggregate.
(package private) List<IRInstr>	SamenessOverrideGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)
(package private) List<IRInstr>	ToJsonGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _json operator IR for the given aggregate.
(package private) List<IRInstr>	ToStringGenerator.generate(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate the _string operator IR for the given aggregate.
(package private) List<IRInstr>	CopyGenerator.generateCopyAccepts(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate the owner's _copyAccepts(target as Any) <- Boolean: is target an instance of this owner (a SUBTYPE test - the owner or any class below it)? Asked of the SOURCE of a copy with the copy's target, so a copy runs in full only between objects whose nearest copy owner is the same class.
OperationInstr	SyntheticOperatorGenerator.generateEnumConstructor(MethodSymbol constructorSymbol, AggregateSymbol aggregateSymbol)	Generate IR for a parameterized enum constructor (copy or String).
OperationInstr	SyntheticOperatorGenerator.generateMethod(MethodSymbol methodSymbol, AggregateSymbol aggregateSymbol)	Generate IR for a synthetic regular method (non-operator).
OperationInstr	SyntheticOperatorGenerator.generateOperator(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Generate IR for a synthetic operator.
protected AbstractSyntheticGenerator.ScopeSetup	AbstractSyntheticGenerator.initializeScope(MethodSymbol operatorSymbol, String scopeLabel, String returnVarName, String returnTypeName)	Initialize scope with return variable reference.
protected AbstractSyntheticGenerator.ScopeSetup	AbstractSyntheticGenerator.initializeScopeNoReturn(MethodSymbol operatorSymbol, String scopeLabel)	Initialize scope for void-returning methods (no return variable).
(package private) boolean	SamenessOverrideGenerator.isOverride(MethodSymbol operatorSymbol, AggregateSymbol aggregateSymbol)	Is this synthetic == or <=> one of the detached overrides - does it take a type other than its owner? A generated sameness always takes exactly its owner.

Uses of MethodSymbol in org.ek9lang.compiler.search

Classes in org.ek9lang.compiler.search that implement interfaces with type arguments of type MethodSymbol

Modifier and Type	Class	Description
class	PossibleMatchingMethods	Just uses the name of a method in the search, to get a list of all possible method name.

Methods in org.ek9lang.compiler.search that return MethodSymbol

Modifier and Type	Method	Description
MethodSymbol	PercentageMethodSymbolMatch.getMethodSymbol()

Methods in org.ek9lang.compiler.search that return types with arguments of type MethodSymbol

Modifier and Type	Method	Description
List<MethodSymbol>	PossibleMatchingMethods.apply(MethodSearchInScope searchOnAggregate)
Optional<MethodSymbol>	MethodSymbolSearchResult.getSingleBestMatchSymbol()	If there is a single best match for the search; then return it.

Constructors in org.ek9lang.compiler.search with parameters of type MethodSymbol

Modifier	Constructor	Description
	MethodSymbolSearch(String newName, MethodSymbol methodSymbol)	Create a method search given a method symbol, but used a new method name.§ But this does not set the expected type.
	MethodSymbolSearch(MethodSymbol methodSymbol)	Create a method search given a method symbol.
	PercentageMethodSymbolMatch(MethodSymbol methodSymbol, double percentageMatch)

Uses of MethodSymbol in org.ek9lang.compiler.support

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

Modifier and Type	Class	Description
final class	BodyOfProgram	THE body method of a program: the compiler-made _main that holds what was written in the program, and which IS the program wherever a person reads about it.
final class	CallsSuperExplicitly	True when the constructor makes an explicit super(...) call (recorded in phase 3).
final class	CaptureConstructorMarker	Records that a constructor is THE capture constructor of its dynamic class (IsCaptureConstructor, which is the only reader).
(package private) class	CheckAndPopulateOperator	Deals with normal operators (i.e.
final class	CopyConstructor	THE copy constructor of a type: a PUBLIC constructor taking exactly one argument of EXACTLY that type - Step(Step).
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	DelegatesWithThis	True when the constructor delegates to a sibling with this(...) (recorded in phase 3, ThisOrSuperCallOrError).
final class	ExactParameterTypes	THE test "this method or constructor takes exactly these parameter types, in this order" - each by isExactSameType, never by assignability, promotion or a cost-based match.
final class	ExactSingleParameter	THE test "this method or operator takes exactly ONE parameter, and its type is EXACTLY this type" - by isExactSameType, never by assignability.
final class	GenericTemplateMember	THE mapping from a member of a MONOMORPHISED parameterised type back to the member of the GENERIC it was substituted from.
final class	GenericTemplateMember	THE mapping from a member of a MONOMORPHISED parameterised type back to the member of the GENERIC it was substituted from.
final class	IsInheritedDispatcherEntryPoint	THE "was this entry point synthesised by InheritedDispatcher" (front-end rationalisation D2) - the INHERITED_DISPATCHER squirrel.
final class	NoArgumentConstructor	THE no-argument constructor of a type, whatever its access - Counter().
final class	OverriddenDeclarations	THE parent declarations a method overrides - hold one and apply it, do not re-derive it.
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	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	SameRuntimeOperator	THE test that two DIFFERENTLY SPELT operators are one runtime operator - hold one and ask it, do not re-derive it.
final class	SameRuntimeOperator	THE test that two DIFFERENTLY SPELT operators are one runtime operator - hold one and ask it, do not re-derive it.
final class	TakesExactlyTheTypesOf	True when method takes exactly the types of variables (VariableTypes), in order (ExactParameterTypes); false when any of the variables has no type.
final class	UsesImplicitSuperCall	True when the constructor relies on the hidden implicit super(): it neither delegates with this(...) (DelegatesWithThis) nor calls super(...) (CallsSuperExplicitly).

Methods in org.ek9lang.compiler.support that return MethodSymbol

Modifier and Type	Method	Description
MethodSymbol	AggregateManipulator.addComparatorOperator(IAggregateSymbol aggregateSymbol, String comparatorType, Optional<ISymbol> returnType)	Adds a form of a comparison operator.
MethodSymbol	AggregateManipulator.addConstructor(AggregateSymbol t, Optional<ISymbol> s)	Add another constructor to type t, but passing in an s as the value in the construction.
MethodSymbol	AggregateManipulator.addConstructor(AggregateSymbol t, ISymbol s)	Add a constructor to the type aggregate with a particular parameter.
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)
MethodSymbol	AggregateManipulator.addPublicMethod(AggregateSymbol aggregate, String methodName, List<ISymbol> methodParameters, Optional<ISymbol> returnType)	Just add a method to an aggregate with the name and parameters and return type.
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.
MethodSymbol	CheckAndPopulateOperator.apply(EK9Parser.OperatorDeclarationContext ctx, IAggregateSymbol aggregate)
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.
(package private) MethodSymbol	OperatorFactory.getDefaultOperator(IAggregateSymbol aggregate, String operator)
MethodSymbol	DispatcherWinner.Selection.handler()	Returns the value of the handler record component.
MethodSymbol	OperationFactory.newMethod(EK9Parser.MethodDeclarationContext ctx, String methodName, IScopedSymbol scopedSymbol)	Create a new method with a specific name.
MethodSymbol	OperationFactory.newMethod(EK9Parser.MethodDeclarationContext ctx, IScopedSymbol scopedSymbol)	Create a new method that represents an EK9 class/component method.
MethodSymbol	SymbolFactory.newMethod(EK9Parser.MethodDeclarationContext ctx, String methodName, IScopedSymbol scopedSymbol)	Create a new method with a specific name.
MethodSymbol	SymbolFactory.newMethod(EK9Parser.MethodDeclarationContext ctx, IScopedSymbol scopedSymbol)	Create a new method that represents an EK9 class/component method.
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.
MethodSymbol	SymbolFactory.newTextBody(EK9Parser.TextBodyDeclarationContext ctx, IScope scope)	Create a new aggregate that represents an EK9 text body - this is represented by a method.
MethodSymbol	TextFactory.newTextBody(EK9Parser.TextBodyDeclarationContext ctx, IScope scope)
MethodSymbol	ConceptualAccess.OrderingUse.operator()	Returns the value of the operator record component.

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

Modifier and Type	Method	Description
Optional<MethodSymbol>	BodyOfProgram.apply(ISymbol symbol)	The body method of a program - empty when the symbol is not a program.
Optional<MethodSymbol>	CopyConstructor.apply(IAggregateSymbol type)	The public copy constructor of type, if it has one.
Optional<MethodSymbol>	DefaultOperatorCoverage.apply(IAggregateSymbol aggregate, String operator)	The type's own operator that already serves default operator <operator>, if any.
Optional<MethodSymbol>	GenericTemplateMember.apply(MethodSymbol method)	The generic's own method this one was substituted from.
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)
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.
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.
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.
protected Consumer<MethodSymbol>	CommonFactory.getDefaultOperatorSymbolInitializer(Consumer<ISymbol> initialise)
Optional<MethodSymbol>	UnsetKeepingOperator.keepingUnset(ISymbol receiverType, String operator, Optional<ISymbol> argumentType)	As OperatorResolvedOn then KeepsUnset: the resolved operator, only when it keeps an unset receiver unset.
Optional<MethodSymbol>	DefaultedComparisonDelegate.Resolver.of(MethodSymbol operator)	The operator a generated comparison delegates to, resolved on the type (its own, a super's or a trait's).

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

Modifier and Type	Method	Description
void	CaptureConstructorMarker.accept(MethodSymbol constructor)
Optional<MethodSymbol>	GenericTemplateMember.apply(MethodSymbol method)	The generic's own method this one was substituted from.
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)
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	SymbolFactory.ensureTextBodyIsInSuper(MethodSymbol textMethodSymbol)	Ensures that any method in a specific text block is always added to the base text for that component.
void	TextFactory.ensureTextBodyIsInSuper(MethodSymbol textMethodSymbol)	Ensures that any method in a specific text block is always added to the base text for that component.
static ConstructionSteps	ConstructionSteps.of(MethodSymbol constructor)	The steps this constructor takes before its body.
Optional<MethodSymbol>	DefaultedComparisonDelegate.Resolver.of(MethodSymbol operator)	The operator a generated comparison delegates to, resolved on the type (its own, a super's or a trait's).
boolean	CallsSuperExplicitly.test(MethodSymbol constructor)
boolean	DelegatesWithThis.test(MethodSymbol constructor)
boolean	ExactParameterTypes.test(MethodSymbol method, List<ISymbol> types)	True when method takes exactly as many parameters as types, each exactly the type at its position.
boolean	ExactSingleParameter.test(MethodSymbol method, ISymbol type)	True when method takes exactly one parameter whose type is exactly type.
boolean	IsInheritedDispatcherEntryPoint.test(MethodSymbol method)
boolean	SameRuntimeOperator.test(MethodSymbol first, MethodSymbol second)	Are these two operators, spelt differently, one runtime operator with the same parameter types?
boolean	TakesExactlyTheTypesOf.test(MethodSymbol method, List<ISymbol> variables)
boolean	UsesImplicitSuperCall.test(MethodSymbol constructor)

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

Modifier and Type	Method	Description
void	SymbolMatcher.addMatchesToResult(MethodSymbolSearchResult result, SymbolSearch criteria, List<MethodSymbol> methodSymbols)	Match the search criteria against one or more symbol methods.
List<ISymbol>	DispatcherReachableTypes.all(ISymbol baseType, List<MethodSymbol> handlers, int paramIndex, ConcreteSubtypeFinder finder)	As DispatcherReachableTypes.concrete(ISymbol, List, int, ConcreteSubtypeFinder), but keeping abstract types.
List<ISymbol>	DispatcherReachableTypes.concrete(ISymbol baseType, List<MethodSymbol> handlers, int paramIndex, ConcreteSubtypeFinder finder)	The types a value at this parameter could actually HAVE at runtime.
Optional<DispatcherWinner.Selection>	DispatcherWinner.forParam(ISymbol concreteType, int paramIndex, List<MethodSymbol> handlers)	The winning handler for a concrete type at one parameter position.
Optional<DispatcherWinner.Selection>	DispatcherWinner.forParamPair(ISymbol type0, ISymbol type1, List<MethodSymbol> handlers)	The winning handler for a pair of concrete types across the first two parameters.

Constructors in org.ek9lang.compiler.support with parameters of type MethodSymbol

Modifier	Constructor	Description
	OrderingUse(ISymbol type, ConceptualAccess.OrderingKind kind, MethodSymbol operator)	Creates an instance of a OrderingUse record class.
	Selection(MethodSymbol handler, double cost)	Creates an instance of a Selection record class.

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

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

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	DeclaredClose	The close operator this type declares itself, if any: own scope, not abstract, not a delegation proxy.
final class	IsCloseOperator	True when the method is a type's close operator.
final class	IsDefaultedClose	True when the operator is a close the developer asked for with default operator close.
(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	ParentClose	The close of the nearest super CLASS that has one, when it is not abstract.

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

Modifier and Type	Method	Description
List<MethodSymbol>	ChainedCloses.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	DeclaredClose.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	OwnCloseOperator.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	ParentClose.apply(IAggregateSymbol aggregate)
Optional<MethodSymbol>	CloseSteps.parentClose()	Returns the value of the parentClose record component.

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

Modifier and Type	Method	Description
boolean	IsCloseOperator.test(MethodSymbol method)
boolean	IsDefaultedClose.test(MethodSymbol method)

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

Modifier	Constructor	Description
	CloseSteps(List<ISymbol> closed, Optional<MethodSymbol> parentClose)	Creates an instance of a CloseSteps record class.

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

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

Modifier and Type	Class	Description
final class	IsAccessedByRange	THE "is the member the copy constructor of a for range over T" (NoteRangeCopyConstructor).
final class	IsAccessedInPureScope	THE "did the body use the member from a pure scope" (NoteConceptualAccess).
final class	IsConceptuallyAccessed	THE "does the generic's body use this member of T" (NoteConceptualAccess).
final class	NoteConceptualAccess	THE note that the generic's body uses this member of its conceptual T (ConceptualAccess), and - when the body is in a pure scope - that too: the concrete member must then be pure (a conceptual constructor's own purity is meaningless - it is synthetic on T).
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	NoteRangeCopyConstructor	THE note of the copy constructor a for range over T will use (NoteConceptualAccess, and marked as the range's): which one runs, and whether it is pure, is only known at parameterisation.

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

Modifier and Type	Method	Description
void	NoteConceptualAccess.accept(MethodSymbol member, Boolean inPureScope)
void	NoteIfConceptual.accept(IAggregateSymbol owner, MethodSymbol operator)
void	NoteRangeCopyConstructor.accept(MethodSymbol copyConstructor, Boolean inPureScope)
void	NoteOrderingUse.note(IAggregateSymbol owner, MethodSymbol operator, boolean writtenAsAnOperatorCall)	Note the ordering use, when the operator is an ordering operator.
boolean	IsAccessedByRange.test(MethodSymbol member)
boolean	IsAccessedInPureScope.test(MethodSymbol member)
boolean	IsConceptuallyAccessed.test(MethodSymbol member)

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

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

Modifier and Type	Class	Description
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	IsGeneratedCopy	THE "is this :=: generated rather than written by hand" (default operator :=:, or the bare default operator, and not abstract).
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 that return types with arguments of type MethodSymbol

Modifier and Type	Method	Description
List<MethodSymbol>	InheritedCopySignatures.apply(IAggregateSymbol owner, ISymbol ek9Any)
Optional<MethodSymbol>	SelfCopy.apply(IAggregateSymbol aggregate)

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

Modifier and Type	Method	Description
boolean	IsGeneratedCopy.test(MethodSymbol copy)

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

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

Modifier and Type	Class	Description
final class	CallableWithArgumentsOf	THE "can the existing operator be called with the candidate default's arguments?" - each candidate parameter type assignable to the existing one's, same count.
final class	CallableWithArgumentsOf	THE "can the existing operator be called with the candidate default's arguments?" - each candidate parameter type assignable to the existing one's, same count.
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	IsSynthesisedIsSet	THE "is this '?' the one synthesised for a field-less type (FIELDLESS_IS_SET)?" of Q-COMPONENT-? (FieldlessIsSet).
final class	KeepsUnset	THE "does this RESOLVED operator keep an unset receiver unset, whatever its argument?" - the KEEPS_UNSET squirrel the bootstrap reads from @Ek9Operator(keepsUnset = true) (see UnsetKeepingOperator).
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	OperatorOwner	THE type that declares an operator - its OWNER, which a generated super call names (Contract 19, NearestOperatorAbove).
final class	OtherSpellingIn	THE first of several operators that is a different spelling of the same runtime operator as another (D59, SameRuntimeOperator).
final class	OtherSpellingIn	THE first of several operators that is a different spelling of the same runtime operator as another (D59, SameRuntimeOperator).
final class	OtherSpellingIn	THE first of several operators that is a different spelling of the same runtime operator as another (D59, SameRuntimeOperator).
final class	SingleParameterType	THE type of a method's single parameter, when it has exactly one - e.g.

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

Modifier and Type	Method	Description
Optional<MethodSymbol>	DeclaredOperator.apply(IAggregateSymbol aggregate, String operatorName)
Optional<MethodSymbol>	NearestAbove.apply(IAggregateSymbol aggregate, Function<IAggregateSymbol, Optional<MethodSymbol>> declaredOn)
Optional<MethodSymbol>	OtherSpellingIn.apply(MethodSymbol operator, Iterable<MethodSymbol> candidates)	The first of candidates that is a different spelling of the same runtime operator as operator.
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.
Optional<MethodSymbol>	OperatorResolvedOn.resolve(ISymbol receiverType, String operator, Optional<ISymbol> argumentType)	The operator operator resolves to on receiverType given an argument of argumentType (empty for ++ and --), when it resolves to exactly one.

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

Modifier and Type	Method	Description
List<ISymbol>	NarrowedReturnTypes.apply(IAggregateSymbol aggregate, MethodSymbol method)	Empty for a method that overrides nothing or keeps every parent's return type.
IAggregateSymbol	OperatorOwner.apply(MethodSymbol operator)
Optional<MethodSymbol>	OtherSpellingIn.apply(MethodSymbol operator, Iterable<MethodSymbol> candidates)	The first of candidates that is a different spelling of the same runtime operator as operator.
Optional<ISymbol>	SingleParameterType.apply(MethodSymbol method)
boolean	CallableWithArgumentsOf.test(MethodSymbol existing, MethodSymbol candidate)	True when the existing operator can be called with the candidate default's arguments.
boolean	IsSynthesisedIsSet.test(MethodSymbol method)
boolean	KeepsUnset.test(MethodSymbol operator)

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

Modifier and Type	Method	Description
Optional<MethodSymbol>	NearestAbove.apply(IAggregateSymbol aggregate, Function<IAggregateSymbol, Optional<MethodSymbol>> declaredOn)
Optional<MethodSymbol>	OtherSpellingIn.apply(MethodSymbol operator, Iterable<MethodSymbol> candidates)	The first of candidates that is a different spelling of the same runtime operator as operator.

Uses of MethodSymbol in org.ek9lang.compiler.support.retention

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

Modifier and Type	Class	Description
final class	MarkReturnsReceiverInterior	Record, on a user method or operator, that what it returns is (part of) its receiver (ReturnRetention.RECEIVER_INTERIOR, exactly the text a built-in declares).

Methods in org.ek9lang.compiler.support.retention with parameters of type MethodSymbol

Modifier and Type	Method	Description
void	MarkReturnsReceiverInterior.accept(MethodSymbol method)

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

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

Modifier and Type	Class	Description
(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	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	IsExplicitlyDefaulted	THE "is this an explicit default operator X", as opposed to one added by the bare default operator or one generated from the sameness (IsGeneratedFromSameness).
final class	IsGeneratedFromSameness	THE "is this a comparison GENERATED from the type's sameness" (B18 - never written or requested).
final class	IsHandWrittenOperator	THE "did the developer write this operator's body" (not default operator) - the sameness rules' meaning of hand-written (B18, D24).
final class	IsHashCodeOperator	THE "is this the zero-argument #?" - the hash code that goes with a type's sameness (B18).
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	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	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.

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

Modifier and Type	Method	Description
MethodSymbol	SamenessAbove.Found.operator()	Returns the value of the operator record component.

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

Modifier and Type	Method	Description
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)
Optional<MethodSymbol>	NearestSamenessAbove.apply(IAggregateSymbol owner, ISymbol ek9Any)
Optional<MethodSymbol>	NearestSurvivingSamenessAbove.apply(IAggregateSymbol owner, ISymbol ek9Any)
List<MethodSymbol>	OverriddenSamenessSignatures.apply(IAggregateSymbol owner, ISymbol ek9Any)
Optional<MethodSymbol>	SealedSameness.apply(IAggregateSymbol aggregate, ISymbol ek9Any)
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.
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)).

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

Modifier and Type	Method	Description
boolean	OrderingAvailability.isDegenerateDefaultedOrdering(MethodSymbol operator, ISymbol ek9Any)	A defaulted ordering operator on a type whose <=> degenerates because a field cannot be ordered - the case a generic instantiation reaches without any retraction marker: Box of List (its template's default operator <=> is over a T that became a List).
boolean	OrderingAvailability.isRetractedOrdering(MethodSymbol operator, ISymbol ek9Any)	Is this operator a BARE ordering operator that phase 5 retracts (OrderingAvailability.bareOrderingRetracted(IAggregateSymbol, ISymbol) of its owner)? Order-independent, so usable from POST_RESOLUTION_CHECKS on: a generic's body that uses <=> or < on T, parameterised with a type whose ordering is retracted, is E07620 at the parameterisation (D58, Steve 2026-10-21).
boolean	OrderingAvailability.isUnavailableOrdering(MethodSymbol operator, ISymbol ek9Any)	THE verdict on a call of an ordering operator written as an operator (first < second, a case < x): the operator it resolved to is one phase 5 retracts (OrderingAvailability.isRetractedOrdering(MethodSymbol, ISymbol)) or one that degenerates (OrderingAvailability.isDegenerateDefaultedOrdering(MethodSymbol, ISymbol)).
boolean	OrderingAvailability.orderingSurvives(MethodSymbol comparison, ISymbol ek9Any)	THE "does this <=> still order values once PRE_IR_CHECKS has run?" (D55, Steve 2026-10-20).
boolean	IsDerivedComparison.test(IAggregateSymbol owner, MethodSymbol operator)
boolean	IsExplicitlyDefaulted.test(MethodSymbol operator)
boolean	IsGeneratedFromSameness.test(MethodSymbol operator)
boolean	IsHandWrittenOperator.test(MethodSymbol operator)
boolean	IsHashCodeOperator.test(MethodSymbol operator)
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	NeedsRuntimeTypeCheck.test(IAggregateSymbol owner, MethodSymbol operator)
(package private) boolean	TakesItself.test(IAggregateSymbol aggregate, MethodSymbol method, String operatorName)
Optional<UnorderedProperty>	OrderingAvailability.unorderedPropertyBehind(MethodSymbol comparison, ISymbol ek9Any)	THE reason a bare <=> does not survive: the first property, from the owner of comparison upward through the <=>s each bare one builds on (read as DECLARED, so it answers the same after the retraction), whose type cannot be ordered (OrderingAvailability.isOrderable(IAggregateSymbol, ISymbol)).

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

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

Uses of MethodSymbol in org.ek9lang.compiler.symbols

Subclasses of MethodSymbol in org.ek9lang.compiler.symbols

Modifier and Type	Class	Description
class	CallSymbol	Just re-uses the bulk of method symbol for when we want to make a symbol that is a call to an actual method.
class	ServiceOperationSymbol	Scope for callable methods (operations) that are part of a Service.
class	StreamCallSymbol	Just re-uses the bulk of method symbol.

Methods in org.ek9lang.compiler.symbols that return MethodSymbol

Modifier and Type	Method	Description
MethodSymbol	MethodSymbol.clone(IScope withParentAsAppropriate)
MethodSymbol	MethodSymbol.clone(ISymbol withType, IScope withParentAsAppropriate)
protected MethodSymbol	MethodSymbol.cloneIntoMethodSymbol(MethodSymbol newCopy)
MethodSymbol	MethodSymbol.copyMethodProperties(MethodSymbol newCopy)	Just copies the properties over.
MethodSymbol	StreamCallSymbol.getResolvedPipeMethod()
MethodSymbol	MethodSymbol.setConstructor(boolean constructor)
MethodSymbol	MethodSymbol.setOperator(boolean operator)

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

Modifier and Type	Method	Description
List<MethodSymbol>	AggregateSymbol.getAllAbstractMethods()	Gets all abstract methods in this aggregate and any super classes.
List<MethodSymbol>	AggregateWithTraitsSymbol.getAllAbstractMethods()	Gets all abstract methods in this aggregate and any super classes.
default List<MethodSymbol>	IAggregateSymbol.getAllAbstractMethods()	Get all methods marked as abstract in this or any supers.
List<MethodSymbol>	AggregateSymbol.getAllAbstractMethodsInThisScopeOnly()
default List<MethodSymbol>	IAggregateSymbol.getAllAbstractMethodsInThisScopeOnly()	Get all methods in this scope only that are abstract.
List<MethodSymbol>	AggregateSymbol.getAllEffectiveMethods()
List<MethodSymbol>	AggregateWithTraitsSymbol.getAllEffectiveMethods()
default List<MethodSymbol>	IAggregateSymbol.getAllEffectiveMethods()	Gets all methods that are effective, by this I mean if supers (classes or traits) have the same method name but, it has been overridden then we would only retain the 'overridden' one as that has taken effect.
List<MethodSymbol>	AggregateSymbol.getAllMethodInThisScopeOnly()
default List<MethodSymbol>	IAggregateSymbol.getAllMethodInThisScopeOnly()	All methods abstract and non-abstract in this scope.
List<MethodSymbol>	AggregateSymbol.getAllMethods()
List<MethodSymbol>	AggregateWithTraitsSymbol.getAllMethods()
default List<MethodSymbol>	IAggregateSymbol.getAllMethods()	Get all methods on this and any supers or traits.
List<MethodSymbol>	AggregateSymbol.getAllNonAbstractMethods()
List<MethodSymbol>	AggregateWithTraitsSymbol.getAllNonAbstractMethods()
default List<MethodSymbol>	IAggregateSymbol.getAllNonAbstractMethods()	Get all methods not marked as abstract in this or any supers.
List<MethodSymbol>	AggregateSymbol.getAllNonAbstractMethodsInThisScopeOnly()
default List<MethodSymbol>	IAggregateSymbol.getAllNonAbstractMethodsInThisScopeOnly()	Get all methods in this scope only that are not abstract.
List<MethodSymbol>	AggregateSymbol.getAllOperators()
default List<MethodSymbol>	IAggregateSymbol.getAllOperators()	Get all operators on this and any supers or traits.
List<MethodSymbol>	AggregateSymbol.getConstructors()
List<MethodSymbol>	IAggregateSymbol.getConstructors()	A list of all the defined constructors.
Optional<MethodSymbol>	MethodSymbol.getGenericTemplateMethod()	The generic template's method this one was substituted from, or empty when this method was not produced by TypeSubstitution (hand-written source, introspected extern, synthesised).

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

Modifier and Type	Method	Description
protected MethodSymbol	MethodSymbol.cloneIntoMethodSymbol(MethodSymbol newCopy)
MethodSymbol	MethodSymbol.copyMethodProperties(MethodSymbol newCopy)	Just copies the properties over.
boolean	MethodSymbol.hasSameSignatureAs(MethodSymbol toMethod)	THE same-signature test: same NAME and exactly the same PARAMETER TYPES, in order.
boolean	MethodSymbol.isAbstractRequirementMetBy(MethodSymbol implementation)	THE "does this implementation meet this abstract requirement" test for a type that inherits both along different routes (Steve, 2026-10-12, decision a): ONE implementation plus any number of abstract declarations of the SAME method is not a conflict - the implementation IS the method.
boolean	MethodSymbol.isAbstractRequirementOfSameMethodAs(MethodSymbol implementation)	The relation half of MethodSymbol.isAbstractRequirementMetBy(MethodSymbol), without asking whether implementation has a body: this is abstract and implementation is a declaration of the same method.
boolean	MethodSymbol.isExactSignatureMatchTo(MethodSymbol toMethod)	This method just checks that the signature has exactly the same types as parameters.
boolean	MethodSymbol.isSameDeclarationAs(MethodSymbol toMethod)	THE "is this the very same method declaration" test: the same signature (MethodSymbol.hasSameSignatureAs(MethodSymbol)) declared by the same type (isExactSameType of the owning aggregates), or the same symbol.
boolean	MethodSymbol.isSignatureMatchTo(MethodSymbol toMethod)	Does the signature of this method match that of the method passed in.
protected boolean	AggregateSymbol.methodNotPresent(List<MethodSymbol> defined, MethodSymbol checkMethod)
boolean	AggregateWithTraitsSymbol.providesThroughDelegate(MethodSymbol method)	Does this aggregate (or a super class of it) forward method to a delegate - is it a member of a trait listed with by.
void	MethodSymbol.setGenericTemplateMethod(MethodSymbol templateMethod)	Record the generic template method this one is the substituted clone of.
void	StreamCallSymbol.setResolvedPipeMethod(MethodSymbol resolvedPipeMethod)

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

Modifier and Type	Method	Description
protected boolean	AggregateSymbol.methodNotPresent(List<MethodSymbol> defined, MethodSymbol checkMethod)