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

Packages that use ISymbol

Package	Description
org.ek9lang.compiler	B - For the EK9 compiler itself.
org.ek9lang.compiler.common	Common parts of processing that can be reused across various phases.
org.ek9lang.compiler.directives	The directives are really aimed at helping the creation of the EK9 language, but they maybe very useful in the early stages of adoption of EK9 (should there be any).
org.ek9lang.compiler.ir.instructions	IR Instruction Classes - The instruction set for EK9 intermediate representation.
org.ek9lang.compiler.ir.support	IR Support Utilities - Helper classes for IR generation and processing.
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.phase5.callgraph	Call graph infrastructure for EK9 compiler static analysis.
org.ek9lang.compiler.phase5.construction
org.ek9lang.compiler.phase5.flow
org.ek9lang.compiler.phase5.lockanalysis	Data model for slice-2 deadlock detection analysis results.
org.ek9lang.compiler.phase7	K - Intermediate Representation Generation.
org.ek9lang.compiler.phase7.calls
org.ek9lang.compiler.phase7.generation
org.ek9lang.compiler.phase7.generator
org.ek9lang.compiler.phase7.support
org.ek9lang.compiler.phase7.synthesis	Synthetic operator and method generation for EK9.
org.ek9lang.compiler.phase7.synthesis.support	Support classes for synthetic operator IR generation.
org.ek9lang.compiler.repair	THE automatic source repairs - one engine for every door (ek9 -ff, ek9_format, the MCP editors, ek9_write_file, ek9_edit_file, ek9_compile).
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.inputvariety
org.ek9lang.compiler.symbolic
org.ek9lang.compiler.symbols	This is the main source of EK9 Symbols used within the compiler.

Uses of ISymbol in org.ek9lang.compiler

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

Modifier and Type	Class	Description
(package private) final class	ParseTreeSymbolLocator	Find the ISymbol at a given token position by traversing the parse tree.

Methods in org.ek9lang.compiler that return ISymbol

Modifier and Type	Method	Description
ISymbol	ParsedModule.getRecordedSymbol(org.antlr.v4.runtime.tree.ParseTree node)	Locate and return a recorded symbol against part of the parse tree, this may return null if nothing has been recorded.
ISymbol	ParsedModuleTransientData.getRecordedSymbol(org.antlr.v4.runtime.tree.ParseTree node)	Locate and return a recorded symbol against part of the parse tree, this may return null if nothing has been recorded.

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

Modifier and Type	Method	Description
Optional<ISymbol>	ParseTreeSymbolLocator.apply(CompilableSource source, IToken targetToken)
Optional<ISymbol>	ParsedModule.locateSymbolAtToken(CompilableSource source, IToken targetToken)	Locate a symbol at a specific token position in the source.
Optional<ISymbol>	CompilableProgram.resolveByFullyQualifiedSearch(SymbolSearch search)	Resolve some symbol via a fully qualified search.
Optional<ISymbol>	CompilableProgram.resolveFromImplicitScopes(SymbolSearch search)	Search in the implicit ek9 module namespaces of: org.ek9.lang etc.
Optional<ISymbol>	CompilableProgram.resolveFromModule(String moduleName, SymbolSearch search)	A package name (moduleName) can actually have multiple parsedModules (i.e.
Optional<ISymbol>	CompilableProgram.resolveReferenceFromModule(String moduleName, SymbolSearch search)	Check the existing set of references in the moduleName.

Methods in org.ek9lang.compiler with parameters of type ISymbol

Modifier and Type	Method	Description
void	ParsedModule.recordSymbol(org.antlr.v4.runtime.tree.ParseTree node, ISymbol symbol)	Record a particular node context with a particular symbol.
void	ParsedModuleTransientData.recordSymbol(org.antlr.v4.runtime.tree.ParseTree node, ISymbol symbol, Module module)	Record a particular node context with a particular symbol.

Uses of ISymbol in org.ek9lang.compiler.common

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

Modifier and Type	Class	Description
final class	BareDefaulted	Test if a symbol is a BARE-defaulted operator, i.e.
final class	CloseableResourceToBeChecked	Checks if a symbol should be tracked as a closeable resource.
final class	Defaulted	THE test that an operator was written as default operator X (or added by the bare default operator): the DEFAULTED squirrel, so the compiler wrote its body.
final class	ExternallyImplemented	Test if a symbol is externally implemented.
final class	ForwardTargetDispatched	Test if a (generic base function) symbol is forward-target dispatched: the closed set of extern abstract function types a built-in invokes through the erased base _call(Any...) path with the argument held RAW — MutexKey (via MutexLock.enter) and Comparator (via PriorityQueue.withComparator/Ek9Sort).
final class	LhsFromPreFlowOrError	Access the Symbol for the lhs of the preflow statement.
final class	SuitableGenusOrError	Checks for a type is resolved and is suitable genus and category.
final class	SymbolSignatureExtractor	Function that extracts signature-qualified-name from a symbol.
final class	SymbolTypeOrException	Just gets the type from a symbol, or throws a compiler exception if missing.
final class	TypeNameOrException	Extracts the fully qualified type name from the symbol.
final class	UninitialisedPropertyToBeChecked	THE test that a symbol is a PROPERTY declared with no value, so every access to it is questionable until a constructor (or a guard) has set it: a VariableSymbol that is a property field and UninitialisedAtDeclaration.declaredWithNoValue(ISymbol).
final class	UninitialisedVariableToBeChecked	Checks if a variable should be processed as a possible uninitialised variable.

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

Modifier and Type	Method	Description
ISymbol	LhsFromPreFlowOrError.apply(EK9Parser.PreFlowStatementContext ctx)
ISymbol	SymbolTypeOrException.apply(ISymbol symbol)
ISymbol	TypedSymbolAccess.getRecordedAndTypedSymbol(org.antlr.v4.runtime.tree.ParseTree node)	Gets any symbol associated with this node.
ISymbol	SymbolsAndScopes.getRecordedSymbol(org.antlr.v4.runtime.tree.ParseTree node)
ISymbol	TypeNameOrException.typeSymbolOf(ISymbol symbol)	THE type SYMBOL whose fully qualified name TypeNameOrException.apply(ISymbol) emits - deliberately the same returning-symbol rule, yielding the symbol rather than its name.

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

Modifier and Type	Method	Description
Optional<ISymbol>	SuitableGenusOrError.apply(org.antlr.v4.runtime.ParserRuleContext ctx)
Optional<ISymbol>	HasRealOperator.declaredAt(IAggregateSymbol level)	The operator this one LEVEL declares (not its supers or traits), if any.
List<ISymbol>	CodeFlowAnalyzer.getSymbolsNotMeetingAcceptableCriteria(IScope inScope)
List<ISymbol>	CodeFlowMap.getSymbolsNotMeetingAcceptableCriteria(IScope inScope)	Just provide a list of variables that have not been marked as meeting acceptable criteria in the scope.
List<ISymbol>	SymbolsAndScopes.getUninitialisedVariables(IScope inScope)
Optional<ISymbol>	SymbolsAndScopes.resolveOrDefine(PossibleGenericSymbol parameterisedSymbol, SemanticErrorReporter errorListener)	Resolve or define a parameterised type here.
Optional<ISymbol>	TypeDefResolver.typeDefToSymbol(String typeDefinition)	Use an ek9 parser to accept a String of a typeDef and convert to a symbol (if it can be found).

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

Modifier and Type	Method	Description
String	SymbolSignatureExtractor.apply(ISymbol symbol)
ISymbol	SymbolTypeOrException.apply(ISymbol symbol)
String	TypeNameOrException.apply(ISymbol symbol)
ClassModifierChangeViability	ClassModifierChangePredicate.canChange(ISymbol symbol, ClassModifierChangePredicate.Mode mode)
VisibilityChangeViability	VisibilityChangePredicate.canChangeTo(ISymbol member, String targetAccessModifier)
static String	TestPrograms.declaredExitCodeOf(ISymbol symbol)	The exit code a test DECLARED with "EXIT:<n>", or null when it declared none.
static boolean	UninitialisedAtDeclaration.declaredWithNoValue(ISymbol symbol)	True when the symbol was declared with no value: a property, local or returning variable that name as Type? left unset.
boolean	CodeFlowAnalyzer.doesSymbolMeetAcceptableCriteria(ISymbol identifierSymbol, IScope inScope)
boolean	CodeFlowMap.doesSymbolMeetAcceptableCriteria(ISymbol identifierSymbol, IScope inScope)	Check if a variable meets the criteria of being acceptable.
protected void	TypedSymbolAccess.emitTypeNotResolvedError(ISymbol symbol)
void	SymbolsAndScopes.enterNewConstant(ISymbol symbol, org.antlr.v4.runtime.tree.ParseTree node, SymbolChecker symbolChecker)	Create a new constant as declared in the constants section and records the symbol.
void	SymbolsAndScopes.enterNewLiteral(ISymbol symbol, org.antlr.v4.runtime.tree.ParseTree node)	For literals, we only record in the parsedModule.
void	SymbolsAndScopes.enterNewSymbol(ISymbol symbol, org.antlr.v4.runtime.tree.ParseTree node)	A new symbol has been encountered and is defined within the current scope in the scope stack and recorded in the parsedModule against the appropriate node.
static String	TestPrograms.executionGroupOf(ISymbol symbol)	The sequential execution group a test belongs to.
static int	TestPrograms.expectedExitCodeOf(ISymbol symbol)	The exit code a test program must end with for the test to pass: the one it declared with "EXIT:<n>", else 0.
static boolean	UninitialisedAtDeclaration.hasInitialiser(ISymbol symbol)	True when the symbol was given a value where it was declared (the opposite of UninitialisedAtDeclaration.declaredWithNoValue(ISymbol)).
static boolean	BareDefaulted.is(ISymbol symbol)	The same test without an instance, for a static helper.
static boolean	Defaulted.is(ISymbol symbol)	The same test without an instance, for a static helper.
static boolean	ExternallyImplemented.is(ISymbol symbol)	The same test without an instance, for a static helper.
static boolean	TypedSymbolAccess.isAlreadyInError(ISymbol symbol)	THE test that a symbol has no type because the expression it was declared from is already reported (E-7): its readers stay silent rather than adding a 'type not resolved' for every later use.
boolean	SymbolsAndScopes.isErrorResultAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isGetOptionalAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isInitialiserReplaced(ISymbol returningVariable, IScope inScope)	True when every path to the end of the scope has given the returning variable a new value - the definite assignment E08050 asks of a returning variable with no initialiser, asked of one that has an initialiser - so the value it was declared with cannot be the one returned.
static boolean	CloseableResourceToBeChecked.isLocalVariable(ISymbol symbol)	THE 'is this a local variable' for resource management: a variable that is not a property, not an incoming parameter and not the returning parameter.
boolean	CloseableResourceToBeChecked.isManagedCloseableType(ISymbol type)	THE 'is this a type whose values the compiler must see closed' predicate: an aggregate with a close operator that is not one of the global standard streams and not a bare type parameter (BareTypeParameter - a generic type that HAS type parameters is closeable when it has a close).
boolean	SymbolsAndScopes.isNextIteratorAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isOkResultAccessSafe(ISymbol identifierSymbol)
protected boolean	TypedSymbolAccess.isPureReassignmentDisallowed(ISymbol leftHandSideSymbol)	THE purity half of E08100 (NO_PURE_REASSIGNMENT): true when a plain reassignment (:=) of leftHandSideSymbol would be refused here because the processing scope is pure.
boolean	SymbolsAndScopes.isSymbolAccessSafe(ISymbol identifierSymbol)	true if identifier is safe to access.
boolean	SymbolsAndScopes.isSymbolAccessSafe(ISymbol identifierSymbol, IScope inScope)	true if identifier is safe to access within the specified scope (rather than the current top scope).
static boolean	TestPrograms.isTestProgram(ISymbol symbol)	Whether this symbol is itself a @Test program.
boolean	SymbolsAndScopes.isVariableInitialised(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isVariableInitialised(ISymbol identifierSymbol, IScope inScope)
static boolean	TestPrograms.isWithinTestProgram(ISymbol symbol)	Whether this symbol is a test program or a method declared inside one.
void	SymbolsAndScopes.markErrorResultAccessSafe(ISymbol identifierSymbol, IScope inScope)
void	SymbolsAndScopes.markGetOptionalAccessSafe(ISymbol identifierSymbol, IScope inScope)
void	SymbolsAndScopes.markNextIteratorAccessSafe(ISymbol identifierSymbol, IScope inScope)
void	SymbolsAndScopes.markOkResultAccessSafe(ISymbol identifierSymbol, IScope inScope)
void	SymbolsAndScopes.markSymbolAccessSafe(ISymbol identifierSymbol, IScope inScope)	Record an identifier as being safe to access.
void	SymbolsAndScopes.markSymbolAsInitialised(ISymbol identifierSymbol, IScope inScope)	Record an identifier was initialised.
void	CodeFlowAnalyzer.markSymbolAsMeetingAcceptableCriteria(ISymbol identifierSymbol, IScope inScope)
void	CodeFlowMap.markSymbolAsMeetingAcceptableCriteria(ISymbol identifierSymbol, IScope inScope)	Ensures that an identifier symbol is now marked as meeting the criteria of being acceptable.
void	TypedSymbolAccess.recordATypedSymbol(ISymbol symbol, org.antlr.v4.runtime.tree.ParseTree node)	Records a symbol against a node and also emits an error if its type has not been set.
void	SymbolsAndScopes.recordDeclarationOfVariableUsingIterator(ISymbol identifierSymbol)
void	SymbolsAndScopes.recordDeclarationOfVariableUsingOptional(ISymbol identifierSymbol)
void	SymbolsAndScopes.recordDeclarationOfVariableUsingResult(ISymbol identifierSymbol)
void	SymbolsAndScopes.recordInitialisedReturningVariable(ISymbol returningVariable)	Follow a returning variable that was declared WITH a value: from here on SymbolsAndScopes.isInitialiserReplaced(ISymbol, IScope) says whether every path has since given it a new one.
void	SymbolsAndScopes.recordInitialiserReplaced(ISymbol returningVariable)	Record a plain assignment to a followed returning variable: on this path its declared value is replaced.
void	CodeFlowAnalyzer.recordSymbol(ISymbol identifierSymbol, IScope inScope)
void	CodeFlowMap.recordSymbol(ISymbol identifierSymbol, IScope inScope)	Records a symbol against the specific scope if it is a variable to be analysed.
void	SymbolsAndScopes.recordSymbol(ISymbol symbol, org.antlr.v4.runtime.tree.ParseTree node)	Record a symbol against a specific node (so it can be looked up later).
void	SymbolsAndScopes.recordSymbolAssignment(ISymbol identifierSymbol)	Record an identifier was assigned and therefore initialised.
void	SymbolsAndScopes.recordSymbolDeclaration(ISymbol identifierSymbol)	Records a variable against the appropriate scope.
void	SymbolsAndScopes.recordSymbolDeclaration(ISymbol identifierSymbol, IScope inScope)	Record variable declaration against a specific scope.
boolean	BareDefaulted.test(ISymbol symbol)
boolean	CloseableResourceToBeChecked.test(ISymbol symbol)
boolean	Defaulted.test(ISymbol symbol)
boolean	ExternallyImplemented.test(ISymbol symbol)
boolean	ForwardTargetDispatched.test(ISymbol symbol)
boolean	UninitialisedPropertyToBeChecked.test(ISymbol symbol)
boolean	UninitialisedVariableToBeChecked.test(ISymbol symbol)
ISymbol	TypeNameOrException.typeSymbolOf(ISymbol symbol)	THE type SYMBOL whose fully qualified name TypeNameOrException.apply(ISymbol) emits - deliberately the same returning-symbol rule, yielding the symbol rather than its name.
boolean	SuitableGenusOrError.validOrError(org.antlr.v4.runtime.ParserRuleContext ctx, ISymbol symbol)	Checks a symbol that is already in hand (for example the type a call constructs), reporting at ctx.

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

Modifier	Constructor	Description
	HasRealComparator(ISymbol ek9Any)
	HasRealOperator(ISymbol ek9Any, String operatorGlyph, boolean binary)

Constructor parameters in org.ek9lang.compiler.common with type arguments of type ISymbol

Modifier	Constructor	Description
protected	CodeFlowMap(Predicate<ISymbol> isVariableToBeChecked, Predicate<SymbolAccess> meetsCriteria, Consumer<SymbolAccess> markAsMeetingCriteria)
	SymbolTypeOrException(UnaryOperator<ISymbol> typeResolver)	Create with a type resolver for Scenario 3 type parameter substitution.
	TypeNameOrException(Function<ISymbol,String> typeResolver)	Create with a type resolver for Scenario 3 type parameter substitution.

Uses of ISymbol in org.ek9lang.compiler.directives

Methods in org.ek9lang.compiler.directives with parameters of type ISymbol

Modifier and Type	Method	Description
(package private) File	DirectiveClassBytes.mainClassFile(CompilationEvent compilationEvent, ISymbol symbol)	The main (non-dev) class file location for a symbol — used for the "not found" diagnostic.
(package private) Optional<byte[]>	DirectiveClassBytes.read(CompilationEvent compilationEvent, ISymbol symbol)	The bytes for a symbol's generated class, using the dev-then-main lookup — but asking the sink rather than the filesystem.
protected void	ByteCodeDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	ComplexityDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	CounterexampleDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	DebugDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective directive, ISymbol symbol)
protected void	GenusDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	ImplementsDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	InputVarietyDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	IRDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	NotResolvedDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective directive, ISymbol symbol)
protected void	ObligationsDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected abstract void	ResolutionDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective directive, ISymbol symbol)
protected void	ResolvedDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective directive, ISymbol symbol)
protected void	SquirrelledDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	VerifiedDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)

Uses of ISymbol in org.ek9lang.compiler.ir.instructions

Methods in org.ek9lang.compiler.ir.instructions that return ISymbol

Modifier and Type	Method	Description
ISymbol	Field.getSymbol()	Get the symbol representing this field.
ISymbol	IRConstruct.getSymbol()
ISymbol	OperationInstr.getSymbol()

Methods in org.ek9lang.compiler.ir.instructions that return types with arguments of type ISymbol

Modifier and Type	Method	Description
(package private) Optional<ISymbol>	ConstructSuperTypeResolver.apply(ISymbol symbol)
List<ISymbol>	IRConstruct.getImplementedTraits()
Optional<ISymbol>	IRConstruct.getSuperType()	The single nominal super type this construct extends, resolved from the symbol's declared super (function super-chain, Scenario-2 wrapper base, or aggregate super).

Methods in org.ek9lang.compiler.ir.instructions with parameters of type ISymbol

Modifier and Type	Method	Description
void	IRConstruct.addImplementedTrait(ISymbol traitSymbol)
(package private) Optional<ISymbol>	ConstructSuperTypeResolver.apply(ISymbol symbol)
boolean	IRConstruct.isForSymbol(ISymbol toCheck)
static Field	Field.staticField(ISymbol symbol, String name, String typeName, DebugInfo debugInfo)	Factory method for creating a static field (e.g., enum constants).

Constructors in org.ek9lang.compiler.ir.instructions with parameters of type ISymbol

Modifier	Constructor	Description
	Field(ISymbol symbol, String name, String typeName, DebugInfo debugInfo)	Create a new instance Field IR node.
	IRConstruct(ISymbol symbol, String sourceFileName)
	OperationInstr(ISymbol symbol, DebugInfo debugInfo)

Uses of ISymbol in org.ek9lang.compiler.ir.support

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

Modifier and Type	Class	Description
class	CallMetaDataExtractor	Extracts call metadata from symbols for use in IR generation.

Methods in org.ek9lang.compiler.ir.support with parameters of type ISymbol

Modifier and Type	Method	Description
CallMetaDataDetails	CallMetaDataExtractor.apply(ISymbol symbol)

Uses of ISymbol in org.ek9lang.compiler.phase1

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

Modifier and Type	Class	Description
(package private) final class	ImplementationPresentOrError	Typically used with programs.
(package private) class	ProcessAsDispatcherIfNecessary	If any of its OWN methods is marked as 'dispatcher' then mark this class as a 'dispatcher'.
(package private) final class	SetGenericSuperIfAppropriate
(package private) class	ValidAggregateConstructorsOrError	Checks that if the aggregate is a generic class that the appropriate public constructors are in place.

Methods in org.ek9lang.compiler.phase1 that return ISymbol

Modifier and Type	Method	Description
ISymbol	ConflictingTokens.symbol()	Returns the value of the symbol record component.

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

Modifier and Type	Method	Description
void	ImplementationPresentOrError.accept(ISymbol aggregate, EK9Parser.MethodDeclarationContext ctx)
void	ProcessAsDispatcherIfNecessary.accept(ISymbol possibleAggregate)
void	SetGenericSuperIfAppropriate.accept(ISymbol symbol)
void	ValidAggregateConstructorsOrError.accept(ISymbol possibleAggregate)

Constructors in org.ek9lang.compiler.phase1 with parameters of type ISymbol

Modifier	Constructor	Description
(package private)	ConflictingTokens(IToken tokenInError, IToken firstUse, ISymbol symbol)	Creates an instance of a ConflictingTokens record class.

Uses of ISymbol in org.ek9lang.compiler.phase2

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

Modifier and Type	Class	Description
(package private) final class	GenericConstructorArgumentTypesOrError	A generic type's inferring constructor must take exactly its type parameters, in the same order - that is what lets 'Box(21)' infer 'Box of Integer'.
(package private) final class	HttpAccessOrError	Checks HTTP Access for service operations because some require HTTP_SOURCE, but others do not support it.
(package private) final class	NotGenericTypeParameterOrError	Checks that the variable supplied (if not null and has a type), does not have a type that is a genericTypeParameter.
(package private) class	PopulateConstrainedTypeOrError	For Constrained Types, focus on checking it is possible to constrain the type and if so then clones the appropriate methods/operators over and alters the types as appropriate.
(package private) final class	SanitizedParameterTypeOrError	Validates that the 'sanitized' keyword is used correctly: 1.
(package private) final class	SuitableToExtendOrError	Checks for a type is resolved and is suitable to be extended from (in basic terms).
(package private) final class	SupportsBeingConstrainingType	Only types of a specific genus can be used as constraints on the generic type 'T'.
(package private) final class	ValidPathParameterOrError	Checks the PATH value (if this is a path parameter) and ensures that the name appears in the path itself on the operation.

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

Modifier and Type	Method	Description
Optional<ISymbol>	SuitableToExtendOrError.apply(org.antlr.v4.runtime.ParserRuleContext ctx)

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

Modifier and Type	Method	Description
void	GenericConstructorArgumentTypesOrError.accept(ISymbol possibleGeneric)
void	HttpAccessOrError.accept(ISymbol param)
void	NotGenericTypeParameterOrError.accept(ISymbol variable)
void	PopulateConstrainedTypeOrError.accept(AggregateSymbol newType, ISymbol constrainedType)
(package private) void	PopulateConstrainedTypeOrError.accept(AggregateSymbol newType, ISymbol constrainedType, boolean hasConstraint)
void	SanitizedParameterTypeOrError.accept(ISymbol param)
boolean	SupportsBeingConstrainingType.test(ISymbol symbol)
boolean	ValidPathParameterOrError.test(ServiceOperationSymbol operation, ISymbol param)

Uses of ISymbol in org.ek9lang.compiler.phase3

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

Modifier and Type	Class	Description
(package private) final class	AssignmentOrError	Checks the assignments for operator : := = and :=? that's all.
(package private) final class	CoalescingComparisonTypeOrError	E07187 (D24 Q4 REVISED, Steve 2026-10-20): the comparison coalescing operators <? and >? select one operand by <=>.
(package private) class	ComparatorPresentOrError	Given a symbol, this check that the type that the symbol has can support the '<=>' operator.
(package private) final class	ConstructorThisEscapeOrError	Inside a constructor body, 'this' must not be passed as an argument to any NON-PURE call.
(package private) class	DecrementPresentOrError	Given a symbol, this check that the type that the symbol has can support the '--' operator.
(package private) final class	ExceptionTypeOrError	Checks that the symbol passed has a type and that the type is compatible with an EK9 Exception.
(package private) final class	GenusLocator	Attempts to locate an Trait by name.
(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) class	HashCodePresentOrError	Given a symbol, this check that the type that the symbol has can support the '#?' operator.
(package private) final class	IdentifierOrError	Used for pure identifier resolution and recording.
(package private) final class	IdentifierReferenceOrError	Ensures that 'identifierReference' is now resolved and hangs together and is 'typed' or emit "not resolved" error.
(package private) class	IncrementPresentOrError	Given a symbol, this check that the type that the symbol has can support the '++' operator.
(package private) class	IsConvertableToStringOrError	Checks if a type has the $ 'toString' method or a 'promotion' #^ to a String method.
(package private) final class	IsSetPresentOrError	Given a symbol, this check that the type that the symbol has can support the '?' operation.
(package private) final class	MutableOrError	Checks if a symbol can be mutated, this is nothing to do with a pure context.
(package private) final class	NoDelegateMethodClashesOrError	As it is possible to have a variable that is a delegate 'function', it means that to call that function, the ek9 developer would use variable-name(parameters).
(package private) final class	NotAbstractOrError	THE 'cannot call an abstract function or type' check (CANNOT_CALL_ABSTRACT_TYPE), with the located message.
(package private) class	OperatorTest	Provides a common set of operations for checking operators.
(package private) final class	PropertyFieldOrError	Used for resolving and recoding of fields on specific types.
(package private) final class	PureProcessingInPureContextOrError	Just check that with in the current 'context' - if pure that the processing call is pure.
(package private) final class	RequiredOperatorPresentOrError	To be used with operators on aggregates (except for the is-set ? operator, that has to deal with functions).
(package private) final class	ResetReferencedOnWrite	THE rule for when a write to a local resets its 'referenced' flag (E08090): a write is not a use.
(package private) final class	SetTypeFromReturningParam	Looks at the returning param (if not null) and sets the symbol type as appropriate.
(package private) final class	SymbolFromContextOrError	Returns the appropriate symbol from the symbol and scope management component.
(package private) final class	SymbolReferencedOrError	Checks if a symbol has been referenced or not (can be null - no error).
(package private) final class	SymbolsFromParamExpression	Just extracts the ISymbols from the expression contexts and issues not resolved errors if any are not present.
(package private) final class	SymbolTypeOrEmpty	Provides the PossibleGenericSymbol type of the symbol if it has been typed, or empty.
(package private) class	TraitAccessibleOrError	Checks that a trait access like T1.xyz() - is allowed i.e.
(package private) final class	ValidNamedArgumentsOrError	If the Ek9 developer has used named parameters, then they must be validated.
(package private) final class	VoidTypeOrError	Checks if a symbol's type is Void and emits E10010 if so.

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

Modifier and Type	Method	Description
ISymbol	IdentifierOrError.apply(EK9Parser.IdentifierContext ctx)
ISymbol	PropertyFieldOrError.apply(EK9Parser.IdentifierContext ctx, IScope scopeToResolveIn)
ISymbol	SymbolFromContextOrError.apply(org.antlr.v4.runtime.ParserRuleContext ctx)
ISymbol	StreamFunctionCheckData.currentStreamType()	Returns the value of the currentStreamType record component.
ISymbol	DelegateFunctionData.delegateSymbol()	Returns the value of the delegateSymbol record component.
ISymbol	CaptureEvaluationScope.OuterField.field()	Returns the value of the field record component.
ISymbol	CovarianceData.fromVar()	Returns the value of the fromVar record component.
(package private) ISymbol	RangeOrError.inRangeOf(EK9Parser.ExpressionContext ctx)	The range of x in a ... b: the start is rangeFrom and the end is right of the comparison alternative (the range form shares that level, so its end binds like any comparison operand - PRECEDENCE (4), Steve 2026-10-07).
ISymbol	ExprLeftAndRightData.left()	Returns the value of the left record component.
ISymbol	TypeCompatibilityData.lhs()	Returns the value of the lhs record component.
ISymbol	TypeCompatibilityData.rhs()	Returns the value of the rhs record component.
ISymbol	ExprLeftAndRightData.right()	Returns the value of the right record component.
ISymbol	CheckOperatorData.symbol()	Returns the value of the symbol record component.
ISymbol	SymbolAccessData.symbol()	Returns the value of the symbol record component.
ISymbol	StreamAggregateCheckData.symbolType()	Returns the value of the symbolType record component.
ISymbol	CovarianceData.toVar()	Returns the value of the toVar record component.

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

Modifier and Type	Method	Description
Optional<ISymbol>	GenusLocator.apply(String toResolve)
Optional<ISymbol>	GetIteratorType.apply(IAggregateSymbol aggregate)
Optional<ISymbol>	IdentifierReferenceOrError.apply(EK9Parser.IdentifierReferenceContext ctx)
Optional<ISymbol>	RequiredOperatorPresentOrError.apply(CheckOperatorData checkOperatorData)
Optional<ISymbol>	RequiredOperatorPresentOrError.apply(CheckOperatorData checkOperatorData, CallSymbol callSymbol)	Overloaded version that accepts a CallSymbol and sets the resolved method on it.
List<ISymbol>	SymbolsFromParamExpression.apply(EK9Parser.ParamExpressionContext ctx)
List<ISymbol>	MethodOnAggregateData.callArguments()	Returns the value of the callArguments record component.
List<ISymbol>	DelegateFunctionData.callArgumentTypes()	Returns the value of the callArgumentTypes record component.
List<ISymbol>	FunctionData.callArgumentTypes()	Returns the value of the callArgumentTypes record component.
(package private) Optional<List<ISymbol>>	LiteralTargetType.dictKeyValueTypes(EK9Parser.DictContext ctx)	The declared key and value types of the Dict literal at this context, if it has a Dict target.
List<ISymbol>	ParametersData.from()	Returns the value of the from record component.
protected Optional<ISymbol>	OperatorTest.getSymbolType(ISymbol symbol)
(package private) Optional<List<ISymbol>>	LiteralTargetType.listElementType(EK9Parser.ListContext ctx)	The declared type parameters of the List literal at this context, if it has a List target.
List<ISymbol>	SanitizedCheckData.superParameters()	Returns the value of the superParameters record component.
List<ISymbol>	SanitizedCheckData.thisParameters()	Returns the value of the thisParameters record component.
List<ISymbol>	ParametersData.to()	Returns the value of the to record component.

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

Modifier and Type	Method	Description
void	AssignmentOrError.accept(IToken op, ISymbol leftHandSideSymbol)
(package private) void	CannotAssignFromSanitizedOrError.accept(IToken assignmentOp, ISymbol lhsSymbol, ISymbol rhsSymbol)	Check if assignment from a sanitized parameter is allowed.
(package private) void	CloseOperatorCallOrError.accept(IToken errorLocation, ISymbol resolved, boolean viaSuper)	Check a call that has been resolved.
void	CoalescingComparisonTypeOrError.accept(IToken operatorUse, ISymbol commonType)	Judge the common type of a comparison coalescing operator's operands.
void	ConstructorThisEscapeOrError.accept(EK9Parser.ParamExpressionContext paramExpression, ISymbol resolvedTarget)
void	ExceptionTypeOrError.accept(IToken errorLocation, ISymbol symbol)
void	MutableOrError.accept(IToken locationForError, ISymbol symbol)
void	NoDelegateMethodClashesOrError.accept(ISymbol symbol)
void	NotAbstractOrError.accept(IToken token, ISymbol symbol)
void	PureProcessingInPureContextOrError.accept(IToken accessLocationToken, ISymbol symbol)
void	ResetReferencedOnWrite.accept(ISymbol lhsSymbol, IToken operator)
void	SetTypeFromReturningParam.accept(ISymbol symbol, EK9Parser.ReturningParamContext ctx)
void	SymbolReferencedOrError.accept(ISymbol symbol)
(package private) void	SymbolReferencedOrError.accept(ISymbol symbol, String detail)	As SymbolReferencedOrError.accept(ISymbol), with what else the developer needs to know to fix it (placed after the name, before the standard text).
void	TraitAccessibleOrError.accept(org.antlr.v4.runtime.Token errorLocation, ISymbol symbol)
Optional<PossibleGenericSymbol>	SymbolTypeOrEmpty.apply(ISymbol symbol)
protected Optional<Boolean>	IsSetPresentOrError.decidedForType(ISymbol symbolType)	The types '?' is decided for without a search - shared by IsSetPresentOrError.test(IToken, ISymbol) and OperatorTest.testType(IToken, ISymbol) (B-2, so the coalescing operators judging a common type get them too).
protected Optional<Boolean>	OperatorTest.decidedForType(ISymbol symbolType)	THE step OperatorTest.test(IToken, ISymbol) and OperatorTest.testType(IToken, ISymbol) both take before searching for the operator: a type for which this operator is decided without a search (for '?': a function, Any, text, an enumeration).
(package private) static String	CaptureEvaluationScope.deniedReferenceText(ISymbol symbol)	The text of a denial, the same at every site: what was named and where it is declared.
(package private) boolean	CaptureEvaluationScope.deniesAccessTo(org.antlr.v4.runtime.tree.ParseTree node, ISymbol symbol)	THE "may this code reach that property?" check for a BARE name, shared by every site that resolves one against the scope stack: a read (IdentifierReferenceOrError), an assignment, an object-access start, a pre-flow or a for-range (IdentifierOrError), and a stream pipeline part (ResolveFunctionOrDelegateByNameOrError: a sink, head, map with, tee in).
(package private) void	LiteralTargetType.elementFitsOrError(org.antlr.v4.runtime.ParserRuleContext elementCtx, ISymbol element, ISymbol declaredType, SemanticErrorReporter errorListener)	An element of a targeted literal must be assignable to the declared element (or key/value) type - exactly the test a single assignment applies.
(package private) static CheckOperatorData	CheckOperatorData.forType(ISymbol type, IToken operatorUseToken, MethodSymbolSearch search)	An operator required of a TYPE, by a caller that has no value of it.
protected MethodSymbolSearch	ComparatorPresentOrError.getMethodSymbolSearch(ISymbol symbolType)
protected MethodSymbolSearch	DecrementPresentOrError.getMethodSymbolSearch(ISymbol symbolType)
protected MethodSymbolSearch	HashCodePresentOrError.getMethodSymbolSearch(ISymbol symbolType)
protected MethodSymbolSearch	IncrementPresentOrError.getMethodSymbolSearch(ISymbol symbolType)
protected MethodSymbolSearch	IsSetPresentOrError.getMethodSymbolSearch(ISymbol symbolType)
protected abstract MethodSymbolSearch	OperatorTest.getMethodSymbolSearch(ISymbol symbolType)
protected Optional<ISymbol>	OperatorTest.getSymbolType(ISymbol symbol)
(package private) static boolean	ControlIsBooleanOrError.isCondition(ISymbol type, ISymbol booleanType)	True if a value of this type can be a condition: a Boolean, or a type that promotes to Boolean with '#^'.
boolean	OperatorTest.notAnEnumerationTypeOrError(IToken operatorUse, ISymbol operand)	Is this operand a value rather than the enumeration TYPE itself? E07630 when it is the type.
(package private) boolean	RequiredOperatorPresentOrError.notAnEnumerationTypeOrError(IToken operatorUse, ISymbol operand)	THE check that an operand is a VALUE, not the enumeration TYPE itself (CardSuit > CardSuit.Hearts), which is E07630.
(package private) void	ConstructorThisEscapeOrError.recordDynamicClass(ISymbol target, EK9Parser.AssignmentExpressionContext assignment)	Inside a constructor, mark a local that is given a dynamic class capturing 'this'.
boolean	IsConvertableToStringOrError.test(IToken errorReportingLocation, ISymbol typeSymbol)
boolean	IsSetPresentOrError.test(IToken operatorUse, ISymbol symbol)
boolean	OperatorTest.test(IToken operatorUse, ISymbol symbol)
(package private) boolean	StreamElementNotCloseableOrError.test(IToken location, String producer, ISymbol elementType)
boolean	VoidTypeOrError.test(ISymbol symbol)	Test if the symbol has a Void type.
boolean	OperatorTest.testType(IToken operatorUse, ISymbol type)	As OperatorTest.test(IToken, ISymbol), for a TYPE rather than a value of it - e.g.

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

Modifier and Type	Method	Description
void	ValidNamedArgumentsOrError.accept(EK9Parser.ParamExpressionContext ctx, List<ISymbol> parameters)

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

Modifier	Constructor	Description
(package private)	CheckOperatorData(ISymbol symbol, IToken operatorUseToken, MethodSymbolSearch search)	An operator used on a VALUE (the usual case).
(package private)	CheckOperatorData(ISymbol symbol, IToken operatorUseToken, MethodSymbolSearch search, boolean onType)	Creates an instance of a CheckOperatorData record class.
(package private)	CovarianceData(IToken token, Supplier<String> errorMessage, ISymbol fromVar, ISymbol toVar)	Creates an instance of a CovarianceData record class.
(package private)	DelegateFunctionData(IToken token, ISymbol delegateSymbol, List<ISymbol> callArgumentTypes)	Creates an instance of a DelegateFunctionData record class.
(package private)	ExprLeftAndRightData(ISymbol left, ISymbol right)	Creates an instance of a ExprLeftAndRightData record class.
(package private)	OuterField(ISymbol field, boolean fromDynamicClass, boolean denied)	Creates an instance of a OuterField record class.
(package private)	StreamAggregateCheckData(org.antlr.v4.runtime.Token errorLocation, IAggregateSymbol aggregateSymbol, ISymbol symbolType)	Creates an instance of a StreamAggregateCheckData record class.
(package private)	StreamFunctionCheckData(org.antlr.v4.runtime.Token errorLocation, FunctionSymbol functionSymbol, ISymbol currentStreamType)	Creates an instance of a StreamFunctionCheckData record class.
(package private)	SymbolAccessData(IToken token, IScope fromScope, IScope inScope, String symbolName, ISymbol symbol)	Creates an instance of a SymbolAccessData record class.
(package private)	TypeCompatibilityData(IToken location, ISymbol lhs, ISymbol rhs)	Creates an instance of a TypeCompatibilityData record class.

Constructor parameters in org.ek9lang.compiler.phase3 with type arguments of type ISymbol

Modifier	Constructor	Description
(package private)	DelegateFunctionData(IToken token, ISymbol delegateSymbol, List<ISymbol> callArgumentTypes)	Creates an instance of a DelegateFunctionData record class.
(package private)	FunctionData(IToken token, FunctionSymbol function, List<ISymbol> callArgumentTypes)	Creates an instance of a FunctionData record class.
(package private)	MethodOnAggregateData(IToken token, IScope scopeToSearch, String methodName, List<ISymbol> callArguments)	Creates an instance of a MethodOnAggregateData record class.
(package private)	ParametersData(IToken token, Supplier<String> errorMessage, List<ISymbol> from, List<ISymbol> to)	Creates an instance of a ParametersData record class.
(package private)	SanitizedCheckData(Supplier<String> errorMessage, List<ISymbol> superParameters, List<ISymbol> thisParameters)	Creates an instance of a SanitizedCheckData record class.

Uses of ISymbol in org.ek9lang.compiler.phase4

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

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

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

Modifier and Type	Class	Description
(package private) final class	CloseableLocalOrError	The NAMED half of the closeable ownership rule (Steve, 2026-10-05): "A closeable value you never NAME is owned by the statement that created it and closed when that statement finishes; a closeable value you NAME must be declared as a try-with-resources resource." (E81056).
(package private) final class	GetGuardVariable	Extracts the EXISTING variable a pre-flow assigns: the target of a blind assignment (v := e()) or an assign-if-unset (v :=? e()).
(package private) final class	HasTypeOfGeneric
(package private) class	InheritanceDepthCalculator	Calculates the Depth of Inheritance Tree (DIT) for aggregate symbols.
(package private) final class	SafeGenericAccessMarker	Marks specific types of variable of specific types (generic Result/Option) in a manner that enables the compiler to check if access to certain methods is safe.
(package private) final class	SafeGenericAccessPredicate	Tests specific types of variable of specific types (generic Result/Option) in a manner that enables the compiler to check if access to certain methods is safe.
(package private) final class	SafeSymbolMarker	It may be that before calling this you have determined that 'isSet' has been called or you 'know' that the value of the variable is present and set.

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

Modifier and Type	Method	Description
ISymbol	ConstrainedConstructionResolver.Site.argSymbol()	Returns the value of the argSymbol record component.
ISymbol	OrderingTotality.Finding.callee()	Returns the value of the callee record component.
ISymbol	ConstrainedConstructionResolver.Site.constructorParamType()	Returns the value of the constructorParamType record component.
ISymbol	CloseableArgumentKeeping.Holder.symbol()	Returns the value of the symbol record component.
ISymbol	SafeAccessConjuncts.Proof.symbol()	Returns the value of the symbol record component.
(package private) static ISymbol	MetricLimitCheck.symbolOf(SymbolsAndScopes symbolsAndScopes, org.antlr.v4.runtime.tree.ParseTree node)	The symbol the metric is recorded against; asserted present (the node, not the symbol, is never null).
ISymbol	StoreSite.target()	Returns the value of the target record component.
ISymbol	MutatedOnlyVariables.Deferred.variable()	Returns the value of the variable record component.

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

Modifier and Type	Method	Description
List<ISymbol>	GetGuardVariable.apply(EK9Parser.PreFlowStatementContext ctx)
(package private) List<ISymbol>	ScopeVariableCollector.collectLocalVariables(org.antlr.v4.runtime.tree.ParseTree node, Predicate<ISymbol> filter)	Collect the local variable symbols declared inside the callable's instruction blocks (including those nested in if/while/for/try/switch), admitting only those for which the filter holds.
List<ISymbol>	FieldClassifier.FieldCounts.dataFields()	Returns the value of the dataFields record component.
(package private) List<ISymbol>	ScopeVariableCollector.getAccessibleFields(IScope scope)	The property fields of the nearest enclosing aggregate, or an empty list if there is none.
protected List<ISymbol>	PossibleExpressionConstruct.getPreFlowAssignedVariables(EK9Parser.PreFlowAndControlContext ctx)
protected List<ISymbol>	PossibleExpressionConstruct.getPreFlowAssignedVariables(EK9Parser.PreFlowStatementContext ctx)	The EXISTING variables the pre-flow assigns, which are initialised after the construct whether or not its body runs - see GetGuardVariable.
(package private) List<ISymbol>	ScopeVariableCollector.namedCaptures(org.antlr.v4.runtime.tree.ParseTree node)	THE variables a NAMED capture '(name: value)' introduces on a dynamic function or class - read by every name-quality check (E11030, E11031, E11032; C-1: only E11031 once collected them, FE57).
(package private) Set<ISymbol>	InjectionCycles.notExplained(String ownerFqn, Set<ISymbol> injections)	The injections of ownerFqn the ordering checks still judge: those no cycle explains.
List<ISymbol>	FieldClassifier.FieldCounts.serviceFields()	Returns the value of the serviceFields record component.
(package private) Optional<ISymbol>	StoreSite.valueType(SymbolsAndScopes symbolsAndScopes)	The resolved type of the value stored - not the slot's declared type.

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

Modifier and Type	Method	Description
void	CloseableLocalOrError.accept(ISymbol symbol)
(package private) void	SafeAccessRepointOrError.accept(ISymbol target, org.antlr.v4.runtime.Token op)	Report E08040 at op if target is proven safe to unwrap in the current scope.
void	SafeGenericAccessMarker.accept(ISymbol symbol)
void	SafeSymbolMarker.accept(ISymbol symbol, IScope scope)
(package private) void	CloseableSlotStoreOrError.acceptCallableDeclaration(ISymbol recorded)	A callable declaration (a constructor, method, operator, function or dynamic function): what it does with each of its parameters is then known, so an unnamed closeable given to it is a loan unless it keeps the argument (the verdict of a constructor is CloseableArgumentKeeping.fateOf(MethodSymbol, int); of any other callable, its derived RETAINS).
(package private) void	CloseableArgumentKeeping.aliases(CloseableArgumentKeeping.Holder from, ISymbol to)	The local to now refers to the same object as from.
int	InheritanceDepthCalculator.applyAsInt(ISymbol symbol)	Calculate the inheritance depth for a symbol.
protected void	AbstractSafeSymbolMarker.assessIsSetCall(ISymbol toBeAssessed, IScope scopeMadeSafe)
(package private) void	OperatorKeepsValueUnsetOrError.constructedUnset(ISymbol symbol, ISymbol type)	symbol was given the value a CONSTRUCTS_UNSET constructor of type makes.
(package private) void	CallableParameterOccurrences.declared(ISymbol recorded)	A callable declaration was reached: its parameters are the variables whose occurrences are followed.
(package private) void	OperatorKeepsValueUnsetOrError.declaredWithoutValue(ISymbol symbol)	symbol was declared as T?, with no value.
(package private) static String	ConstructStatementBudget.displayNameFor(ISymbol symbol)	Human-readable label for the construct the given symbol represents, for use in diagnostics.
(package private) void	MutatedOnlyVariables.Collector.enterCallable(ISymbol symbol)	A method, operator, function or dynamic function is entered; only one with a returning variable is followed.
(package private) static void	MetricLimitCheck.errorIfExceeds(ErrorListener errorListener, ISymbol symbol, int value, int max, ErrorListener.SemanticClassification code, Supplier<String> message)	Raise code on the symbol's source token when the value is strictly above the maximum.
(package private) boolean	InjectionCycles.explains(String ownerFqn, ISymbol injected)	True when the injection of injected into ownerFqn is explained by a cycle, not by the order.
(package private) Optional<CloseableArgumentKeeping.Holder>	CallableParameterOccurrences.holderOf(ISymbol variable)	The callable whose own variable this is, when it is one that is followed (a parameter, or a local made to refer to one); empty otherwise.
Optional<PropertyTypeGraph.Node>	PropertyTypeGraph.holdsOf(ISymbol declaredType)	The node for what a property declared with this type can hold, or empty when it can hold nothing that has properties of its own (a function, a built-in leaf, an unresolved type).
(package private) boolean	SafeGenericContainers.isAccessSafe(ISymbol symbol)	Is the (OK for a Result) unwrapping access of this symbol safe in the scope it is used in.
protected boolean	SafeSymbolAccess.isAccessUnSafe(ISymbol calledFromSymbol, String methodName, org.antlr.v4.runtime.tree.ParseTree accessSite)	True when the access needs a check that neither the enclosing scope nor an earlier and conjunct of the expression at accessSite provides (SafeAccessConjuncts.isProvenEarlier(ParseTree, ISymbol, CommonValues)).
(package private) boolean	SafeGenericContainers.isContainer(ISymbol symbol)	Is the symbol a Result, Optional or Iterator.
(package private) static boolean	GuardVariableReadWhereUnsetOrError.isInLaterBlockOfItsGuard(org.antlr.v4.runtime.tree.ParseTree at, ISymbol target, SymbolsAndScopes symbolsAndScopes)	THE test of this rule's domain, for a rule that must not report the same use a second time (E08096): is at inside a later block of an if chain (an else if or the else) whose earlier block's <- guard declares target, provably unset there.
(package private) boolean	SafeAccessConjuncts.isProvenEarlier(org.antlr.v4.runtime.tree.ParseTree accessSite, ISymbol symbol, CommonValues access)	True when access on symbol at accessSite is protected by an EARLIER conjunct of an enclosing and evaluated as part of the same expression.
protected boolean	PossibleExpressionConstruct.isVariableInitialisedInScopes(CodeFlowAnalyzer analyzer, ISymbol variable, List<IScope> scopes)
(package private) boolean	OperatorKeepsValueUnsetOrError.keepsIncrementedUnset(EK9Parser.IdentifierContext ctx, ISymbol target)	An identifier written in place by x++ or x--: true when it is UNSET and the operator keeps it unset - reported, and it stays UNSET.
(package private) boolean	OperatorKeepsValueUnsetOrError.keepsTargetUnset(EK9Parser.AssignmentStatementContext ctx, ISymbol target)	An assignment statement x += y (any in-place operator but a store): true when its target is UNSET and the operator keeps it unset - the target then stays UNSET and the finding is made once the right-hand side has been walked (OperatorKeepsValueUnsetOrError.assignmentCompleted(EK9Parser.AssignmentStatementContext)).
(package private) void	SafeGenericContainers.markAccessSafe(ISymbol symbol, IScope scopeMadeSafe)	Mark the (OK for a Result) unwrapping access of this symbol safe in the scope; nothing for other symbols.
(package private) static int	ConstructStatementBudget.maxStatementsFor(ISymbol symbol)	Maximum number of statements permitted for the construct the given symbol represents.
(package private) boolean	SlotAssignedOnce.mayAlreadyHold(ISymbol slot, org.antlr.v4.runtime.tree.ParseTree assignment)	True when the slot may already hold a value at this assignment, judged from the assignments recorded so far; the assignment is then recorded, so call this once for every assignment to the slot, in source order.
(package private) void	OperatorKeepsValueUnsetOrError.narrowed(ISymbol symbol)	symbol was narrowed by a set-check (if not x?): known unset now because of the check.
(package private) static CloseableArgumentKeeping.Holder	CloseableArgumentKeeping.Holder.of(ScopedSymbol callable, ISymbol symbol)
(package private) Optional<SafeGenericContainers.Container>	SafeGenericContainers.of(ISymbol symbol)
(package private) void	OperatorKeepsValueUnsetOrError.otherwiseGiven(ISymbol symbol)	symbol was given some other value, by a store or a narrowing.
static PropertyTypeGraph	PropertyTypeGraph.over(ConcreteSubtypeFinder subtypeFinder, ISymbol anyType)	The graph over the program, its subtypes and aggregates from the phase's ONE shared subtype index.
protected void	PossibleExpressionConstruct.processPossibleGuardInitialisation(CodeFlowAnalyzer analyzer, ISymbol guardVariable, org.antlr.v4.runtime.ParserRuleContext ctx)	Now when there is a preflow control, it may mean that a variable is initialised.
(package private) void	InputVarietyDenominatorRecorder.record(ISymbol symbol)	The squirrel core — package-private so it is unit-testable with a hand-built callable, no parse tree or scope resolution required.
(package private) static void	MetricLimitCheck.record(ISymbol symbol, CommonValues squirrelKey, int value)	Squirrel an integer metric on the symbol as decimal text, through SmallIntStrings.
(package private) void	OrderingTotality.record(ISymbol callable, List<OrderingTotality.Finding> found)	Record the partial sources of one callable's Integer result; nothing is recorded for a total one.
(package private) void	SafeGenericContainers.recordDeclaration(ISymbol symbol)	Record the declaration of a variable of a container type, so that its unwrapping call needs a check.
(package private) void	CouplingTracker.recordDependency(ISymbol type)	Record a type dependency.
(package private) void	ModuleCouplingTracker.recordDependency(String sourceModuleName, ISymbol referencedType)	Record a type dependency for a specific module.
(package private) void	ModuleCohesionTracker.recordReference(String moduleName, String fromConstructFqn, ISymbol referencedType)	Record a type reference from one construct to another.
protected boolean	SafeSymbolAccess.requiresSafeAccess(ISymbol calledFromSymbol, String methodName)	Whether methodName on calledFromSymbol is a container-unwrap that needs a preceding safety check (Optional.get, Result.ok/error, Iterator.next on a symbol the marker has flagged) — i.e.
boolean	HasTypeOfGeneric.test(ISymbol symbol)
boolean	SafeGenericAccessPredicate.test(ISymbol symbol)
(package private) void	MutatedOnlyVariables.Collector.variableDeclared(EK9Parser.VariableDeclarationContext ctx, ISymbol symbol)

Method parameters in org.ek9lang.compiler.phase5 with type arguments of type ISymbol

Modifier and Type	Method	Description
(package private) void	UnsatisfiedInjectionReporter.checkInjectionsAvailable(String aggName, Set<ISymbol> injections, Set<String> availableTypes, Set<String> allRegisteredTypes, IToken triggerToken, ErrorListener errorListener)	Report the injections (of a type, or in a callable's body) that are not available at the trigger: never registered (E08210) or not yet registered (E08200).
(package private) List<ISymbol>	ScopeVariableCollector.collectLocalVariables(org.antlr.v4.runtime.tree.ParseTree node, Predicate<ISymbol> filter)	Collect the local variable symbols declared inside the callable's instruction blocks (including those nested in if/while/for/try/switch), admitting only those for which the filter holds.
(package private) Set<ISymbol>	InjectionCycles.notExplained(String ownerFqn, Set<ISymbol> injections)	The injections of ownerFqn the ordering checks still judge: those no cycle explains.
(package private) void	DataClumpTracker.recordSignature(String moduleName, String callableName, List<ISymbol> params, IToken token)	Record a callable's parameter signature for a specific module.

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

Modifier	Constructor	Description
(package private)	DefaultComparatorRecheckOrError(ISymbol ek9Any)
(package private)	Deferred(ParsedModule parsedModule, ISymbol variable, EK9Parser.ExpressionContext initialiser)	Creates an instance of a Deferred record class.
(package private)	DynamicClassComparatorRetraction(ParsedModule parsedModule, ISymbol ek9Any)
(package private)	Finding(IToken token, String reason, ISymbol callee)	Creates an instance of a Finding record class.
(package private)	HasTypeOfGeneric(ISymbol matchType)	Constructor to check if symbol has a type that matches the use of the match generic type.
(package private)	Holder(ScopedSymbol callable, ISymbol symbol)	Creates an instance of a Holder record class.
(package private)	Proof(ISymbol symbol, CommonValues access)	Creates an instance of a Proof record class.
	PropertyTypeGraph(PropertyTypeGraph.TypeUniverse universe, ISymbol anyType)
(package private)	Site(AggregateSymbol constrainedType, ConstraintExpr constraint, ISymbol argSymbol, ISymbol constructorParamType)	Creates an instance of a Site record class.
(package private)	StoreSite(ISymbol target, EK9Parser.AssignmentExpressionContext value, IToken location)	Creates an instance of a StoreSite record class.

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

Modifier	Constructor	Description
(package private)	CallableReturnsInitialisedOrError(SymbolsAndScopes symbolsAndScopes, ErrorListener errorListener, Function<C, EK9Parser.OperationDetailsContext> operationDetailsOf, Class<? extends ISymbol> expectedSymbolKind)
(package private)	FieldCounts(int serviceFieldCount, int dataFieldCount, int byDelegatedFieldCount, List<ISymbol> serviceFields, List<ISymbol> dataFields, Set<String> byDelegatedFields)	Creates an instance of a FieldCounts record class.

Uses of ISymbol in org.ek9lang.compiler.phase5.callgraph

Methods in org.ek9lang.compiler.phase5.callgraph that return ISymbol

Modifier and Type	Method	Description
ISymbol	CallableInfo.symbol()	Returns the value of the symbol record component.

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

Modifier and Type	Method	Description
Set<ISymbol>	CallGraph.getInjectionSites(String callable)	The injection sites declared directly in a callable's body (not transitively).

Methods in org.ek9lang.compiler.phase5.callgraph with parameters of type ISymbol

Modifier and Type	Method	Description
void	CallGraph.addInjectionSite(String callable, ISymbol injectedVariable)	Record an injection site (name as T!) in the body of a callable.
CallableInfo.Builder	CallableInfo.Builder.symbol(ISymbol symbol)

Constructors in org.ek9lang.compiler.phase5.callgraph with parameters of type ISymbol

Modifier	Constructor	Description
	CallableInfo(String fullyQualifiedName, ISymbol symbol, IToken sourceToken, String moduleName, boolean isPure, boolean isProgram, boolean isTestEntry, boolean isServiceEntry, boolean containsAssertion, boolean containsInjection)	Create CallableInfo with validation.

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

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

Modifier and Type	Method	Description
ISymbol	ConstructionEdges.CallTarget.callee()	Returns the value of the callee record component.
ISymbol	ConstructionEdges.TypeParameterConstruction.typeParameter()	Returns the value of the typeParameter record component.

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

Modifier and Type	Method	Description
Map<String,ISymbol>	ConstructionEdges.constructionNodes()	Every construction node, by call-graph identity.

Methods in org.ek9lang.compiler.phase5.construction with parameters of type ISymbol

Modifier and Type	Method	Description
void	ConstructionEdges.addConstructionNode(String key, ISymbol symbol)	Record a construction node - a constructor, or a type's _i_init - which every cycle reported must contain.
(package private) static boolean	Parameterisations.isConcrete(ISymbol type)	A type that names no conceptual type parameter anywhere in it.

Method parameters in org.ek9lang.compiler.phase5.construction with type arguments of type ISymbol

Modifier and Type	Method	Description
(package private) Optional<PossibleGenericSymbol>	Parameterisations.lookup(PossibleGenericSymbol generic, List<ISymbol> arguments)	The existing parameterisation of a generic with exactly these (concrete) arguments, if there is one.

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

Modifier	Constructor	Description
	CallTarget(ISymbol callee)	Creates an instance of a CallTarget record class.
	TypeParameterConstruction(ISymbol typeParameter, int arity)	Creates an instance of a TypeParameterConstruction record class.

Uses of ISymbol in org.ek9lang.compiler.phase5.flow

Methods in org.ek9lang.compiler.phase5.flow that return ISymbol

Modifier and Type	Method	Description
ISymbol	LockIdentityInference.resolveParamSymbol(String paramFqn)	Resolve the original parameter ISymbol for a placeholder FQN, if one has been registered via LockIdentityInference.tokenForSymbol(ISymbol).
ISymbol	LockIdentityInference.unwrapCapture(ISymbol symbol, IScopedSymbol enclosingFunction)	Like LockIdentityInference.tokenForSymbol(ISymbol) but unwraps one level of dynamic-function capture: if the symbol is one of enclosingFunction's captured variables, resolve the same-named variable in the CaptureScope's enclosing scope and use that outer symbol's identity instead.

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

Modifier and Type	Method	Description
Set<ISymbol>	ConstraintState.trackedSymbols()	Every symbol this state holds anything about (a value or the values it may hold), as a copy.

Methods in org.ek9lang.compiler.phase5.flow with parameters of type ISymbol

Modifier and Type	Method	Description
void	ConstraintState.clearMay(ISymbol symbol)	Record that nothing is provable about symbol here.
ConditionResult	ValueTrackingAnalyzer.evaluateIsEmpty(ISymbol symbol)	Evaluate the empty state of a variable based on its tracked value.
ConditionResult	ValueTrackingAnalyzer.evaluateIsSet(ISymbol symbol)	Evaluate the isSet state of a variable based on its tracked value.
AbstractValue	ConstraintState.get(ISymbol symbol)	Get the abstract value for a symbol.
Set<Object>	ConstraintState.getMay(ISymbol symbol)	The constant values that reach this point on SOME path; empty when nothing is provable.
Set<Object>	ValueTrackingAnalyzer.getMayValues(ISymbol symbol)	The constant values that reach this point on SOME path — the MAY side of the analysis.
AbstractValue	ValueTrackingAnalyzer.getValue(ISymbol symbol)
boolean	ConstraintState.isFreshInLoop(ISymbol symbol)	True if symbol was written, on every path here, since the innermost loop body was entered.
boolean	ValueTrackingAnalyzer.isFreshInLoop(ISymbol symbol)	True if symbol was written, on every path to here, since the innermost loop body was entered: inside the loop its value is then what that write gave it on every pass, so a decision about it holds (D48) even though the body is walked only once.
AbstractValue	TrackedValues.knownValueOf(ISymbol symbol)	The symbol's tracked value but only if that is known, else TOP - the symbol half of TrackedValues.knownValueOf(EK9Parser.ExpressionContext), for a name that is not an expression (a by step identifier).
void	ConstraintState.markFreshInLoop(ISymbol symbol)	Note that symbol was written since the innermost loop body was entered (see ConstraintState.freshInLoop).
void	ValueTrackingAnalyzer.narrowedWithGuardSkipPath(ISymbol guardTarget, Runnable narrowing)	Run narrowing - the false narrowing of an if block's condition, at the start of its next alternative - when the block's guard (v <- f(), v :=? f()) can leave guardTarget unset: then the condition after then was never evaluated, and the alternative is reached by that skip path as well as by the condition being false (D46).
void	ValueTrackingAnalyzer.narrowForCondition(ISymbol symbol, String operator, long operandValue, boolean isTrueBranch)	🔑 Narrowing must reduce the MAY side too, or it goes stale. These paths write the MUST side DIRECTLY rather than through ValueTrackingAnalyzer.recordAssignment(ISymbol, AbstractValue), so without this the may-set keeps a value the narrowing has just ruled out — and a value that provably does NOT arrive would be reported as if it did.
void	ValueTrackingAnalyzer.narrowForIsSet(ISymbol symbol, boolean isTrueBranch)	Narrow a variable's value based on an isSet check.
void	ValueTrackingAnalyzer.recordAssignment(ISymbol symbol, AbstractValue abstractValue)	Record a variable assignment with a known constant value.
void	ValueTrackingAnalyzer.recordEscape(ISymbol symbol)	Record that the object symbol refers to is now kept somewhere the analysis cannot name (D61): it may be changed through that holder at any later point, so it is changed now (ValueTrackingAnalyzer.recordInPlaceChange(ISymbol)) and nothing learned about it later - a condition narrowing it included - survives a call that may run the program's own code (ValueTrackingAnalyzer.recordCallThatMayChange(boolean, Collection)) or an in-place change to anything.
void	ValueTrackingAnalyzer.recordInPlaceChange(ISymbol symbol)	Record that the object symbol refers to was changed IN PLACE (x++, cat items > x, a call given it) - so nothing is known any more about it, nor about any name that may refer to the same object.
void	ValueTrackingAnalyzer.recordInPlaceChangeThroughOthers(ISymbol symbol)
void	ValueTrackingAnalyzer.recordKeptUnset(ISymbol symbol)	The variable symbol is UNSET and an operation that keeps an unset value unset (KEEPS_UNSET, e.g.
void	ValueTrackingAnalyzer.recordLiteralAssignment(ISymbol symbol, AbstractValue abstractValue)	As ValueTrackingAnalyzer.recordAssignment(ISymbol, AbstractValue), for a value that is exact on EVERY pass of an open loop - a literal, which no earlier pass can have changed (D48).
void	ValueTrackingAnalyzer.recordMayAliasOutside(ISymbol symbol)	Record that the object symbol refers to may be one that exists outside this callable (x <- view(), x <- this): a later call that reaches such an object may change it.
void	ValueTrackingAnalyzer.recordMayValues(ISymbol symbol, Set<Object> values)	Record that symbol's value is not known exactly, but is one of values.
void	ValueTrackingAnalyzer.recordSharing(ISymbol first, ISymbol second)	Record that first and second may refer to the same object from here on - alias <- base, or the copy a capture list makes.
void	ValueTrackingAnalyzer.recordUnknownAssignment(ISymbol symbol)
void	ValueTrackingAnalyzer.registerModuleConstant(ISymbol symbol, AbstractValue abstractValue)	Register a module-level constant (from defines constant blocks).
void	ValueTrackingAnalyzer.reportWhenSure(ISymbol symbol, Runnable report)	Run report - a finding that symbol is UNSET at this point on every pass - once it is SURE.
void	ConstraintState.set(ISymbol symbol, AbstractValue abstractValue)	Set the abstract value for a symbol (mutates this state).
void	ConstraintState.setMay(ISymbol symbol, Object value)	Record that symbol definitely holds value here, REPLACING anything it may have held before — a later write kills an earlier value on this path.
void	ConstraintState.setMayAll(ISymbol symbol, Set<Object> values)	Record the full set of values that may reach symbol here, REPLACING what came before.
Object	LockIdentityInference.tokenForSymbol(ISymbol symbol)	Return an identity token for a field, parameter, or capture receiver.
void	ConstraintState.unmarkFreshInLoop(ISymbol symbol)	symbol was written with something other than a literal: what it holds may be what an earlier pass left in another variable, so it is no longer fresh (see ConstraintState.freshInLoop).
ISymbol	LockIdentityInference.unwrapCapture(ISymbol symbol, IScopedSymbol enclosingFunction)	Like LockIdentityInference.tokenForSymbol(ISymbol) but unwraps one level of dynamic-function capture: if the symbol is one of enclosingFunction's captured variables, resolve the same-named variable in the CaptureScope's enclosing scope and use that outer symbol's identity instead.

Method parameters in org.ek9lang.compiler.phase5.flow with type arguments of type ISymbol

Modifier and Type	Method	Description
void	ValueTrackingAnalyzer.recordCallThatMayChange(boolean reachesOutside, Collection<ISymbol> reachedNames)	A call that may run the program's own code (not pure, not a concrete built-in) - it may change every object it can reach (D66, Steve 2026-10-21): the receiver, every argument, everything reachable from them and everything that may be the same object.

Uses of ISymbol in org.ek9lang.compiler.phase5.lockanalysis

Methods in org.ek9lang.compiler.phase5.lockanalysis that return ISymbol

Modifier and Type	Method	Description
ISymbol	CrossThreadEdge.caller()	Returns the value of the caller record component.
ISymbol	ChainStep.contextFunction()	Returns the value of the contextFunction record component.
ISymbol	EnterCallSite.enclosingFunction()	Returns the value of the enclosingFunction record component.
ISymbol	MutexKeyBody.enclosingFunction()	Returns the value of the enclosingFunction record component.
ISymbol	FunctionLockSummary.function()	Returns the value of the function record component.
ISymbol	CrossThreadEdge.handler()	Returns the value of the handler record component.
ISymbol	MutexKeyBody.keyFunction()	Returns the value of the keyFunction record component.
ISymbol	LockIdentityDescriptor.originSymbol()	Returns the value of the originSymbol record component.
ISymbol	ChainStep.stepTarget()	Returns the value of the stepTarget record component.

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

Modifier and Type	Method	Description
Set<ISymbol>	LockAnalysis.lookupPureGetterReturnFields(String methodFqn)	Look up the set of fields a pure-getter method may return.

Methods in org.ek9lang.compiler.phase5.lockanalysis with parameters of type ISymbol

Modifier and Type	Method	Description
static FunctionLockSummary	FunctionLockSummary.empty(ISymbol function)	Convenience factory producing an empty summary backed by mutable collections.
void	LockAnalysis.recordPureGetterReturnField(String methodFqn, ISymbol returnedField)	Record that a pure-getter method (by FQN) returns the given field symbol.

Constructors in org.ek9lang.compiler.phase5.lockanalysis with parameters of type ISymbol

Modifier	Constructor	Description
	ChainStep(StepKind kind, IToken stepLocation, ISymbol contextFunction, ISymbol stepTarget, String contextDescription)	Creates an instance of a ChainStep record class.
	CrossThreadEdge(ISymbol caller, ISymbol handler, IToken callLocation)	Creates an instance of a CrossThreadEdge record class.
	EnterCallSite(String stableId, ISymbol enclosingFunction, IToken callLocation, Set<String> lockIdentityIds, String receiverDisplayForm, EnterKind kind)	Creates an instance of a EnterCallSite record class.
	FunctionLockSummary(ISymbol function, List<EnterCallSite> directEnters, List<MutexKeyBody> directKeyBodies, Set<TransitiveEnterRecord> mayEnter)	Creates an instance of a FunctionLockSummary record class.
	LockIdentityDescriptor(String stableId, IdentityOrigin origin, ISymbol originSymbol, IToken originLocation, String displayName)	Creates an instance of a LockIdentityDescriptor record class.
	MutexKeyBody(String stableId, ISymbol keyFunction, IToken declarationLocation, ISymbol enclosingFunction, String outerLockIdentityId)	Creates an instance of a MutexKeyBody record class.

Uses of ISymbol in org.ek9lang.compiler.phase7

Fields in org.ek9lang.compiler.phase7 declared as ISymbol

Modifier and Type	Field	Description
(package private) ISymbol	Scenario2WrapperHelper.delegateType

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

Modifier and Type	Method	Description
(package private) boolean	Scenario2WrapperHelper.containedTypeHasOperator(ISymbol type, String operatorGlyph)	Whether the contained (element) type has a REAL binary operatorGlyph (==, <>) - its own, a super's or a trait's, never only the degenerate Any one.
protected void	AbstractDfnGenerator.createInitOperation(IRConstruct construct, IScope aggregateSymbol, ISymbol superType)	Create _c_init operation for class/static initialization.
(package private) String	Scenario2WrapperHelper.emitVirtualCall(List<IRInstr> instructions, String targetVar, String targetType, ISymbol targetTypeSymbol, String methodName, List<String> paramTypes, String returnType, List<String> argNames, DebugInfo debugInfo)	A virtual method call whose result (+1) the caller states the owner of itself - it casts it (Scenario2WrapperHelper.ownedCast(List, String, String, String, DebugInfo)) or moves it.
(package private) String	Scenario2WrapperHelper.generateConstructorCall(List<IRInstr> instructions, ISymbol type, String typeName, List<String> paramTypes, List<String> argNames, DebugInfo debugInfo)	A constructor call whose new value (+1) the caller states the owner of itself (it moves it).
(package private) String	Scenario2WrapperHelper.generateConstructorCallInstructions(List<IRInstr> instructions, ISymbol type, String typeName, List<String> paramTypes, List<String> argNames, String scopeId, DebugInfo debugInfo)	Generate a constructor call on a type: the new value (+1) is owned by the scope, dropped at its exit.
(package private) String	Scenario2WrapperHelper.generateProducerVirtualCall(List<IRInstr> instructions, String targetVar, String targetType, ISymbol targetTypeSymbol, String methodName, List<String> paramTypes, String returnType, List<String> argNames, String scopeId, DebugInfo debugInfo)	Generate a virtual method call whose result is a +1 PRODUCER — a value-method or operator that hands back a freshly-owned object (e.g.
(package private) boolean	Scenario2WrapperHelper.hasPublicNoArgConstructor(ISymbol type)	Whether type() can be called here to make an unset value of it: a concrete aggregate with a public no-argument constructor.
(package private) boolean	Scenario2WrapperHelper.isAny(ISymbol type)	Is this the built-in Any (by symbol identity, never by name)?
(package private) boolean	Scenario2WrapperHelper.isBareConceptualOnTemplate(ISymbol templateDeclaredType)	True when the generic template declared this position as a bare conceptual type parameter (T), as opposed to a parameterisation such as Iterator of T or Comparator of T.
(package private) boolean	Scenario2WrapperHelper.isDelegatingParameterisedType(ISymbol type)	THE shared check for "is this a parameterised BUILT-IN generic that carries a raw delegate" — one whose value must be UNWRAPPED via .delegate on store and RE-WRAPPED on return / at a callback edge.
(package private) boolean	Scenario2WrapperHelper.isFunctionParameterisation(ISymbol type)	THE shared check for "is this type a parameterisation of a generic FUNCTION" (e.g.
(package private) void	Scenario2WrapperHelper.returnVirtualCall(List<IRInstr> instructions, String targetVar, String targetType, ISymbol targetTypeSymbol, String methodName, List<String> paramTypes, String returnType, List<String> argNames, String scopeId, DebugInfo debugInfo)	A virtual method call whose result (+1) is moved straight into the return variable: the method hands its caller exactly the count the callee handed it.

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

Methods in org.ek9lang.compiler.phase7.calls that return ISymbol

Modifier and Type	Method	Description
static ISymbol	CallTargetResolution.definingType(ISymbol resolvedMethod, ISymbol staticType)	The type that DECLARES the resolved method (its enclosing scope) - i.e.
ISymbol	CallContext.returnType()	Returns the value of the returnType record component.
ISymbol	CallContext.targetType()	Returns the value of the targetType record component.

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

Modifier and Type	Method	Description
List<ISymbol>	CallContext.argumentTypes()	Returns the value of the argumentTypes record component.
Optional<List<ISymbol>>	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	THE declared parameter types of the operator/method that actually serves a call - read off the RESOLVED member, never copied from the arguments.
Optional<List<ISymbol>>	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol, String, List) inside a monomorphisation: the parameter types the member that SERVES the call declares (OperatorTargetMethodResolver.servingMember(ISymbol, String, List, UnaryOperator)), so a call a generic body makes on its bare T names the type argument's operator, never the template's T._cmp(T) (D53).

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

Modifier and Type	Method	Description
CallDetails	IsSetCallDetailsCreator.apply(String operandVariable, ISymbol operandSymbol, boolean isTraitCall)	Create CallDetails for _isSet() call on the specified operand.
Optional<ScopedSymbol>	OperatorTargetMethodResolver.apply(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	Resolve a method/operator on the target type, returning the resolved symbol itself (not just type names), so callers can read its defining type, return type and metadata rather than re-deriving them.
CallMetaDataDetails	SynthesisedCallMetaData.apply(ISymbol targetType, String methodName)	Metadata for a zero-argument call (operand._isSet(), resource._close()).
CallMetaDataDetails	SynthesisedCallMetaData.apply(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	Resolve methodName(argumentTypes) on targetType and read the metadata off the resolved callee.
Optional<List<ISymbol>>	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	THE declared parameter types of the operator/method that actually serves a call - read off the RESOLVED member, never copied from the arguments.
Optional<List<ISymbol>>	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol, String, List) inside a monomorphisation: the parameter types the member that SERVES the call declares (OperatorTargetMethodResolver.servingMember(ISymbol, String, List, UnaryOperator)), so a call a generic body makes on its bare T names the type argument's operator, never the template's T._cmp(T) (D53).
static ISymbol	CallTargetResolution.definingType(ISymbol resolvedMethod, ISymbol staticType)	The type that DECLARES the resolved method (its enclosing scope) - i.e.
static CallContext	CallContext.forBinaryOperation(ISymbol leftType, ISymbol rightType, ISymbol returnType, String methodName, String leftVariable, String rightVariable, String scopeId)	Create context for binary operation: left.method(right)
static CallContext	CallContext.forBinaryOperationWithContext(ISymbol leftType, ISymbol rightType, ISymbol returnType, String methodName, String leftVariable, String rightVariable, String scopeId, org.antlr.v4.runtime.ParserRuleContext parseContext)	Create context for binary operation with parseContext: left.method(right) Used when Phase 3 has already resolved the method (e.g., switch case comparisons)
CallMetaDataDetails	SynthesisedCallMetaData.forConstructor(ISymbol targetType, List<ISymbol> argumentTypes)	Metadata for a CONSTRUCTOR call on the given type - the default constructor when argumentTypes is empty, otherwise the matching overload (e.g.
static CallContext	CallContext.forFunctionCall(ISymbol targetType, List<ISymbol> argumentTypes, String methodName, String targetVariable, List<String> argumentVariables, String scopeId, EK9Parser.CallContext parseContext)	Create context for function call: function(args...)
static CallContext	CallContext.forPrimaryReferenceOperation(ISymbol leftType, ISymbol rightType, ISymbol returnType, String methodName, String leftVariable, String rightVariable, String scopeId, boolean isSuperReceiver)	Create context for a method-based operator applied to an explicit this or super primary reference - super :=: source, super :~: source, and friends.
CallMetaDataDetails	SynthesisedCallMetaData.forSynthesisedCallee(ISymbol target, String methodName, List<ISymbol> argumentTypes)	Metadata for a callee the COMPILER itself synthesised, where a symbol may legitimately not exist - returns null, meaning no metadata clause, when there is nothing measured to report.
CallMetaDataDetails	SynthesisedCallMetaData.forSynthesisedConstructor(ISymbol targetType, List<ISymbol> argumentTypes)	A compiler-synthesised CONSTRUCTOR - see SynthesisedCallMetaData.forSynthesisedCallee(ISymbol, String, List).
static CallContext	CallContext.forUnaryOperation(ISymbol targetType, String methodName, String targetVariable, ISymbol returnType, String scopeId)	Create context for unary operation: target.method()
static CallContext	CallContext.forUnaryOperation(ISymbol targetType, String methodName, String targetVariable, ISymbol returnType, String scopeId, boolean isSuperReceiver)	Context for a unary operator applied to an explicit super primary reference - $super, #?super, $$super.
static boolean	CallTargetResolution.isOpenAggregate(ISymbol type)	Whether an aggregate type is open for extension (can have subclasses).
static boolean	CallTargetResolution.isVirtualCall(ISymbol resolvedMethod, ISymbol targetType)	Whether the call needs virtual (vtable) dispatch: false for constructors, private methods (cannot be overridden), and targets not open for extension (effectively final).
static boolean	CallTargetResolution.isVirtualForSynthesisedCallee(ISymbol targetType)	The dispatch flag for a call the compiler SYNTHESISED, where the callee type may not have been threaded through.
static CloseCallTarget.Target	CloseCallTarget.ofType(ISymbol staticType, String staticTypeName)	The owner type name and dispatch flags for closing a value whose static TYPE is known.
Optional<ScopedSymbol>	OperatorTargetMethodResolver.servingMember(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.apply(ISymbol, String, List) followed by OperatorTargetMethodResolver.onTypeArgument(ScopedSymbol, UnaryOperator): the member that serves the call, read off the type argument when the call is resolved on a generic's bare T inside a monomorphisation.

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

Modifier and Type	Method	Description
Optional<ScopedSymbol>	OperatorTargetMethodResolver.apply(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	Resolve a method/operator on the target type, returning the resolved symbol itself (not just type names), so callers can read its defining type, return type and metadata rather than re-deriving them.
CallMetaDataDetails	SynthesisedCallMetaData.apply(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	Resolve methodName(argumentTypes) on targetType and read the metadata off the resolved callee.
Optional<List<ISymbol>>	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	THE declared parameter types of the operator/method that actually serves a call - read off the RESOLVED member, never copied from the arguments.
Optional<List<ISymbol>>	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol, String, List) inside a monomorphisation: the parameter types the member that SERVES the call declares (OperatorTargetMethodResolver.servingMember(ISymbol, String, List, UnaryOperator)), so a call a generic body makes on its bare T names the type argument's operator, never the template's T._cmp(T) (D53).
Optional<List<ISymbol>>	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.declaredParameterTypes(ISymbol, String, List) inside a monomorphisation: the parameter types the member that SERVES the call declares (OperatorTargetMethodResolver.servingMember(ISymbol, String, List, UnaryOperator)), so a call a generic body makes on its bare T names the type argument's operator, never the template's T._cmp(T) (D53).
CallMetaDataDetails	SynthesisedCallMetaData.forConstructor(ISymbol targetType, List<ISymbol> argumentTypes)	Metadata for a CONSTRUCTOR call on the given type - the default constructor when argumentTypes is empty, otherwise the matching overload (e.g.
static CallContext	CallContext.forFunctionCall(ISymbol targetType, List<ISymbol> argumentTypes, String methodName, String targetVariable, List<String> argumentVariables, String scopeId, EK9Parser.CallContext parseContext)	Create context for function call: function(args...)
CallMetaDataDetails	SynthesisedCallMetaData.forSynthesisedCallee(ISymbol target, String methodName, List<ISymbol> argumentTypes)	Metadata for a callee the COMPILER itself synthesised, where a symbol may legitimately not exist - returns null, meaning no metadata clause, when there is nothing measured to report.
CallMetaDataDetails	SynthesisedCallMetaData.forSynthesisedConstructor(ISymbol targetType, List<ISymbol> argumentTypes)	A compiler-synthesised CONSTRUCTOR - see SynthesisedCallMetaData.forSynthesisedCallee(ISymbol, String, List).
Optional<ScopedSymbol>	OperatorTargetMethodResolver.onTypeArgument(ScopedSymbol templateMember, UnaryOperator<ISymbol> typeArgumentOf)	THE member that serves, inside a monomorphisation, a call phase 3 resolved on a generic's bare T.
Optional<ScopedSymbol>	OperatorTargetMethodResolver.servingMember(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.apply(ISymbol, String, List) followed by OperatorTargetMethodResolver.onTypeArgument(ScopedSymbol, UnaryOperator): the member that serves the call, read off the type argument when the call is resolved on a generic's bare T inside a monomorphisation.
Optional<ScopedSymbol>	OperatorTargetMethodResolver.servingMember(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.apply(ISymbol, String, List) followed by OperatorTargetMethodResolver.onTypeArgument(ScopedSymbol, UnaryOperator): the member that serves the call, read off the type argument when the call is resolved on a generic's bare T inside a monomorphisation.

Constructors in org.ek9lang.compiler.phase7.calls with parameters of type ISymbol

Modifier	Constructor	Description
	CallContext(ISymbol targetType, String targetVariable, String methodName, List<ISymbol> argumentTypes, List<String> argumentVariables, String scopeId, ISymbol returnType, org.antlr.v4.runtime.ParserRuleContext parseContext)	Every call site that is not an explicit super receiver - which is all of them but one.
	CallContext(ISymbol targetType, String targetVariable, String methodName, List<ISymbol> argumentTypes, List<String> argumentVariables, String scopeId, ISymbol returnType, org.antlr.v4.runtime.ParserRuleContext parseContext, boolean explicitSuperReceiver)	Creates an instance of a CallContext record class.

Constructor parameters in org.ek9lang.compiler.phase7.calls with type arguments of type ISymbol

Modifier	Constructor	Description
	CallContext(ISymbol targetType, String targetVariable, String methodName, List<ISymbol> argumentTypes, List<String> argumentVariables, String scopeId, ISymbol returnType, org.antlr.v4.runtime.ParserRuleContext parseContext)	Every call site that is not an explicit super receiver - which is all of them but one.
	CallContext(ISymbol targetType, String targetVariable, String methodName, List<ISymbol> argumentTypes, List<String> argumentVariables, String scopeId, ISymbol returnType, org.antlr.v4.runtime.ParserRuleContext parseContext, boolean explicitSuperReceiver)	Creates an instance of a CallContext record class.

Uses of ISymbol in org.ek9lang.compiler.phase7.generation

Methods in org.ek9lang.compiler.phase7.generation that return ISymbol

Modifier and Type	Method	Description
ISymbol	IRGenerationContext.resolveType(ISymbol typeSymbol)	The SYMBOL form of IRGenerationContext.resolveTypeName(ISymbol) - the concrete type a (possibly conceptual) type resolves to under the current generic substitution.

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

Modifier and Type	Method	Description
Optional<ISymbol>	IRGenerationContext.monomorphisedDynamicConstruct(ISymbol template)	The copy already made of a dynamic construct for the monomorphisation in progress, if any.
Optional<ISymbol>	IRGenerationContext.resolveTypeByIrName(String fullyQualifiedName)	THE recovery of a type symbol from the IR type NAME a phase-7 site already emitted - only for where the name is all that survived (a CallInstr carries its return type as a name).

Methods in org.ek9lang.compiler.phase7.generation with parameters of type ISymbol

Modifier and Type	Method	Description
void	IRInstructionBuilder.callSuperMethod(ISymbol superType, String methodName)	Create a method call to super class constructor or method.
void	IRInstructionBuilder.callSuperStaticMethod(ISymbol superType, String methodName)	Create a static call to super class initialization method.
void	IRInstructionBuilder.callThisMethod(ISymbol targetType, String methodName, String targetVariable)	Create a method call on 'this' object.
void	IRInstructionBuilder.callThisMethod(ISymbol targetType, String methodName, String targetVariable, DebugInfo debugInfo)	Create a method call on 'this' object with specific debug info.
List<IRInstr>	CoverageProbePlacer.createInputClassProbe(ISymbol operationSymbol, DebugInfo debugInfo, String scopeId, IRGenerationContext stackContext)	Create an input-class probe for a public construct's entry (the dynamic numerator, §5).
void	IRInstructionBuilder.initializeEnumConstant(ISymbol enumType, String constantName, int ordinal)	Initialize an enum constant static field.
Optional<ISymbol>	IRGenerationContext.monomorphisedDynamicConstruct(ISymbol template)	The copy already made of a dynamic construct for the monomorphisation in progress, if any.
void	IRGenerationContext.recordMonomorphisedDynamicConstruct(ISymbol template, ISymbol monomorph)	Record the copy made of a dynamic construct for the monomorphisation in progress; from now on every reference to the construct (its own body, its constructor call, a nested construct) resolves to the copy.
ISymbol	IRGenerationContext.resolveType(ISymbol typeSymbol)	The SYMBOL form of IRGenerationContext.resolveTypeName(ISymbol) - the concrete type a (possibly conceptual) type resolves to under the current generic substitution.
String	IRGenerationContext.resolveTypeName(ISymbol typeSymbol)	THE "what concrete type name does this (possibly conceptual) type have inside the current Scenario-3 monomorphisation?" step - use this, and never re-derive a variant.

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

Classes in org.ek9lang.compiler.phase7.generator that implement interfaces with type arguments of type ISymbol

Modifier and Type	Class	Description
(package private) final class	AssignExpressionToSymbol

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

Modifier and Type	Method	Description
<T extends ICanCaptureVariables & ISymbol> List<IRInstr>	DynamicConstructEmitter.emit(T dynamicSymbol, Function<IRGenerationContext, IRConstruct> generate, EK9Parser.DynamicVariableCaptureContext captureCtx, DebugInfo debugInfo, String resultVariable, Function<List<ISymbol>, CallMetaDataDetails> metaData)	Emit the dynamic construct and the instructions that construct it.

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

Modifier and Type	Method	Description
ISymbol	RangeIterationHelper.InitializationData.byType()	Returns the value of the byType record component.
protected ISymbol	AbstractStreamStageGenerator.concrete(ISymbol type)	The CONCRETE form of a type read straight off a stream symbol (a StreamCallSymbol's produces or consumes type) - under the current Scenario-3 substitution, so inside a monomorphized generic body a template T or List of T becomes the parameterisation's own type.
ISymbol	RangeIterationHelper.InitializationData.constrainedBase()	Returns the value of the constrainedBase record component.
ISymbol	TerminalSetup.consumesType()	Returns the value of the consumesType record component.
(package private) ISymbol	RangeIterationHelper.InitializationData.counterType()	The type the counter, the end copy and the direction probe are held in: the base of a constrained range type, else the range type itself.
(package private) ISymbol	StreamPipelineMachinery.edgeConsumes(EK9Parser.StreamPartContext stage)	The phase-3-resolved IN-edge (consumes) type of a stream stage, or null if unresolved.
(package private) ISymbol	StreamPipelineMachinery.edgeProduces(EK9Parser.StreamPartContext stage)	The phase-3-resolved OUT-edge (produces) type of a stream stage, or null if the stage has no recorded StreamCallSymbol or no produced type set.
(package private) ISymbol	StreamPipelineMachinery.effectivePostSortElementType(SortSetup sortSetup, List<EK9Parser.StreamPartContext> allStages, ISymbol sourceType)	The element type the POST-sort pipeline (and terminal) observe.
ISymbol	StreamSource.elementType()	Returns the value of the elementType record component.
protected ISymbol	AbstractGenerator.extractReturnType(org.antlr.v4.runtime.tree.ParseTree ctx, ISymbol fallbackSymbol)	Extract return type from a CallSymbol's resolved method.
(package private) ISymbol	PipelineVarPlan.finalType()
protected ISymbol	AbstractGenerator.getRecordedSymbolOrException(org.antlr.v4.runtime.tree.ParseTree node)	Safely retrieve the recorded symbol for a parse tree node with automatic validation.
ISymbol	ReturningParamProcessor.getReturnSymbol(EK9Parser.ReturningParamContext ctx)	Extract the return variable symbol from a returningParam context.
(package private) ISymbol	PipelineVarPlan.inType(int stageIndex)
(package private) ISymbol	GuardedConditionEvaluator.preFlowTargetSymbol(EK9Parser.PreFlowStatementContext preFlowStmt)	THE recorded symbol of the variable a pre-flow declares or assigns (FLOW-1).
ISymbol	LoopGuardHelper.preFlowTargetSymbol(EK9Parser.PreFlowStatementContext preFlowStmt)	THE recorded symbol of the variable a pre-flow declares or assigns (FLOW-1), for the constructs that read it themselves (a switch's discriminant).
ISymbol	ConstructorCallProcessor.processChainStart(CallSymbol callSymbol, EK9Parser.CallContext callContext, String resultVariable, List<IRInstr> instructions)	THE constructor call that STARTS an object-access chain - String(move).upperCase(), Holder(3).amount(), SomeText("en").message().
ISymbol	RangeIterationHelper.InitializationData.rangeType()	Returns the value of the rangeType record component.
ISymbol	ResourceCloser.Closing.staticType()	Returns the value of the staticType record component.
ISymbol	ObjectAccessInstrGenerator.ChainStepResult.typeSymbol()	Returns the value of the typeSymbol record component.
ISymbol	SwitchStatementGenerator.EvalVariable.typeSymbol()	Returns the value of the typeSymbol record component.

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

Modifier and Type	Method	Description
List<ISymbol>	PipelineVarPlan.typeAt()	Returns the value of the typeAt record component.

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

Modifier and Type	Method	Description
List<IRInstr>	AssignExpressionToSymbol.apply(ISymbol lhsSymbol, EK9Parser.AssignmentExpressionContext ctx)
(package private) void	StreamEmissionEngine.applyAsyncBufferSortEmit(String asyncExecutorVar, ISymbol asyncProducesType, List<EK9Parser.StreamPartContext> preSortStages, EK9Parser.StreamPartContext sortStage, List<EK9Parser.StreamPartContext> postSortStages, TerminalSetup terminalSetup, DebugInfo debugInfo, List<IRInstr> instructions)	Async-specific entry to StreamEmissionEngine.bufferSortEmit(String, String, String, String, CallDetails, ISymbol, List, EK9Parser.StreamPartContext, List, TerminalSetup, DebugInfo, List): drains the async executor (hasNext/next) and closes it after emission.
(package private) void	StreamEmissionEngine.applyGroupingStage(StreamSource source, ISymbol consumedElementType, BucketTracker tracker, StageGroup preStageGroup, StageGroup postStageGroup, BoundaryConditionBuilder boundaryBuilder, TerminalSetup terminalSetup, List<IRInstr> instructions, DebugInfo debugInfo)	Shared drain+emit engine for the consecutive-grouping stream stages (GROUP, SPLIT).
(package private) SortSetup	StreamEmissionEngine.applySortToCollection(List<EK9Parser.StreamPartContext> stages, IteratorSetup iteratorSetup, ISymbol elementType, IAggregateSymbol collectionType, DebugInfo debugInfo, List<IRInstr> instructions)
(package private) void	StreamEmissionEngine.applyWindowedAsyncToCollection(List<EK9Parser.StreamPartContext> stages, int asyncIndex, List<EK9Parser.StreamPartContext> preAsyncStages, List<StageState> preAsyncStageStates, IteratorSetup iteratorSetup, ISymbol elementType, ISymbol asyncProducesType, String asyncExecutorVar, TerminalSetup terminalSetup, DebugInfo debugInfo, List<IRInstr> instructions, List<StageState> postAsyncStates)	Step C — the interleaved WINDOWED async driver for an unbounded source (the telemetry case cat udp | async | filter | head N | collect).
(package private) void	StreamEmissionEngine.bufferSortEmit(String sourceVar, String sourceTypeName, String hasNextMethod, String nextMethod, CallDetails closeCall, ISymbol bucketType, List<EK9Parser.StreamPartContext> preSortStages, EK9Parser.StreamPartContext sortStage, List<EK9Parser.StreamPartContext> postSortStages, TerminalSetup terminalSetup, DebugInfo debugInfo, List<IRInstr> instructions)
(package private) StageWrapResult	StreamEmissionEngine.buildAsyncSubmitAction(String submitItemVar, ISymbol elementType, String asyncExecutorVar, String inFlightVar, String oneVar, ISymbol integerType, List<EK9Parser.StreamPartContext> preAsyncStages, List<StageState> preAsyncStageStates, org.ek9lang.compiler.phase7.generator.StreamEmissionEngine.AsyncCap cap, DebugInfo debugInfo)	The per-item SUBMIT action shared by the windowed prime loop and the drain refill: executor.submit(item); inFlight++, wrapped in the pre-ASYNC stages (filter/map/etc.).
(package private) ConditionAndPostLoop	StreamPipelineMachinery.buildStreamLoop(IteratorSetup iteratorSetup, List<StageState> demandBounds, String itemVar, ISymbol itemType, boolean rawIterator, EK9Parser.StreamCatContext catCtx, StreamLoopSink sink, DebugInfo debugInfo)	The unified iterator-driven stream while-loop skeleton: condition scope (hasNext(), with the demand bounds - the segment's heads, or the async window - folded in ahead of it by StreamDemand) + body scope (bind iterator.next() then the StreamLoopSink body-tail) + the ConditionAndPostLoop the caller feeds to createWhileLoop.
(package private) List<IRInstr>	StreamEmissionEngine.buildWindowRefill(IteratorSetup iteratorSetup, boolean isRawIterator, String submitItemVar, ISymbol elementType, String asyncExecutorVar, String inFlightVar, String oneVar, ISymbol integerType, List<EK9Parser.StreamPartContext> preAsyncStages, List<StageState> preAsyncStageStates, String moreVar, org.ek9lang.compiler.phase7.generator.StreamEmissionEngine.AsyncCap cap, DebugInfo debugInfo)	The windowed drain's REFILL step: if (more AND source.hasNext()) { bind submitItem = next(); [pre-async stages]; submit(submitItem); inFlight++ }.
protected ISymbol	AbstractStreamStageGenerator.concrete(ISymbol type)	The CONCRETE form of a type read straight off a stream symbol (a StreamCallSymbol's produces or consumes type) - under the current Scenario-3 substitution, so inside a monomorphized generic body a template T or List of T becomes the parameterisation's own type.
(package private) void	StreamEmissionEngine.continueOverIterator(List<EK9Parser.StreamPartContext> stages, IteratorSetup sourceIter, ISymbol sourceElementType, TerminalSetup terminalSetup, DebugInfo debugInfo, List<IRInstr> instructions, boolean sourceUnbounded)	Recursive pipeline TAIL driver: emit a stream given as sourceIter through stages to the terminal, with NO composition limit.
(package private) IteratorSetup	StreamPipelineMachinery.drainSourceToIterator(String sourceVar, String sourceTypeName, String hasNextMethod, String nextMethod, CallDetails closeCall, ISymbol bucketType, boolean keepsUnset, DebugInfo debugInfo, List<IRInstr> instructions)	As above; keepsUnset appends with += so an UNSET element survives the buffer - a stage never drops one (StreamStages.keepsUnsetElements).
(package private) IteratorSetup	StreamPipelineMachinery.drainSourceToIterator(String sourceVar, String sourceTypeName, String hasNextMethod, String nextMethod, CallDetails closeCall, ISymbol bucketType, DebugInfo debugInfo, List<IRInstr> instructions)	MATERIALISE a buffering value source (a GROUP/SPLIT tracker's hasNextGroup/nextGroup, or an async executor's hasNext/next) into a fresh raw EK9_LIST buffer and return an IteratorSetup over it.
(package private) ISymbol	StreamPipelineMachinery.effectivePostSortElementType(SortSetup sortSetup, List<EK9Parser.StreamPartContext> allStages, ISymbol sourceType)	The element type the POST-sort pipeline (and terminal) observe.
StageWrapResult	StreamLoopSink.emitBody(String boundItemVar, ISymbol boundItemType)
protected String	AbstractStreamStageGenerator.emitStageFunctionOperand(List<IRInstr> target, EK9Parser.PipelinePartContext pipelinePartCtx, ISymbol operandSymbol, FunctionSymbol functionType, DebugInfo debugInfo)	THE shared emission of a stream stage's function operand - use this, do not re-derive it.
GuardedConditionEvaluator.ConditionEvaluation	GuardedConditionEvaluator.evaluateGuardOnlyForVariable(ISymbol guardSymbol, String variableName, VariableDetails conditionResult, String scopeId, DebugInfo debugInfo)	Evaluates guard only for a pre-resolved variable (used by WHILE/DO-WHILE for entry check).
protected ISymbol	AbstractGenerator.extractReturnType(org.antlr.v4.runtime.tree.ParseTree ctx, ISymbol fallbackSymbol)	Extract return type from a CallSymbol's resolved method.
static FunctionMetrics	ConstructMetrics.forSymbol(ISymbol symbol)	Resolve every phase-5 metric for one operation.
static String	CoverageDisplayName.forSymbol(ISymbol operationSymbol)	Resolve the display name for a function/method symbol.
List<IRInstr>	ControlFlowChainGenerator.generateAssignIfUnset(ISymbol lhsSymbol, List<IRInstr> assignmentEvaluation, String assignmentResult, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for assign-if-unset (:=?).
List<IRInstr>	ControlFlowChainGenerator.generateAssignIfUnsetTestForTemp(String variableName, ISymbol variableSymbol, boolean isTraitCall, String resultVariable, DebugInfo debugInfo)	The question operator on a temp that holds the current value of a :=? target: a null there is the never-written slot :=? exists to write, so it is NOT a strict-absent observation (StrictAbsent).
(package private) ConditionAndPostLoop	StreamEmissionEngine.generateConditionAndBody(EK9Parser.StreamStatementContext ctx, EK9Parser.StreamCatContext catCtx, List<EK9Parser.StreamPartContext> stages, IteratorSetup iteratorSetup, String pipelineItemVar, ISymbol elementType, TerminalSetup terminalSetup, DebugInfo debugInfo, List<StageState> stageStates, boolean rawIterator, String pipelineScopeId, List<IRInstr> preLoopInstructions)	Generate condition (hasNext) and body (next + stages + terminal pipe).
protected List<IRInstr>	AbstractStreamStageGenerator.generateCounterDelta(String counterVar, String oneVar, String op, ISymbol integerType, DebugInfo debugInfo)	Reassign counterVar = counterVar <op> oneVar ("_add" to increment, "_sub" to decrement) via the RELEASE/STORE/RETAIN reassignment pattern.
(package private) List<IRInstr>	StreamPipelineMachinery.generateDynamicStageLimit(EK9Parser.StreamPartContext stageCtx, String limitVar, ISymbol integerType, String scopeId, DebugInfo debugInfo)	Generate IR to evaluate a dynamic stage operand (function reference or call) and store the Integer result in the given limit variable.
(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.
List<IRInstr>	ControlFlowChainGenerator.generateQuestionOperatorForTemp(String variableName, ISymbol variableSymbol, boolean isTraitCall, String resultVariable, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for Question operator applied to a temp variable.
List<IRInstr>	ControlFlowChainGenerator.generateQuestionOperatorForVariable(ISymbol variableSymbol, String resultVariable, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for Question operator applied to a variable.
protected List<IRInstr>	AbstractStreamStageGenerator.generateTerminalPipe(TerminalSetup terminalSetup, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo)	THE shared "pipe a value into a sink" step: sink._pipe(value) - used by the pipeline terminal and by tee's side terminal.
static String	CoverageDisplayName.identityForSymbol(ISymbol operationSymbol)	THE join key for a construct — the display name minus its one cosmetic exception.
boolean	StatementOwnedCloseables.involvesCloseables(List<IRInstr> evaluation, ISymbol resultType)	True when StatementOwnedCloseables.ownedEvaluation(ParserRuleContext, List, String, ISymbol) could do anything to this evaluation: its value is closeable, or it makes a closeable temporary phase 5 marked as owned, or it holds one deferred to it.
StatementOwnedCloseables.OwnedEvaluation	StatementOwnedCloseables.ownedEvaluation(org.antlr.v4.runtime.ParserRuleContext ctx, List<IRInstr> evaluation, String resultVariable, ISymbol resultType)	An evaluation nested inside another instruction (a condition, a control, an operand) that hands ONE value on: the evaluation wrapped, like a statement, in THE owned region that closes the closeable temporaries it made - and the variable that now holds its value after the region.
(package private) PipelineVarPlan	StreamPipelineMachinery.planPipelineVars(List<EK9Parser.StreamPartContext> stages, String sourceVar, ISymbol sourceType, String scopeId, DebugInfo debugInfo, List<IRInstr> declarationsOut)	Compute the per-boundary item-variable plan for an in-loop stage list, allocating a fresh variable (declared at the produced type) only where a stage changes the element type.
(package private) static PipelineVarPlan	PipelineVarPlan.single(String var, ISymbol type, int stageCount)
static String	CoverageDisplayName.sourceQualifiedName(ISymbol operationSymbol)	THE fully-qualified name to use as a coverage/profiling IDENTITY for a callable — stable across every parameterisation of a generic.
(package private) StageWrapResult	StreamEmissionEngine.terminalBodyTail(List<EK9Parser.StreamPartContext> stages, String itemVar, ISymbol itemType, TerminalSetup terminalSetup, String scopeId, List<IRInstr> preLoopInstructions, List<StageState> stageStates, DebugInfo debugInfo)	The shared stream body-tail, used identically by the cat path (the StreamPipelineMachinery.buildStreamLoop(IteratorSetup, List, String, ISymbol, boolean, EK9Parser.StreamCatContext, StreamLoopSink, DebugInfo) sink) and the for-range streaming body: plan the per-boundary item vars (declared pre-loop in preLoopInstructions so a post-loop consumer like JOIN's emit references a dominating var), pipe the final-typed item to the terminal, and wrap the result in the intermediate stages.
static ResourceCloser.Closing	ResourceCloser.Closing.viaSuper(ISymbol superType, String superTypeName, DebugInfo debugInfo)	The super class's close, called NON-virtually on this object (super._close()): the last step of a generated close chain.
List<IRInstr>	FilterRejectStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType)
List<IRInstr>	StreamElementStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType)	Wrap innerBody in this stage's gate or side effect.
(package private) List<IRInstr>	TeeStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType, StageState teeState)	Wrap innerBody: pipe the item (or its mapped value) to the side target, then run the inner body.
(package private) List<IRInstr>	UniqStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType, StageState stageState)
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates)	Wrap an innermost body with intermediate pipeline stages in reverse order.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates, String asyncExecutorVar)	Wrap inner body instructions with intermediate pipeline stages in reverse order.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates, String asyncExecutorVar, PipelineVarPlan plan)	Core stage-wrapping with an explicit per-boundary PipelineVarPlan.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, Supplier<List<IRInstr>> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates, String asyncExecutorVar, PipelineVarPlan plan, String doneFlagVar)	Core stage-wrapping, additionally threading a doneFlagVar into a HEAD stage's else-branch.

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

Modifier and Type	Method	Description
protected CallDetails	AbstractStreamStageGenerator.streamFunctionCall(FunctionSymbol fn, String funcInstanceVar, List<ISymbol> flowingTypes, List<String> argVars, String returnTypeName, DebugInfo debugInfo, List<IRInstr> setupInstructions)	THE shared builder for a stream stage-function _call invocation - used by every stage that invokes a resolved function on the flowing element(s): filter/reject and split predicates, map and tee mappers, uniq and group key-functions, and the join fold.

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

Modifier	Constructor	Description
(package private)	ChainStepResult(String tempName, ISymbol typeSymbol, boolean isVoid, boolean isExplicitTraitTypeRef)	Creates an instance of a ChainStepResult record class.
	Closing(String variable, ISymbol staticType, String staticTypeName, DebugInfo debugInfo)	A value already held in a variable.
	Closing(List<IRInstr> load, String variable, ISymbol staticType, String staticTypeName, DebugInfo debugInfo)	A value brought into a variable by load (a property's LOAD_FIELD).
	Closing(List<IRInstr> load, String variable, ISymbol staticType, String staticTypeName, DebugInfo debugInfo, boolean viaSuper)	Creates an instance of a Closing record class.
	EvalVariable(String name, String type, ISymbol typeSymbol)	Creates an instance of a EvalVariable record class.
(package private)	InitializationData(List<IRInstr> instructions, String endTemp, String byTemp, String directionTemp, String currentTemp, ISymbol rangeType, ISymbol byType, ISymbol constrainedBase, String startTemp, boolean progressChecked)	Creates an instance of a InitializationData record class.
(package private)	StreamSource(IteratorSetup iteratorSetup, ISymbol elementType, boolean sourceUnbounded)	Creates an instance of a StreamSource record class.
(package private)	TerminalSetup(String variable, IAggregateSymbol type, MethodSymbol resolvedPipeMethod, ISymbol consumesType)	Creates an instance of a TerminalSetup record class.

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

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

Modifier and Type	Class	Description
class	FieldCreator	Creates the appropriate Field object for the symbol and adds it to the construct.
final class	VariableNameForIR	Get the name of the variable suitable for use in the IR.

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

Modifier and Type	Method	Description
ISymbol	ComparisonParams.booleanType()	Returns the value of the booleanType record component.
ISymbol	DirectionCheckParams.booleanType()	Returns the value of the booleanType record component.
ISymbol	IncrementParams.counterType()	Returns the value of the counterType record component.
ISymbol	PromotionCallGenerator.getPromotedType(ISymbol sourceType)	Get the type that results from promoting the given type using #^.
ISymbol	DirectionCheckParams.integerType()	Returns the value of the integerType record component.
ISymbol	BinaryOperatorParams.leftType()	Returns the value of the leftType record component.
ISymbol	ComparisonParams.leftType()	Returns the value of the leftType record component.
ISymbol	AssignIfUnsetDetails.lhsSymbol()	Returns the value of the lhsSymbol record component.
ISymbol	LiteralProcessingDetails.literalSymbol()	Returns the value of the literalSymbol record component.
ISymbol	LiteralParams.literalType()	Returns the value of the literalType record component.
ISymbol	UnaryOperatorParams.operandType()	Returns the value of the operandType record component.
ISymbol	BinaryOperatorParams.resultType()	Returns the value of the resultType record component.
ISymbol	UnaryOperatorParams.resultType()	Returns the value of the resultType record component.
ISymbol	BinaryOperatorParams.rightType()	Returns the value of the rightType record component.
ISymbol	ComparisonParams.rightType()	Returns the value of the rightType record component.
ISymbol	PromotionParams.sourceType()	Returns the value of the sourceType record component.

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

Modifier and Type	Method	Description
List<ISymbol>	ArgumentDetails.argumentSymbols()	Returns the value of the argumentSymbols record component.
List<ISymbol>	CaptureConstructorParameters.typeSymbols()	Returns the value of the typeSymbols record component.

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

Modifier and Type	Method	Description
void	FieldCreator.accept(ISymbol symbol)
List<IRInstr>	ConstantCopyOnAccessLoader.apply(ISymbol constantSymbol, String resultVariable, DebugInfo debugInfo)	Read the constant into resultVariable as a fresh copy.
List<IRInstr>	IsSetEvaluationCreator.apply(String operandVariable, ISymbol operandSymbol, boolean isTraitCall, VariableDetails resultDetails)	Creates _isSet() method call instructions.
String	VariableNameForIR.apply(ISymbol symbol)
ConstantCopyOnAccessLoader.LoadedConstant	ConstantCopyOnAccessLoader.applyToNewTemp(ISymbol constantSymbol, DebugInfo debugInfo)	Read the constant into a freshly generated temp, returning both the instructions and that temp.
static Optional<IAggregateSymbol>	EnumTypeHelper.baseEnumOf(ISymbol type)	Convenience for callers holding an ISymbol: the base enum when it is a constrained enum type.
static CallDetails	CallDetailsFactory.call(String targetObject, ISymbol targetType, String methodName, List<String> parameterTypes, String returnTypeName, List<String> arguments, CallMetaDataDetails metaData)	The same call, but taking the target type as a SYMBOL so BOTH the emitted type name and the virtual-dispatch flag derive from it - they then cannot disagree.
ISymbol	PromotionCallGenerator.getPromotedType(ISymbol sourceType)	Get the type that results from promoting the given type using #^.
boolean	ConstantCopyOnAccessLoader.isCopyOnAccessConstant(ISymbol symbol)	Does this symbol need the copy-on-access constant read?
static boolean	FunctionInstance.isDelegateCall(ISymbol recordedCallSymbol)	True when the recorded call symbol is a delegate call: the function instance is loaded from a variable (or is the result of an inner call) instead of being the named function's singleton.
String	CollectionElementPromoter.promoteIfRequired(ISymbol elementType, ISymbol targetType, String elementTemp, DebugInfo debugInfo, List<IRInstr> setupInstructions)	Insert a #^ promotion for a collection element when its static type is not directly assignable to the collection's resolved element type but is coercible to it (single promotion, per EK9 rules).
String	CollectionElementPromoter.promoteIfRequired(ISymbol elementType, ISymbol targetType, String elementTemp, DebugInfo debugInfo, List<IRInstr> setupInstructions, boolean escaping)	As CollectionElementPromoter.promoteIfRequired(ISymbol, ISymbol, String, DebugInfo, List), but escaping selects the ARC of any inserted promote: false for a scope-local value (collection element, range bound, comparison operand) — RETAIN + SCOPE_REGISTER; true for a value that ESCAPES the current scope (a coalescing/ternary body-result that becomes the expression value) — RETAIN only, the consumer takes ownership.
static CollectionElementPromoter.PromotionNeed	CollectionElementPromoter.promotionNeed(ISymbol from, ISymbol to)	THE "promote if required" decision, for every site that widens a value into a slot (parameters, assignments, collection elements, range bounds, operands): never re-derive the getUnCoercedAssignableCostTo / TypeCoercions.isCoercible pair.
static boolean	TraitCall.requiredFor(ISymbol targetType)
static boolean	TraitCall.requiredForValue(ISymbol targetValue)	As TraitCall.requiredFor(ISymbol) but for a value symbol (field/variable/expression) whose declared type is the call target.
static boolean	TraitCall.requiredForValue(ISymbol targetValue, UnaryOperator<ISymbol> typeArgumentOf)	As TraitCall.requiredForValue(ISymbol) inside a monomorphisation: the value's declared type is substituted first, so a value typed by a bare T is judged by the type argument (D54).

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

Modifier and Type	Method	Description
(package private) static Optional<OperationDetailsLocator.Located>	OperationDetailsLocator.find(ParsedModule parsedModule, EK9Parser.AggregatePartsContext ctx, Predicate<ISymbol> matches)	Find the declaration whose recorded symbol satisfies matches.
static List<IRInstr>	CaptureStores.of(List<ISymbol> capturedVars, DebugInfo debugInfo)
static List<IRInstr>	SanitizedParameterPrologue.of(IRGenerationContext stackContext, List<ISymbol> parameters)	Create the prologue that cleans every SANITIZED_REQUIRED parameter in place, each instruction attributed to the parameter's own declaration.
static List<IRInstr>	SanitizedParameterPrologue.of(IRGenerationContext stackContext, List<ISymbol> parameters, DebugInfo debugInfo)	Create the prologue with every instruction attributed to debugInfo.
static boolean	TraitCall.requiredForValue(ISymbol targetValue, UnaryOperator<ISymbol> typeArgumentOf)	As TraitCall.requiredForValue(ISymbol) inside a monomorphisation: the value's declared type is substituted first, so a value typed by a bare T is judged by the type argument (D54).

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

Modifier	Constructor	Description
	AssignIfUnsetDetails(ISymbol lhsSymbol, EK9Parser.AssignmentExpressionContext assignmentExpression, org.antlr.v4.runtime.Token operatorToken)	Creates an instance of a AssignIfUnsetDetails record class.
	BinaryOperatorParams(String leftOperand, String rightOperand, String operator, ISymbol leftType, ISymbol rightType, ISymbol resultType, String resultTemp, String scopeId, DebugInfo debugInfo)	Creates an instance of a BinaryOperatorParams record class.
	ComparisonParams(String leftOperand, String rightOperand, String operator, ISymbol leftType, ISymbol rightType, ISymbol booleanType, String booleanObjectTemp, String primitiveBooleanTemp, String scopeId, DebugInfo debugInfo)	Creates an instance of a ComparisonParams record class.
	DirectionCheckParams(String directionTemp, String comparisonOperator, String zeroTemp, String booleanObjectTemp, String primitiveBooleanTemp, ISymbol integerType, ISymbol booleanType, String scopeId, DebugInfo debugInfo)	Creates an instance of a DirectionCheckParams record class.
	IncrementParams(String counterVar, String operator, ISymbol counterType, String scopeId, DebugInfo debugInfo)	Creates an instance of a IncrementParams record class.
	LiteralParams(String tempName, String literalValue, ISymbol literalType, DebugInfo debugInfo)	Creates an instance of a LiteralParams record class.
	LiteralProcessingDetails(ISymbol literalSymbol, String literalResult)	Creates an instance of a LiteralProcessingDetails record class.
	PromotionParams(ISymbol sourceType, String sourceVariable, DebugInfo debugInfo)	Non-escaping (scope-local) promotion — the common case (list/dict element, range bound, comparison operand).
	PromotionParams(ISymbol sourceType, String sourceVariable, DebugInfo debugInfo, boolean escaping)	Creates an instance of a PromotionParams record class.
	UnaryOperatorParams(String operand, String operator, ISymbol operandType, ISymbol resultType, String resultTemp, String scopeId, DebugInfo debugInfo)	Creates an instance of a UnaryOperatorParams record class.

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

Methods in org.ek9lang.compiler.phase7.synthesis that return ISymbol

Modifier and Type	Method	Description
protected ISymbol	AbstractSyntheticGenerator.getAnyType()	The Any type SYMBOL - the root of every EK9 type, a Java interface at the backend.
protected ISymbol	AbstractSyntheticGenerator.getBitsType()	The Bits type SYMBOL - see AbstractSyntheticGenerator.getBooleanType().
protected ISymbol	AbstractSyntheticGenerator.getBooleanType()	The Boolean type SYMBOL - for reading call metadata off it, rather than only naming it.
protected ISymbol	AbstractSyntheticGenerator.getIntegerType()	The Integer type SYMBOL - see AbstractSyntheticGenerator.getBooleanType().
protected ISymbol	AbstractSyntheticGenerator.getStringType()	The String type SYMBOL - see AbstractSyntheticGenerator.getBooleanType().
protected ISymbol	AbstractSyntheticGenerator.getType(ISymbol symbol)	The same type, as a SYMBOL rather than a name - so a call ON this value can derive its dispatch flag instead of inheriting the builder's shape-only default.
ISymbol	EnumPrimitiveOperatorGenerator.Call.receiverType()	Returns the value of the receiverType record component.

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

Modifier and Type	Method	Description
protected List<ISymbol>	AbstractSyntheticGenerator.getSyntheticFields(AggregateSymbol aggregateSymbol)	Get all fields from an aggregate that should be included in synthetic operations.

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

Modifier and Type	Method	Description
protected DebugInfo	AbstractSyntheticGenerator.createDebugInfo(ISymbol symbol)	Create debug info from a symbol's source token.
static Optional<MethodSymbol>	FieldSetStatusSymbolGenerator.createFor(AggregateSymbol aggregateSymbol, ISymbol bitsType)	Create the detached _fieldSetStatus carrier for this aggregate, if it should have one.
protected SynthesisScope	AbstractSyntheticGenerator.createSynthesisScope(ISymbol symbol, String scopeLabel)	Create an SynthesisScope for the given operator symbol.
protected boolean	AbstractSyntheticGenerator.fieldTypeHasRealOperator(ISymbol field, String glyph, boolean binary)	Does the field's TYPE have a REAL operatorGlyph of its own (declared or inherited from a real super), as opposed to only the degenerate Any default that every type inherits?
protected List<IRInstr>	AbstractSyntheticGenerator.generateBinaryOperatorGuards(String aggregateTypeName, ISymbol aggregateType, String paramName, String unsetLabel, SynthesisScope ctx)	Generate isSet guards for binary operators (this and param).
protected List<IRInstr>	AbstractSyntheticGenerator.generateIsSetGuard(String variableName, String typeName, ISymbol type, String unsetLabel, SynthesisScope ctx)	Generate isSet guard check for a variable using SynthesisScope.
protected List<IRInstr>	AbstractSyntheticGenerator.generateIsSetGuard(String variableName, String typeName, ISymbol type, DebugInfo debugInfo, String unsetLabel, String scopeId)	Generate isSet guard check for a variable with branch to unset return.
protected List<IRInstr>	AbstractSyntheticGenerator.generateThisIsSetGuard(String aggregateTypeName, ISymbol aggregateType, String unsetLabel, SynthesisScope ctx)	Generate isSet guard for 'this' using SynthesisScope.
protected List<IRInstr>	AbstractSyntheticGenerator.generateThisIsSetGuard(String aggregateTypeName, ISymbol aggregateType, DebugInfo debugInfo, String unsetLabel, String scopeId)	Generate isSet guard check for 'this' with branch to unset return.
protected ISymbol	AbstractSyntheticGenerator.getType(ISymbol symbol)	The same type, as a SYMBOL rather than a name - so a call ON this value can derive its dispatch flag instead of inheriting the builder's shape-only default.
protected String	AbstractSyntheticGenerator.getTypeName(ISymbol symbol)	Get the fully qualified name for a type.
protected boolean	AbstractSyntheticGenerator.isTraitType(ISymbol symbol)	Check if the given symbol's type is a trait.

Constructors in org.ek9lang.compiler.phase7.synthesis with parameters of type ISymbol

Modifier	Constructor	Description
(package private)	Call(String method, boolean takesOther, ISymbol receiverType)	Creates an instance of a Call record class.

Uses of ISymbol in org.ek9lang.compiler.phase7.synthesis.support

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

Modifier and Type	Method	Description
List<IRInstr>	ReturnBlockHelper.generateUnsetReturn(String labelName, String returnTypeName, ISymbol returnType, String returnVarName, DebugInfo debugInfo, String scopeId)	Generate a return block that returns an unset value of the given type.
List<IRInstr>	ReturnBlockHelper.generateUnsetStore(String labelName, String returnTypeName, ISymbol returnType, String returnVarName, DebugInfo debugInfo, String scopeId, String continueLabel)	Generate a block that sets the return variable to an unset value of the given type and then goes on to continueLabel instead of returning (see ReturnBlockHelper.generateBooleanStore(String, boolean, String, DebugInfo, String, String)).
SyntheticMethodCallBuilder	SyntheticMethodCallBuilder.on(String target, ISymbol targetTypeSymbol)	The same target, but named by its resolved SYMBOL so the dispatch flag can be derived from it.

Uses of ISymbol in org.ek9lang.compiler.repair

Methods in org.ek9lang.compiler.repair that return ISymbol

Modifier and Type	Method	Description
(package private) static ISymbol	StringConcatRewriter.resolveSymbolForTest(ParsedModule parsedModule, EK9Parser.ExpressionContext expr)	Visible for tests.

Uses of ISymbol in org.ek9lang.compiler.search

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

Modifier and Type	Method	Description
ISymbol	MatchResult.getSymbol()

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

Modifier and Type	Method	Description
Optional<ISymbol>	SymbolSearch.getAsSymbol()	Creates a new Symbol from the name in the search and the module name.
Optional<ISymbol>	SymbolSearch.getOfTypeOrReturn()
List<ISymbol>	SymbolSearch.getTypeParameters()	Get the parameters being used in this search.

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

Modifier and Type	Method	Description
MethodSymbolSearch	MethodSymbolSearch.addTypeParameter(ISymbol parameter)
SymbolSearch	SymbolSearch.addTypeParameter(ISymbol parameter)	Add a parameter to the search parameters.
SymbolSearch	SymbolSearch.setExampleSymbolToMatch(ISymbol exampleSymbolToMatch)
MethodSymbolSearch	MethodSymbolSearch.setOfTypeOrReturn(ISymbol ofTypeOrReturn)
SymbolSearch	SymbolSearch.setOfTypeOrReturn(ISymbol ofTypeOrReturn)

Method parameters in org.ek9lang.compiler.search with type arguments of type ISymbol

Modifier and Type	Method	Description
MethodSymbolSearch	MethodSymbolSearch.addTypeParameter(Optional<ISymbol> parameter)
SymbolSearch	SymbolSearch.addTypeParameter(Optional<ISymbol> parameter)	Add a type parameter to the search.
MethodSymbolSearch	MethodSymbolSearch.setOfTypeOrReturn(Optional<ISymbol> ofTypeOrReturn)
SymbolSearch	SymbolSearch.setOfTypeOrReturn(Optional<ISymbol> ofTypeOrReturn)	What type of symbol is being searched for or its return type.
MethodSymbolSearch	MethodSymbolSearch.setTypeParameters(List<ISymbol> typeParameters)
SymbolSearch	SymbolSearch.setTypeParameters(List<ISymbol> typeParameters)	Set any parameters that might be needed as part of this search.

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

Modifier	Constructor	Description
	MatchResult(int costOfMatch, ISymbol symbol)	Create a new match result of a cost to match for a symbol.
	MethodSymbolSearch(String name, ISymbol ofTypeOrReturn)
protected	SymbolSearch(String name, ISymbol ofTypeOrReturn)
	SymbolSearch(ISymbol exampleSymbolToMatch)	Use a symbol to populate the search.

Constructor parameters in org.ek9lang.compiler.search with type arguments of type ISymbol

Modifier	Constructor	Description
	MethodSymbolSearch(String name, Optional<ISymbol> ofTypeOrReturn)
protected	SymbolSearch(String name, Optional<ISymbol> ofTypeOrReturn)

Uses of ISymbol in org.ek9lang.compiler.support

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

Modifier and Type	Class	Description
class	AccessGenericInGeneric	Uses the symbol and scope management to traverse back up stack to determine if the outer parent is a generic type or not and also if this symbol passed in is a generic type.
final class	BareTypeParameter	THE test for a generic's bare type parameter T itself, as opposed to a generic that HAS type parameters.
class	CommonTypeOrError	THE common-type deduction - for collections (List/Dict literals, ranges, stream 'cat') and for the operators that SELECT one of their operands (?:, <? >?, the ternary).
class	CommonTypeSuperOrTraitOrError	Given a list of symbols (normally variables), this code will get the type from each of those symbols.
class	CommonTypeSuperOrTraitOrError	Given a list of symbols (normally variables), this code will get the type from each of those symbols.
class	ConceptualLookupMapping	You may think why this mapping.
class	ConceptualLookupMapping	You may think why this mapping.
class	ConceptualLookupMapping	You may think why this mapping.
class	ConceptualLookupMapping	You may think why this mapping.
class	GeneralTypeResolver	Used to see if it is possible to resolve types, both simple and parametric.
class	InternalNameFor	Given some sort of generic type a function or a type with a set of 'type parameters', create a unique internal name for that combination.
final class	IsFunctionDelegateSymbol	Predicate to determine if a symbol is a function delegate.
final class	IsMutexKeyType	Predicate that returns true iff the symbol IS the org.ek9.lang::MutexKey generic function itself, or a parameterised form of it (e.g.
final class	IsMutexLockType	Predicate that returns true iff the symbol IS the org.ek9.lang::MutexLock generic type itself, or a parameterised form of it (e.g.
class	LocationExtractorFromSymbol	THE location of a symbol for a message: "on line 6 in 'filename.ek9'".
final class	NoBuiltInNameOrError	THE check that a construct being defined in a user module does not take the name of a built-in construct (E01090).
class	NoCaseVariantNameOrError	Checks that a name being defined at module scope does not differ ONLY by case from a name already defined in that same module (across every construct kind - class, record, trait, function, component, service, text, program, application and constant).
class	NoCaseVariantNameOrError	Checks that a name being defined at module scope does not differ ONLY by case from a name already defined in that same module (across every construct kind - class, record, trait, function, component, service, text, program, application and constant).
class	NoNameCollisionOrError	Designed to check if variable name and method names collide with Type/Function names.
class	NotImplicitSuper	THE single predicate for "does this super type need an EK9-style super-init call emitted by the IR?".
final class	ParameterisedLocator	Create a new parameterised symbol from a generic type and a set of type arguments.
class	ParameterizedSymbolCreator	This will just create an Aggregate/Function 'parameterized type' of the 'generic type' with the 'type arguments' But note it will have not - repeat NOT have - traversed the 'generic type' and cloned over the methods and altered all the 'T', 'K', 'V' - 'type parameters' for each of the 'type arguments' There is a separate function (TypeSubstitution) that does that.
class	PositionalConceptualLookupMapping	You may think why this mapping.
class	PositionalConceptualLookupMapping	You may think why this mapping.
class	ProgramArgumentPredicate	Check if this type being supplied to the test can be used as a program argument.
class	RefersToSameSymbol	Rather than just check if the actual ISymbols are the same, this code checks if two symbols actually refer to the same source token from the same source file.
class	RefersToSameSymbol	Rather than just check if the actual ISymbols are the same, this code checks if two symbols actually refer to the same source token from the same source file.
class	ResolveOrDefineExplicitParameterizedType	The bulk of the processing is in the abstract base.
class	ResolveOrDefineIdentifierReference	The bulk of the processing is in the abstract base.
class	ResolveOrDefineTypeDef	The bulk of the processing is in the abstract base.
class	ReturnTypeExtractor	get the appropriate return type from functions, methods and function delegates and constructors.
class	ReturnTypeExtractor	get the appropriate return type from functions, methods and function delegates and constructors.
(package private) class	SameGenericConceptualParameters	Checks to see if the type parameters are the same as the generic arguments.
(package private) class	SameGenericConceptualParameters	Checks to see if the type parameters are the same as the generic arguments.
class	SymbolTypeExtractor	Given a list of arguments (ISymbols), go through and extract the types out.
class	ToCommaSeparated	Converts a list of symbol using their friendly names in to a comma separated list.
class	TypeCanReceivePipedData	Given a Symbol that is some form of type, check that it could receive some piped data.
class	TypeListComparator	Checks that the symbols in list one and list two are each the same for the corresponding position in the list.o
class	TypeListComparator	Checks that the symbols in list one and list two are each the same for the corresponding position in the list.o

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

Modifier and Type	Method	Description
ISymbol	ConceptualTypeReplacement.apply(PositionalConceptualLookupMapping.Mapping typeMapping, ISymbol forType, IToken triggeredByToken)	The concrete counterpart of a type, which may be conceptual, parameterised with conceptual arguments, or already concrete (in which case it is returned unchanged).
ISymbol	ParameterisedTypeData.genericTypeSymbol()	Returns the value of the genericTypeSymbol record component.
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).
ISymbol	Sameness.UnorderedProperty.property()	Returns the value of the property record component.
ISymbol	SelfReferenceStore.CaptureAssignment.property()	Returns the value of the property record component.
ISymbol	ConceptualTypeReplacement.rebuild(PositionalConceptualLookupMapping.Mapping typeMapping, PossibleGenericSymbol forType, IToken triggeredByToken)	Rebuild a parameterised type against concrete type arguments, unconditionally.
ISymbol	ObjectSharing.Use.sharedWith()	Returns the value of the sharedWith record component.
ISymbol	RecordedSymbols.Reference.symbol()	Returns the value of the symbol record component.
ISymbol	ReferenceAssignment.target()	Returns the value of the target record component.
ISymbol	ConceptualAccess.OrderingUse.type()	Returns the value of the type record component.
ISymbol	ConstructTypeReferences.TypeReference.type()	Returns the value of the type record component.

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

Modifier and Type	Method	Description
static Set<ISymbol>	RecordedSymbols.aliasesOf(ParsedModule parsedModule, org.antlr.v4.runtime.tree.ParseTree within, ISymbol symbol)	symbol and every captured copy of it made by a dynamic function or class inside within (transitively: a capture of a capture), as an identity set.
static List<ISymbol>	DispatcherReachableTypes.all(ISymbol baseType, List<MethodSymbol> handlers, int paramIndex, ConcreteSubtypeFinder finder)	As DispatcherReachableTypes.concrete(ISymbol, List, int, ConcreteSubtypeFinder), but keeping abstract types.
Optional<ISymbol>	CommonTypeOrError.apply(CommonTypeDeterminationDetails details)
Optional<ISymbol>	CommonTypeSuperOrTraitOrError.apply(IToken lineToken, List<ISymbol> argumentSymbols)
Map<ISymbol,ISymbol>	ConceptualLookupMapping.apply(List<ISymbol> typeArguments, List<ISymbol> typeParameters)
Map<ISymbol,ISymbol>	ConceptualLookupMapping.apply(List<ISymbol> typeArguments, List<ISymbol> typeParameters)
Optional<ISymbol>	GeneralTypeResolver.apply(SymbolSearchConfiguration toResolve)
Optional<ISymbol>	ParameterisedLocator.apply(ParameterisedTypeData details)
Optional<ISymbol>	ResolveOrDefineExplicitParameterizedType.apply(EK9Parser.ParameterisedTypeContext ctx)
Optional<ISymbol>	ResolveOrDefineIdentifierReference.apply(EK9Parser.IdentifierReferenceContext ctx)
Optional<ISymbol>	ResolveOrDefineTypeDef.apply(EK9Parser.TypeDefContext ctx)
Optional<ISymbol>	ReturnTypeExtractor.apply(ISymbol symbol)
List<ISymbol>	SymbolTypeExtractor.apply(List<ISymbol> argumentSymbols)
List<ISymbol>	CommonTypeDeterminationDetails.argumentSymbols()	Returns the value of the argumentSymbols record component.
List<ISymbol>	CommonTypeDeterminationDetails.argumentTypes()	Returns the value of the argumentTypes record component.
static Optional<ISymbol>	RecordedSymbols.capturedCopy(Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded, EK9Parser.ExpressionParamContext param)	The copy a dynamic function or class makes from one argument of its capture list - (acc) and (total: acc) both make a copy, named acc and total - which shares the object the argument refers to.
static Optional<ISymbol>	SelfReferenceStore.capturedInto(EK9Parser.AssignmentStatementContext ctx, SymbolsAndScopes symbolsAndScopes)	The property of this object that the assignment statement gives a dynamic function or class capturing 'this' itself (child :=? (owner: this) with trait of Child as class ...), if it does.
List<ISymbol>	CloseSteps.Steps.closed()	Returns the value of the closed record component.
static List<ISymbol>	CloseSteps.closedProperties(IAggregateSymbol aggregate)	The fields the type's close closes, in acquisition order: owned captures, then own closeable properties.
static 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.
static List<ISymbol>	GenericTypeInfo.concreteTypeArguments(ISymbol symbol)	Recursively resolve a type reference to the leaf CONCRETE type symbols it actually couples to, skipping conceptual Ts.
static Optional<ISymbol>	NaturalOrderQueue.elementTypeNeedingOrder(EK9Parser.CallContext ctx, CallSymbol callSymbol, Ek9Types ek9Types)	The element type of the queue this written call constructs, when the construction needs a natural order: the call resolved to a constructor of a parameterisation of PriorityQueue, and it is not directly the receiver of .withComparator(...).
static Optional<ISymbol>	NaturalOrderQueue.elementTypeOfQueue(ISymbol queueType, Ek9Types ek9Types)	The element type when queueType is a parameterisation of PriorityQueue.
static Optional<ISymbol>	GenericTypeInfo.genericTemplate(ISymbol symbol)	The generic template a parameterised type was produced from (List, Dict, a user Cache), or empty when the symbol is not a parameterised type.
protected Consumer<ISymbol>	CommonFactory.getDefaultOperatorInitializer(IToken startToken)
static List<ISymbol>	GenericTypeInfo.leafTypes(ISymbol symbol)	THE types a reference to this type couples to, in order: the generic template it was produced from (empty for a plain type: a built-in container, or a user generic's own module) and then every leaf concrete type argument (GenericTypeInfo.concreteTypeArguments(ISymbol)).
static List<ISymbol>	GenericTypeInfo.leaves(ISymbol symbol, Predicate<ISymbol> isLeaf)	THE leaf walk of a type's arguments: descend through every parameterisation (List of (Dict of (K, V))) and collect the leaves isLeaf accepts, in order.
List<ISymbol>	ObjectSharing.Reach.named()	Returns the value of the named record component.
static List<ISymbol>	OverriddenDeclarations.narrowedReturnTypes(FunctionSymbol function)	The same for a function: the super function's return type, when this function narrows it.
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.
static Optional<ISymbol>	AssignmentTarget.of(SymbolsAndScopes symbolsAndScopes, EK9Parser.AssignmentExpressionContext assignmentExpression)	The declared type the assignment expression is given to, if it has one.
static List<ISymbol>	GeneratedOperatorFields.of(AggregateSymbol aggregateSymbol)	The aggregate's own properties followed by its captured variables, in declaration order.
static List<ISymbol>	CloseSteps.ownedCaptures(IAggregateSymbol aggregate)	The captures a dynamic class owns: each one PRE_IR_CHECKS marked as a fresh closeable (R-E).
static List<ISymbol>	ReturnRetention.parametersOf(ScopedSymbol callee)	The declared parameters of a method, operator or function; none for anything else.
static Optional<ISymbol>	TypeCoercions.promotionOperator(ISymbol from)	The #^ operator itself that this 'from' type promotes through, or empty if it has none - for a caller that must read the operator, not only its type (what its RETAINS say it does with the object it is called on: the closeable ownership decision, where an argument reaching a callee as its promotion is not the argument itself).
static Optional<ISymbol>	TypeCoercions.promotionTarget(ISymbol from)	The single type this 'from' type promotes to via its #^ operator, or empty if it has none.
static Set<ISymbol>	SelfReferenceStore.propertiesStoredIn(EK9Parser.MethodDeclarationContext constructor, SymbolsAndScopes symbolsAndScopes)	The properties a constructor body stores 'this' into - directly (me: this) or in a dynamic function or class it gives them (child :=? (owner: this) ...) - not counting code that runs later (a dynamic function's body, a dynamic class's methods), where 'this' is a different object or the construction is over.
static Optional<ISymbol>	AggregateManipulator.resolveAny(IScope scope)	THE search for the built-in Any through a scope: the fully qualified name, of category ANY - a category only AnyTypeSymbol has, so nothing a user declares can answer it.
Optional<ISymbol>	AggregateManipulator.resolveBits(IScope scope)	Resolve Bits from cached ek9 types or full scope hierarchy resolution.
Optional<ISymbol>	AggregateManipulator.resolveBoolean(IScope scope)	Resolve Boolean from cached ek9 types of full scope hierarchy resolution.
Optional<ISymbol>	AggregateManipulator.resolveInteger(IScope scope)	Resolve Integer from cached ek9 types of full scope hierarchy resolution.
Optional<ISymbol>	AggregateManipulator.resolveJson(IScope scope)	Resolve JSON from cached ek9 types of full scope hierarchy resolution.
Optional<ISymbol>	ResolverOrDefiner.resolveOrDefine(ParameterisedTypeData details)	Attempts to resolve the parameterised type first and return that, else returns a new symbol.
protected Optional<ISymbol>	ResolveOrDefineTypes.resolveSimpleTypeByIdentifierReference(EK9Parser.IdentifierReferenceContext ctx)
Optional<ISymbol>	AggregateManipulator.resolveString(IScope scope)	Resolve String from cached ek9 types of full scope hierarchy resolution.
protected Optional<ISymbol>	ResolveOrDefineTypes.resolveTypeByIdentifierReference(EK9Parser.IdentifierReferenceContext ctx)
protected Optional<ISymbol>	ResolveOrDefineTypes.resolveTypeByParameterizedType(IToken triggerToken, EK9Parser.ParameterisedTypeContext ctx)
protected Optional<ISymbol>	ResolveOrDefineTypes.resolveTypeByTypeDef(IToken triggerToken, EK9Parser.TypeDefContext ctx)	Resolves the type for a type def, can trigger recursion.
Optional<ISymbol>	AggregateManipulator.resolveVoid(IScope scope)	Resolve Void from cached ek9 types of full scope hierarchy resolution.
static Optional<ISymbol>	PolymorphicCopy.singleParameterType(MethodSymbol copy)	The single parameter type of a :=:, if it has exactly one.
static Optional<ISymbol>	SelfReferenceStore.storedProperty(EK9Parser.AssignmentStatementContext ctx, SymbolsAndScopes symbolsAndScopes)	The property of this object that the assignment statement re-points at 'this', if it does.
static Optional<ISymbol>	BooleanTruthGuard.targetOf(EK9Parser.PreFlowStatementContext preFlow, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recordedSymbol, ISymbol ek9Boolean)	The target of a Boolean truth guard, if this pre-flow is one.
List<ISymbol>	ParameterisedTypeData.typeArguments()	Returns the value of the typeArguments record component.
List<ISymbol>	PositionalConceptualLookupMapping.Mapping.typeArguments()	Returns the value of the typeArguments record component.
List<ISymbol>	PositionalConceptualLookupMapping.Mapping.typeParameters()	Returns the value of the typeParameters record component.
static List<ISymbol>	GenericTypeInfo.typeParametersOrArguments(ISymbol symbol)	The single level of type parameters (for a template) or type arguments (for a parameterisation) exactly as declared — for display/inspection.
static Optional<ISymbol>	Sameness.unorderedDictEntryKey(ISymbol type, ISymbol ek9Any)	The key type that stops a DictEntry of (K, V) being ordered (Steve, 2026-10-21): a DictEntry orders by its KEY's <=>, then by its VALUE's when the keys are the same (the entries of one Dict have unique keys), so a key type that cannot be ordered (Sameness.isOrderable(IAggregateSymbol, ISymbol); a function never can) leaves the entry unordered, and a comparator-less sort, <?, range or natural-order queue over it is E07620 - not the run-time "Sort cannot order" Exception it was.

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

Modifier and Type	Method	Description
static Optional<HttpAccess>	HttpAccess.accessOf(ISymbol param)	The access kind stored on this parameter, or empty if none has been stored yet.
MethodSymbol	AggregateManipulator.addConstructor(AggregateSymbol t, ISymbol s)	Add a constructor to the type aggregate with a particular parameter.
static Set<ISymbol>	RecordedSymbols.aliasesOf(ParsedModule parsedModule, org.antlr.v4.runtime.tree.ParseTree within, ISymbol symbol)	symbol and every captured copy of it made by a dynamic function or class inside within (transitively: a capture of a capture), as an identity set.
static List<ISymbol>	DispatcherReachableTypes.all(ISymbol baseType, List<MethodSymbol> handlers, int paramIndex, ConcreteSubtypeFinder finder)	As DispatcherReachableTypes.concrete(ISymbol, List, int, ConcreteSubtypeFinder), but keeping abstract types.
static List<MethodSymbol>	InheritedOperators.allAbove(IAggregateSymbol aggregate, String operatorName, ISymbol ek9Any)	EVERY operator called operatorName declared ABOVE the aggregate - each level's own overloads, nearest level first, never Any's.
static boolean	Sameness.allPropertiesOrderable(IAggregateSymbol aggregate, ISymbol ek9Any)	THE "can every property of this type be ordered?" (Sameness.isOrderable(IAggregateSymbol, ISymbol) for each property's type) - what a bare default operator's <=> needs of its own fields.
Optional<GenericInGenericData>	AccessGenericInGeneric.apply(ISymbol typeDef)
ISymbol	ConceptualTypeReplacement.apply(PositionalConceptualLookupMapping.Mapping typeMapping, ISymbol forType, IToken triggeredByToken)	The concrete counterpart of a type, which may be conceptual, parameterised with conceptual arguments, or already concrete (in which case it is returned unchanged).
String	LocationExtractorFromSymbol.apply(ISymbol symbol)
Optional<ISymbol>	ReturnTypeExtractor.apply(ISymbol symbol)
static boolean	Sameness.bareOrderingRetracted(IAggregateSymbol owner, ISymbol ek9Any)	THE retraction decision for a type's BARE ordering family (<=> < <= > >= added by the bare default operator): its own bare <=> decides for the whole family through Sameness.orderingSurvives(MethodSymbol, ISymbol); without one (the ordering family alone, beside a hand-written <=>) the type's own properties decide.
static Optional<MethodSymbol>	ProgramBody.bodyOf(ISymbol symbol)	The body method of a program - empty when the symbol is not a program.
static Optional<ScopedSymbol>	ReturnRetention.calleeOf(ISymbol recorded)	The method or function a recorded symbol CALLS, when it is a call that hands back a value made elsewhere: a method, operator or function call - never a constructor, whose result is always fresh.
static boolean	ObjectSharing.compoundTargetMayKeep(ISymbol type, ISymbol operandType)	May a compound assignment (target += item, target :~: item) to a value of this type keep its operand? A container (a parameterised type, a bare T) does; so does a type of the program's own, whose operator is written in EK9 and may store it - as any call of the program's own may keep its argument (ObjectSharing.keepsArgument(ISymbol, int); the verifier, 2026-10-21: registry += item, Registry's += adding to its list, was read as keeping nothing, so a loaned closeable was closed by its statement and then used).
static 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.
static List<ISymbol>	GenericTypeInfo.concreteTypeArguments(ISymbol symbol)	Recursively resolve a type reference to the leaf CONCRETE type symbols it actually couples to, skipping conceptual Ts.
protected void	CommonFactory.configureSymbol(ISymbol symbol, IToken start)
protected List<AggregateSymbol>	CommonFactory.createAndRegisterParameterisedSymbols(EK9Parser.ParameterisedParamsContext ctx, ISymbol functionOrClass, IScope scope)
static Optional<IAggregateSymbol>	InheritedOperators.declarationSiteFor(IAggregateSymbol aggregate, ISymbol ek9Any)	Where a missing operator belongs when NOTHING above the aggregate declares it (Q4, Steve 2026-10-08): the nearest super class that HAS fields of its own - the root of the data decides whether its fields are exposed (R4) - or, when no super class has fields, the topmost one (the hierarchy's root below Any).
void	VoidAsTypeOrError.declaredTypeOrError(ISymbol variable)	A variable, property, parameter or returning variable declared with type Void.
boolean	PropertyInitialiser.declares(ISymbol candidate)	True if this property is declared in the same aggregate body as the initialiser.
static void	HttpAccess.defaultOnto(ISymbol param)	THE defaulting of a service parameter that declares no access: it is a PATH parameter bound to the placeholder of its own name.
static Optional<String>	ConstructDisplayName.distinctOf(ISymbol symbol)	ConstructDisplayName.of(ISymbol) with a dynamic construct among the type arguments left as its mangled name, so two parameterisations over two different dynamic classes never share it (both are Box of cls in ConstructDisplayName.of(ISymbol)).
static Optional<ISymbol>	NaturalOrderQueue.elementTypeOfQueue(ISymbol queueType, Ek9Types ek9Types)	The element type when queueType is a parameterisation of PriorityQueue.
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).
boolean	SymbolChecker.errorsIfNameDiffersOnlyByCase(List<ISymbol> alreadyDefined, ISymbol symbol)	Check whether the symbol being defined differs ONLY by case from one already defined in the same module.
boolean	SymbolChecker.errorsIfNameIsBuiltIn(IScope moduleScope, ISymbol symbol)	Check the symbol about to be defined in a user module does not take the name of a built-in construct (E01090).
boolean	NoNameCollisionOrError.errorsIfResolved(IScope inScope, ISymbol symbol, SymbolSearch search, ErrorListener.SemanticClassification classificationError)	If a symbol is resolved then this will emit an error.
boolean	SymbolChecker.errorsIfSymbolAlreadyDefined(IScope inScope, ISymbol symbol, boolean limitVarSearchToBlockScope)	Check for exising symbol in the scope.
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 Optional<PossibleGenericSymbol>	TargetTypedConstruction.forCall(SymbolsAndScopes symbolsAndScopes, EK9Parser.CallContext call, ISymbol generic)	The parameterisation a bare G() at this call is completed to from its declared target, if it has one.
static Optional<DispatcherWinner.Selection>	DispatcherWinner.forParam(ISymbol concreteType, int paramIndex, List<MethodSymbol> handlers)	The winning handler for a concrete type at one parameter position.
static 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.
static String	CallableIdentity.forSymbol(ISymbol symbol)	The call-graph identity for a callable symbol.
static Optional<ISymbol>	GenericTypeInfo.genericTemplate(ISymbol symbol)	The generic template a parameterised type was produced from (List, Dict, a user Cache), or empty when the symbol is not a parameterised type.
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 int	FieldSlots.indexOf(ISymbol owner, String fieldName)	The slot of fieldName in an object of owner: the nearest declaration of that property in the chain, at its declaring type's inherited slot count plus its position there.
static Optional<MethodSymbol>	Sameness.inheritedSameness(IAggregateSymbol aggregate, ISymbol ek9Any)	The 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, sealed or not.
static List<MethodSymbol>	PolymorphicCopy.inheritedSignatures(IAggregateSymbol owner, ISymbol ek9Any)	The inherited :=:(Super) signatures a GENERATED owner overrides: every :=: declared up its super CLASS chain (InheritedOperators.allAbove(IAggregateSymbol, String, ISymbol)) 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.
static boolean	ConceptualAccess.isBuiltOnTypeParameters(ISymbol type)	True when the type is built on conceptual type parameters without being one: a parameterisation with a bare T among its leaves (DictEntry of (K, Integer), List of (OrderedBox of T)), or a generic template named in its own body (this < other inside OrderedBox of type T, which is OrderedBox of T).
static boolean	CapturedVariables.isCaptureOf(ISymbol candidate, ICanCaptureVariables capturer)	True when candidate is, by identity, one of the variables capturer captured.
static boolean	CloseSteps.isCloseableType(ISymbol type)	True when values of this TYPE have a close the compiler must see run (CloseableResourceToBeChecked.isManagedCloseableType(ISymbol)) - THE question for a type that is not a field, for example the component an application registers (the application closes it at program end).
static boolean	TypeCoercions.isCoercible(ISymbol from, ISymbol to)	Can the 'from' token type be coerced to the 'to' type.
static boolean	InputVarietyReceiver.isCounted(ISymbol method)	True when the method's input-variety floor counts its receiver.
boolean	PropertyInitialiser.isDeclaredBefore(ISymbol candidate)	True if this property is declared before the property whose initialiser this is - so its own initialiser, if it has one, has already run.
static boolean	Sameness.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).
static boolean	GenericBodyReference.isDependentOf(PossibleGenericSymbol generic, ISymbol symbol)	True when the symbol is a dependent reference of the generic - see the class description.
static boolean	ExternSymbols.isExternallyProvided(ISymbol symbol)	Is this symbol externally provided, so its source token must NOT be shown as a location?
static boolean	Ek9LiteralTypes.isExtractableLiteral(ISymbol symbol)	Whether symbol is a literal value that may be lifted into a module constant — the symbol-side companion to Ek9LiteralTypes.typeNameOf(EK9Parser.LiteralContext) (the parse-context side).
static boolean	GenericTypeInfo.isGenericTemplate(ISymbol symbol)	True when the symbol is a generic TEMPLATE (e.g.
static boolean	ConcurrentEntryPoint.isMarked(ISymbol symbol)	True if the symbol has been marked as a concurrent entry point.
static boolean	TargetTypedConstruction.isMarked(ISymbol recordedCall)	Was this call completed from its declared target.
static boolean	RangeProgressCheck.isNeededFor(ISymbol counterType, ISymbol ek9Time, ISymbol ek9Float, ISymbol ek9Dimension)	True when a for-range counted in counterType (already resolved to the concrete type, the base of a constrained one) carries a progress check.
static boolean	Sameness.isOrderable(IAggregateSymbol type, ISymbol ek9Any)	THE "is this type orderable?" behind HasRealComparator: the nearest <=> it declares or inherits (super chain before Any, then its traits) that survives (Sameness.orderingSurvives(MethodSymbol, ISymbol)).
static boolean	StreamStages.isOutputChannel(ISymbol sinkType)	THE test of a built-in OUTPUT CHANNEL (Steve, 2026-10-27: "> udpConnection and > stdout, > stderr all feel normal"): the type IS-A org.ek9.lang::IO - Stdout, Stderr, a file output, a UDP or TCP connection, a StringOutput, and a user type taking those traits.
static boolean	StatementOwnership.isOwnedByItsStatement(ISymbol recorded)	Is recorded a call whose result its statement owns (and closes).
static boolean	CloseSteps.isOwnedCapture(ISymbol capture)	True when the capture was marked as owned by the dynamic class that made it.
static boolean	GenericTypeInfo.isParameterised(ISymbol symbol)	True when the symbol is a concrete PARAMETERISATION of a generic (e.g.
static boolean	PartialOrdering.isPartial(ISymbol type, ISymbol ek9Any)	THE test of whether a <=> of this type can be unset for two SET values of it: a partial built-in, or a type whose values may be of different run-time types under a per-type sameness.
static boolean	PartialOrdering.isPartialBuiltIn(ISymbol type)	True when the type is a core built-in whose runtime class declares a comparison group.
static boolean	OwnProperty.isPropertyOf(ISymbol candidate, IAggregateSymbol aggregate)	True when candidate is one of aggregate's own declared properties - by identity, never by name.
static boolean	ReferenceTypeChecker.isReferenceType(ISymbol type, Ek9Types ek9Types)	Determines if the given ISymbol represents a reference-counted type.
static boolean	SanitizedRequired.isRequiredOn(ISymbol symbol)	True when the symbol is a parameter declared as sanitized, or an expression derived from one.
static boolean	Sameness.isRetractedOrdering(MethodSymbol operator, ISymbol ek9Any)	Is this operator a BARE ordering operator that phase 5 retracts (Sameness.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).
static boolean	SelfReferenceStore.isSelfReference(org.antlr.v4.runtime.tree.ParseTree node, ISymbol symbol, SymbolsAndScopes symbolsAndScopes)	True when the symbol is a property that the constructor this node is in stores 'this' into - so, in that constructor, the property is 'this' under another name.
static boolean	Sameness.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 (Sameness.isRetractedOrdering(MethodSymbol, ISymbol)) or one that degenerates (Sameness.isDegenerateDefaultedOrdering(MethodSymbol, ISymbol)).
static boolean	StreamStages.isWriteThroughSink(ISymbol sinkType)	A sink is write-through - it never accumulates what it is given - only when its type IS-A org.ek9.lang::StringOutput (Stdout, Stderr, a StringOutput).
static boolean	ObjectSharing.iterationRunsProgramCode(ISymbol type)	D66 gap (Steve, 2026-10-21): does a for ... in loop over a value of this type run code of the program's own? THE test: the loop calls iterator() and then hasNext()/next() (or those two on the value itself), so it is a call that is not pure when the type - or the iterator its iterator() declares to return - has one of those methods that is not pure and is supplied by the program: a method written in EK9, or an abstract one of a built-in trait or abstract type (Iterator, Iterable) a program implements.
static Optional<MethodSymbol>	UnsetKeepingOperator.keepingUnset(ISymbol receiverType, String operator, Optional<ISymbol> argumentType)	As UnsetKeepingOperator.resolve(ISymbol, String, Optional) then UnsetKeepingOperator.keepsUnset(MethodSymbol): the resolved operator, only when it keeps an unset receiver unset.
static boolean	StreamStages.keepsUnsetIntoList(ISymbol ek9List, ISymbol target)	True when a TERMINAL's target is a List (the built-in, any parameterisation): collect as List of X, > list, >> list and a tee ... in list target append each element with the List's += (_addAss), which keeps an unset element, never with its | (_pipe), which drops it (Steve, 2026-10-21: "keep them through +=").
static List<ISymbol>	GenericTypeInfo.leafTypes(ISymbol symbol)	THE types a reference to this type couples to, in order: the generic template it was produced from (empty for a plain type: a built-in container, or a user generic's own module) and then every leaf concrete type argument (GenericTypeInfo.concreteTypeArguments(ISymbol)).
static List<ISymbol>	GenericTypeInfo.leaves(ISymbol symbol, Predicate<ISymbol> isLeaf)	THE leaf walk of a type's arguments: descend through every parameterisation (List of (Dict of (K, V))) and collect the leaves isLeaf accepts, in order.
static boolean	PropertyCycles.leavesOutOfHash(IAggregateSymbol owner, ISymbol field)	Must a generated #? on this type leave this field out? True for a field of a cyclic type that can lead back to an object of that type; the hash is then a subset of what == compares, so equal graphs (even co-inductively equal cycles) hash alike, and it never recurses round the loop.
static void	ConcurrentEntryPoint.mark(ISymbol symbol)	Mark the symbol as a concurrent entry point.
static void	TargetTypedConstruction.mark(ISymbol recordedCall)	Record that this call was completed from its declared target.
static void	InputVarietyReceiver.markCounted(ISymbol method)	Record that the floor counts the receiver of this method.
static void	SanitizedRequired.markRequiredOn(ISymbol symbol)	Mark the symbol as one the receiver must clean.
static boolean	BorrowedViewReturn.mayHold(ISymbol returnType)	May a value of returnType (null: unknown) hold a borrowed view?
static boolean	BorrowedViewReturn.mayHold(ISymbol holderType, List<ISymbol> heldTypes)	THE test of whether a holder - a container variable, a stream's target, a call's result - can keep an object of a given type at all (D80 follow-up, 2026-10-21): the same walk as BorrowedViewReturn.mayHold(ISymbol), asked about an object of one of heldTypes instead of about a closeable.
static boolean	Sameness.mayMixRuntimeTypes(IAggregateSymbol type, ISymbol ek9Any)	THE test behind E07187 (D24 Q4 REVISED, Steve 2026-10-20): can two values of this type be of DIFFERENT run-time types whose <=> is UNSET? Then <? and >? have no lesser or greater value to select, and an unset value cannot be built to stand in for one (a T() may be set, absent, private or abstract, and would run developer code).
static Optional<MethodSymbol>	InheritedOperators.nearestAbove(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.
static Optional<MethodSymbol>	Sameness.nearestSamenessAbove(IAggregateSymbol owner, ISymbol ek9Any)	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 (InheritedOperators.nearestSelfComparisonAbove(IAggregateSymbol, String, ISymbol)) - the super is ORDERED - else the nearest such == - the super is EQUATABLE only.
static Optional<MethodSymbol>	InheritedOperators.nearestSelfComparisonAbove(IAggregateSymbol aggregate, String operatorName, ISymbol ek9Any)	THE nearest SAMENESS operator above the aggregate (D19, Steve 2026-10-20): the nearest operatorName (== or <=>) declared above it that compares the level declaring it with ITSELF (Sameness.isSelfComparison(IAggregateSymbol, MethodSymbol)) - matched by SIGNATURE, never by name, never Any's.
static Optional<MethodSymbol>	Sameness.nearestSurvivingSamenessAbove(IAggregateSymbol owner, ISymbol ek9Any)	The sameness a type that declares none of its own gets from its super CLASS chain once PRE_IR_CHECKS has run (D55): Sameness.nearestSamenessAbove(IAggregateSymbol, ISymbol), but a <=> that does not survive (Sameness.orderingSurvives(MethodSymbol, ISymbol)) is passed over for the nearest == - the super is EQUATABLE only.
static boolean	PolymorphicCopy.needsCopyAccepts(IAggregateSymbol owner, ISymbol ek9Any)	Does the owner get a _copyAccepts? Only where one can be asked.
static boolean	StreamStages.needsFreshValueError(int terminationOp, Ek9Types ek9Types, ISymbol target)	True when a > would have to replace its target but the target cannot make a fresh value (E08278): it is abstract or a trait, has no accessible no-argument constructor, or has no :=: to swap the fresh value in.
ExpressionSymbol	SymbolFactory.newExpressionSymbol(ISymbol fromSymbol)	Create a new expression around a symbol.
static void	ConceptualAccess.noteNaturalOrderQueue(ISymbol elementType)	Note a natural-order PriorityQueue of this element type, when it is built on a conceptual parameter without being one (PriorityQueue of (OrderedBox of T)).
static Optional<String>	ConstructDisplayName.of(ISymbol symbol)	The fully qualified display name (module::Holder of String) of a monomorphised generic, else empty.
static List<ConstructTypeReferences.TypeReference>	ConstructTypeReferences.of(ISymbol construct)	Enumerate the signature-level type references of a construct.
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 HttpAccess	HttpAccess.of(ISymbol param)	The access kind of this parameter: what was stored, else PATH - the kind an unqualified service parameter is assumed to be (see HttpAccess.defaultOnto(ISymbol)), so a check that runs without having asked for the default first still gets the answer the default would have given.
static int	MeasuredComplexity.of(ISymbol symbol)	The symbol's measured complexity, or 0 when it was never measured (or is unparseable).
static String	ModuleOf.of(ISymbol type)	The name of the module the type belongs to; empty text when it cannot be told.
static ErrorListener	OwningErrorListener.of(ISymbol symbol, ErrorListener fallback)	The error listener of the source that declares symbol, or fallback if it has none.
static boolean	Sameness.orderingSurvives(MethodSymbol comparison, ISymbol ek9Any)	THE "does this <=> still order values once PRE_IR_CHECKS has run?" (D55, Steve 2026-10-20).
static boolean	Sameness.orderingWithdrawn(IAggregateSymbol type, ISymbol ek9Any)	Does a use that needs the type's <=> without naming it (sort, <?, a range) rely on an ordering that is not there: a withdrawn bare <=> (Sameness.withdrawnOrdering(IAggregateSymbol, ISymbol)) or a DictEntry whose key cannot be ordered (Sameness.unorderedDictEntryKey(ISymbol, ISymbol))? THE test of phase 5's RetractedComparatorUseOrError; Sameness.whyNotOrderable(IAggregateSymbol, ISymbol) words it.
static StreamStages.OutputStep	StreamStages.outputStepFor(int terminationOp, ISymbol sinkType)	THE decision of which StreamStages.OutputStep a termination gives its sink: > into an output channel clears, >> appends, anything that is not a channel (a collection, a fold, a user type) gets none.
static List<MethodSymbol>	Sameness.overriddenSignatures(IAggregateSymbol owner, ISymbol ek9Any)	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 (InheritedOperators.allAbove(IAggregateSymbol, String, ISymbol)) that takes a type the owner is assignable to and that the owner does not declare itself.
static Optional<MethodSymbol>	Sameness.ownOperatorTaking(IAggregateSymbol owner, String name, ISymbol parameterType)	The owner's own non-abstract operator of this name taking exactly that one type, if any.
static Optional<PossibleGenericSymbol>	GenericTypeInfo.parameterisationOf(ISymbol generic, ISymbol target)	THE strict test: target is a parameterisation of EXACTLY this generic - not a sub type or a super type of it - and so the parameterisation itself (List of String for the generic List), else empty.
static Optional<String>	NaturalOrderQueue.problemWith(ISymbol elementType, ISymbol ek9Any)	E07620's wording for an element type that cannot be ordered, or empty when it can.
static Optional<IAggregateSymbol>	ProgramBody.programOf(ISymbol symbol)	The program whose body this symbol is - empty for anything else.
static Optional<ISymbol>	TypeCoercions.promotionOperator(ISymbol from)	The #^ operator itself that this 'from' type promotes through, or empty if it has none - for a caller that must read the operator, not only its type (what its RETAINS say it does with the object it is called on: the closeable ownership decision, where an argument reaching a callee as its promotion is not the argument itself).
static Optional<ISymbol>	TypeCoercions.promotionTarget(ISymbol from)	The single type this 'from' type promotes to via its #^ operator, or empty if it has none.
void	HttpAccess.putOn(ISymbol param)	Store this access kind on the parameter, as the one writer of the HTTP_ACCESS squirrel.
static boolean	ObjectSharing.rangeRunsProgramCode(ISymbol type)	D66 gap (verifier, 2026-10-21): does a for range over values of this type run code of the program's own? The range builds its counter and each loop value with the type's copy constructor and moves the counter with ++/-- (or +=/-= by a step), comparing with <=>: a program type with any of those not pure runs that code, which may change what it can reach (a copy shares its fields).
static Optional<ObjectSharing.Reach>	ObjectSharing.reachOfInPlaceWrite(org.antlr.v4.runtime.ParserRuleContext occurrence, ISymbol written, ISymbol type, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	THE reading of an in-place write as a call (D66, Steve 2026-10-21): when the operator that makes it is the program's own code (ObjectSharing.inPlaceWriteRunsProgramCode(ISymbol, String)), it is a call that is not pure, given the object written and whatever the right-hand side gives it (other -= amount), or - for a stream target - every element of the stream.
static String	ConstructDisplayName.readable(ISymbol symbol)	THE name a GENERATED operator shows for a type in its text (D65, Contract 21 rule 5): a parameterised type by its friendly name (Holder of String), every other type by its simple name, and in either case a compiler-made name by what FriendlyInternalName gives it - a dynamic class is cls, never its _Class_<digest>.
static String	ConstructDisplayName.readableFriendly(ISymbol symbol)	The friendly name of a type as the symbol gives it, with a compiler-made name made readable (D65): the form a generated refusal message uses for the types it names.
static void	MeasuredComplexity.record(ISymbol symbol, int complexity)	Record a complexity against a symbol that phase 5 will never visit.
static boolean	StreamStages.replacesTargetOnCompletion(int terminationOp, Ek9Types ek9Types, ISymbol target)	True when a stream statement's > REPLACES its target when the pipeline completes (Steve, 2026-10-21: "> 'clobbers' and >> 'appends'", the Unix shell meaning; made ALL-OR-NOTHING the same day, and extended to a PriorityQueue and a JSON: "> always means REPLACE"; to a scalar 2026-10-26; and finally to EVERY target, no type list, 2026-10-27: "let's make > consistent"): the termination is > (never >>) and the target is anything but an output channel (StreamStages.isOutputChannel(ISymbol)).
static Optional<MethodSymbol>	UnsetKeepingOperator.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.
static boolean	Sameness.retractWithdrawnBareOrdering(IAggregateSymbol aggregate, ISymbol ek9Any)	THE retraction step (D55/D58/D62): when Sameness.bareOrderingRetracted(IAggregateSymbol, ISymbol) says the type's bare ordering is withdrawn, mark each of its bare ordering operators (<=>, <, <=, >, >=) DEFAULT_OPERATOR_RETRACTED, which the type's method set then filters out, so none is generated.
static void	ClonedMemberRetyping.retypeOne(ISymbol value, UnaryOperator<ISymbol> replacement)	Re-type a single symbol, in place, when it has a type.
static Optional<MethodSymbol>	Sameness.sealedSameness(IAggregateSymbol aggregate, ISymbol ek9Any)	The SEALED sameness this type inherits - one written by hand on an abstract base or a trait above it (Sameness.isHierarchyWide(IAggregateSymbol)) - if any.
static StreamStages.SinkBuffer	StreamStages.sinkBufferFor(Ek9Types ek9Types, ISymbol target)	THE decision of StreamStages.SinkBuffer for a target type (asked beside StreamStages.replacesTargetOnCompletion(int, Ek9Types, ISymbol), which is defined by it).
static boolean	ExactSingleParameter.takes(MethodSymbol method, ISymbol type)	True when method takes exactly one parameter whose type is exactly type.
static Optional<ISymbol>	BooleanTruthGuard.targetOf(EK9Parser.PreFlowStatementContext preFlow, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recordedSymbol, ISymbol ek9Boolean)	The target of a Boolean truth guard, if this pre-flow is one.
boolean	BareTypeParameter.test(ISymbol symbol)
boolean	IsFunctionDelegateSymbol.test(ISymbol symbol)
boolean	IsMutexKeyType.test(ISymbol symbol)
boolean	IsMutexLockType.test(ISymbol symbol)
boolean	NoBuiltInNameOrError.test(IScope moduleScope, ISymbol symbol)	Check the symbol about to be defined in the module scope given.
boolean	NoCaseVariantNameOrError.test(List<ISymbol> alreadyDefined, ISymbol symbol)	Check the symbol being defined against those already defined in the same module.
boolean	NoNameCollisionOrError.test(IScope inScope, ISymbol symbol)	Check for exising symbol in the scope.
boolean	NotImplicitSuper.test(ISymbol symbol)
boolean	ProgramArgumentPredicate.test(ISymbol typeSymbol)
boolean	RefersToSameSymbol.test(ISymbol s1, ISymbol s2)
boolean	SameGenericConceptualParameters.test(ISymbol typeSymbol, List<ISymbol> typeArguments)
boolean	TypeCanReceivePipedData.test(ISymbol symbolType)
static List<ISymbol>	GenericTypeInfo.typeParametersOrArguments(ISymbol symbol)	The single level of type parameters (for a template) or type arguments (for a parameterisation) exactly as declared — for display/inspection.
static List<IAggregateSymbol>	ConceptualAccess.typeParametersUnder(ISymbol type)	The conceptual parameters a (non-bare) parameterisation is built on, each once; for a generic template (named in its own body) its own type parameters.
static Optional<ISymbol>	Sameness.unorderedDictEntryKey(ISymbol type, ISymbol ek9Any)	The key type that stops a DictEntry of (K, V) being ordered (Steve, 2026-10-21): a DictEntry orders by its KEY's <=>, then by its VALUE's when the keys are the same (the entries of one Dict have unique keys), so a key type that cannot be ordered (Sameness.isOrderable(IAggregateSymbol, ISymbol); a function never can) leaves the entry unordered, and a comparator-less sort, <?, range or natural-order queue over it is E07620 - not the run-time "Sort cannot order" Exception it was.
static Optional<Sameness.UnorderedProperty>	Sameness.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 (Sameness.isOrderable(IAggregateSymbol, ISymbol)).
static List<RecordedSymbols.Reference>	RecordedSymbols.usesOf(ParsedModule parsedModule, org.antlr.v4.runtime.tree.ParseTree within, ISymbol symbol)	The references in within to symbol - that INSTANCE, never another symbol with the same name - plus the references to the copies of it that dynamic functions and classes inside within captured (a capture is a copy symbol; a += on it mutates the same object).
static String	Sameness.whyNotOrderable(IAggregateSymbol type, ISymbol ek9Any)	THE wording of why a type has no <=> although it asked for one with the bare default operator (D58): the field whose type cannot be ordered, the type declaring it and - only where that is a super - that a sub-type follows its super.
static Optional<String>	PartialOrdering.whyPartial(ISymbol type, ISymbol ek9Any)	THE wording of why a type's <=> is partial (PartialOrdering.isPartial(ISymbol, ISymbol)), to follow "'X' ...", or empty when it is total.
static Optional<MethodSymbol>	Sameness.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 (Sameness.orderingSurvives(MethodSymbol, ISymbol)).
static List<SymbolWrites.Write>	SymbolWrites.writesOf(ParsedModule parsedModule, org.antlr.v4.runtime.tree.ParseTree region, ISymbol symbol)	Every write to symbol (or to a captured copy of it) in region, in source order.

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

Modifier and Type	Method	Description
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.
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.
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.
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.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.
void	AggregateManipulator.addSyntheticConstructorIfRequired(IAggregateSymbol aggregateSymbol, List<ISymbol> constructorArguments)	Add a synthetic constructor, if a constructor is not present.
static List<ObjectSharing.Use>	ObjectSharing.all(EK9Parser.IdentifierContext occurrence, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	EVERY effect of one occurrence: what ObjectSharing.of(EK9Parser.IdentifierContext, Function) says, plus what the occurrence RETAINS (D61) - the object put in a collection literal, a Dict value, given to a call or constructor that keeps its argument, added with a compound assignment, or iterated by a for: whatever holds it afterwards shares the object, so an in-place change through the holder (a loop variable, an element, a field) changes it too.
static List<ObjectSharing.Use>	ObjectSharing.allOfSelf(EK9Parser.PrimaryReferenceContext self, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	What this or super - the object a method runs on, whose name is no identifier - does to that object, read exactly as the occurrence of a variable is (ObjectSharing.all(EK9Parser.IdentifierContext, Function)): kept where the whole expression is kept (items += this, box <- Box(this), (this) is ...), or the start of a call chain that may return a view of it (this.me()).
Optional<ISymbol>	CommonTypeSuperOrTraitOrError.apply(IToken lineToken, List<ISymbol> argumentSymbols)
Map<ISymbol,ISymbol>	ConceptualLookupMapping.apply(List<ISymbol> typeArguments, List<ISymbol> typeParameters)
String	InternalNameFor.apply(PossibleGenericSymbol possibleGenericSymbol, List<ISymbol> typeArguments)
PossibleGenericSymbol	ParameterizedSymbolCreator.apply(PossibleGenericSymbol possibleGenericSymbol, List<ISymbol> typeArguments)
PositionalConceptualLookupMapping.Mapping	PositionalConceptualLookupMapping.apply(List<ISymbol> typeArguments, List<ISymbol> typeParameters)
List<ISymbol>	SymbolTypeExtractor.apply(List<ISymbol> argumentSymbols)
String	ToCommaSeparated.apply(List<ISymbol> params)
static Optional<ScopedSymbol>	ReturnRetention.calleeOf(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	The method, operator or function an expression CALLS when the whole expression is that call - a.get(k), first(), a + b, (a.get(k)) - so its value is whatever the call handed back.
static Optional<ISymbol>	RecordedSymbols.capturedCopy(Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded, EK9Parser.ExpressionParamContext param)	The copy a dynamic function or class makes from one argument of its capture list - (acc) and (total: acc) both make a copy, named acc and total - which shares the object the argument refers to.
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.createPurePublicSimpleOperator(IAggregateSymbol aggregateSymbol, String methodName, Optional<ISymbol> returnType)	Just creates a public operator with the name specified.
boolean	SymbolChecker.errorsIfNameDiffersOnlyByCase(List<ISymbol> alreadyDefined, ISymbol symbol)	Check whether the symbol being defined differs ONLY by case from one already defined in the same module.
static IsFreshValueExpression	IsFreshValueExpression.forCloseableReturns(Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	The closeable-return reading (R5): also a call whose callee DECLARES a closeable return type and does not declare (or have derived) a result that may alias.
double	SymbolMatcher.getCostOfMatch(Optional<ISymbol> fromSymbol, Optional<ISymbol> toSymbol)	Calculates the cost of matching two symbols, which may or may not be present.
double	SymbolMatcher.getCostOfParameterMatch(List<ISymbol> fromSymbols, List<ISymbol> toSymbols)	Calculates the percentage of matching these two lists of parameters.
protected Consumer<MethodSymbol>	CommonFactory.getDefaultOperatorSymbolInitializer(Consumer<ISymbol> initialise)
static boolean	TypeCoercions.isCoercible(Optional<ISymbol> from, Optional<ISymbol> to)	Can the 'from' token type be coerced to the 'to' type.
static boolean	SymbolWrites.isWrittenBetween(ParsedModule parsedModule, org.antlr.v4.runtime.tree.ParseTree region, Set<ISymbol> symbols, int afterTokenIndex, int beforeTokenIndex)	Is any of symbols written in region strictly between two token positions (token indexes in the compiled token stream: pass first.getStop().getTokenIndex() and second.getStart().getTokenIndex() to ask "does anything change these between the two occurrences?").
static boolean	SymbolWrites.isWrittenIn(ParsedModule parsedModule, org.antlr.v4.runtime.tree.ParseTree region, Set<ISymbol> symbols)	Is any of symbols written anywhere in region.
static Optional<MethodSymbol>	UnsetKeepingOperator.keepingUnset(ISymbol receiverType, String operator, Optional<ISymbol> argumentType)	As UnsetKeepingOperator.resolve(ISymbol, String, Optional) then UnsetKeepingOperator.keepsUnset(MethodSymbol): the resolved operator, only when it keeps an unset receiver unset.
static List<ISymbol>	GenericTypeInfo.leaves(ISymbol symbol, Predicate<ISymbol> isLeaf)	THE leaf walk of a type's arguments: descend through every parameterisation (List of (Dict of (K, V))) and collect the leaves isLeaf accepts, in order.
static boolean	ObjectSharing.mayBeExistingObject(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	May the value of this expression BE an object that exists already - rather than a fresh one: a variable (not a constant, which is read as a copy), this/super, a call whose RETAINS says its result may be its receiver's interior or an argument (ReturnRetention.mayAlias(ScopedSymbol)), or a coalescing operator's result or a ternary's when EITHER operand may be (the result is one of them: the same route ObjectSharing.all(EK9Parser.IdentifierContext, Function) follows for the operand itself).
static boolean	ObjectSharing.mayBeExistingObjectByShape(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	Is the expression, looking through parentheses, of a SHAPE whose value may be an object that already exists - a variable, this/super, a call, or a coalescing operator or ternary (whose result IS one of its operands) - so only ObjectSharing.mayBeExistingObject(EK9Parser.ExpressionContext, Function), once phase 5 has derived the RETAINS of the program's own callables, can say whether it is.
static boolean	ObjectSharing.mayBeObjectFromOutside(org.antlr.v4.runtime.tree.ParseTree value, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	May the value given to a name be, or hold, an object from OUTSIDE the code being analysed (D66) that the name is not recorded as sharing with: this - itself, or held by a list, a Dict, a constructor's or call's arguments or a dynamic function's or class's capture list (box <- Box(this)) - or a result a call, a coalescing operator or a ternary hands back that may be an existing object.
static boolean	BorrowedViewReturn.mayHold(ISymbol holderType, List<ISymbol> heldTypes)	THE test of whether a holder - a container variable, a stream's target, a call's result - can keep an object of a given type at all (D80 follow-up, 2026-10-21): the same walk as BorrowedViewReturn.mayHold(ISymbol), asked about an object of one of heldTypes instead of about a closeable.
static boolean	ObjectSharing.mayRunProgramCode(org.antlr.v4.runtime.tree.ParseTree call, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	May the call (or stream stage operand) call run code of the program's own - something that is not pure and not a concrete built-in? Such code may change any object it can reach, an object kept where the caller cannot name it included.
ExpressionSymbol	SymbolFactory.newExpressionSymbol(IToken token, String name, Optional<ISymbol> ofType)	Create a new expression symbol place-holder.
PossibleGenericSymbol	SymbolFactory.newParameterisedSymbol(PossibleGenericSymbol genericType, List<ISymbol> typeArguments)
static Optional<ObjectSharing.Use>	ObjectSharing.of(EK9Parser.IdentifierContext occurrence, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	What occurrence - an identifier the compiler bound to a symbol - does to the object it names; empty when it only reads it, or stores a new object in it.
static List<ConceptualAccess.OrderingUse>	ConceptualAccess.orderingUsesOf(List<? extends ISymbol> typeParameters)	The orderings of types built on any of these conceptual parameters that the generic's body uses, each once (a type built on several parameters is recorded on each).
static ObjectSharing.Reach	ObjectSharing.reachOf(org.antlr.v4.runtime.tree.ParseTree call, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	THE reading of what a call that may run the program's own code can change: everything reachable from ObjectSharing.Reach, which the value tracker turns into what it forgets (ValueTrackingAnalyzer.recordCallThatMayChange).
static Optional<ObjectSharing.Reach>	ObjectSharing.reachOfInPlaceWrite(org.antlr.v4.runtime.ParserRuleContext occurrence, ISymbol written, ISymbol type, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	THE reading of an in-place write as a call (D66, Steve 2026-10-21): when the operator that makes it is the program's own code (ObjectSharing.inPlaceWriteRunsProgramCode(ISymbol, String)), it is a call that is not pure, given the object written and whatever the right-hand side gives it (other -= amount), or - for a stream target - every element of the stream.
static ObjectSharing.Reach	ObjectSharing.reachOfIteration(EK9Parser.ExpressionContext iterated, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	What a for loop over iterated can reach (D66, the same reading as ObjectSharing.reachOf(ParseTree, Function) gives a call): the value iterated - a name, this, or something no name is given to - and what it is made from.
static Optional<MethodSymbol>	UnsetKeepingOperator.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.
static void	ClonedMemberRetyping.retype(IScopedSymbol newOwner, List<ISymbol> clonedMembers, UnaryOperator<ISymbol> replacement)	Re-type the members, in place.
static void	ClonedMemberRetyping.retype(IScopedSymbol newOwner, List<ISymbol> clonedMembers, UnaryOperator<ISymbol> replacement)	Re-type the members, in place.
static void	ClonedMemberRetyping.retypeOne(ISymbol value, UnaryOperator<ISymbol> replacement)	Re-type a single symbol, in place, when it has a type.
static Optional<ISymbol>	BooleanTruthGuard.targetOf(EK9Parser.PreFlowStatementContext preFlow, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recordedSymbol, ISymbol ek9Boolean)	The target of a Boolean truth guard, if this pre-flow is one.
boolean	NoCaseVariantNameOrError.test(List<ISymbol> alreadyDefined, ISymbol symbol)	Check the symbol being defined against those already defined in the same module.
boolean	SameGenericConceptualParameters.test(ISymbol typeSymbol, List<ISymbol> typeArguments)
boolean	TypeListComparator.test(List<ISymbol> listOne, List<ISymbol> listTwo)

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

Modifier	Constructor	Description
	CaptureAssignment(EK9Parser.AssignmentStatementContext statement, ISymbol property)	Creates an instance of a CaptureAssignment record class.
	IsMutexKeyType(ISymbol ek9MutexKey)
	IsMutexLockType(ISymbol ek9MutexLock)
	IsThreadSpawningCall(ISymbol ek9Tcp, ISymbol ek9Signals)
	OrderingUse(ISymbol type, ConceptualAccess.OrderingKind kind, MethodSymbol operator)	Creates an instance of a OrderingUse record class.
	ParameterisedTypeData(IToken location, ISymbol genericTypeSymbol, List<ISymbol> typeArguments)	Creates an instance of a ParameterisedTypeData record class.
	Reference(org.antlr.v4.runtime.ParserRuleContext node, ISymbol symbol)	Creates an instance of a Reference record class.
	ReferenceAssignment(ISymbol target, EK9Parser.ExpressionContext source)	Creates an instance of a ReferenceAssignment record class.
	ToCommaSeparated(ISymbol fromType, boolean includeParenthesis)
	TypeReference(String kind, ISymbol type)	Creates an instance of a TypeReference record class.
	UnorderedProperty(IAggregateSymbol owner, ISymbol property)	Creates an instance of a UnorderedProperty record class.
	Use(ObjectSharing.Kind kind, ISymbol sharedWith)	Creates an instance of a Use record class.

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

Modifier	Constructor	Description
	CommonTypeDeterminationDetails(IToken lineToken, List<ISymbol> argumentSymbols, List<ISymbol> argumentTypes)	Creates an instance of a CommonTypeDeterminationDetails record class.
	ConceptualTypeReplacement(BiFunction<PossibleGenericSymbol, IToken, ISymbol> onParameterisedType)	Construct the replacement with the action to apply to each rebuilt parameterised type.
	Mapping(List<ISymbol> typeArguments, List<ISymbol> typeParameters)	Creates an instance of a Mapping record class.
	ParameterisedTypeData(IToken location, ISymbol genericTypeSymbol, List<ISymbol> typeArguments)	Creates an instance of a ParameterisedTypeData record class.
	ParameterizedSymbolCreator(BiFunction<PossibleGenericSymbol, List<ISymbol>, String> internalNameFor)
	Reach(boolean givenThis, List<ISymbol> named, boolean someOtherObject)	Creates an instance of a Reach record class.
	Steps(List<ISymbol> closed, Optional<MethodSymbol> parentClose)	Creates an instance of a Steps record class.

Uses of ISymbol in org.ek9lang.compiler.support.inputvariety

Methods in org.ek9lang.compiler.support.inputvariety that return ISymbol

Modifier and Type	Method	Description
ISymbol	LeafPath.leafType()	Returns the value of the leafType record component.

Methods in org.ek9lang.compiler.support.inputvariety with parameters of type ISymbol

Modifier and Type	Method	Description
InputVarietyDenominator	InputVarietyDenominatorCalculator.forInstanceMethod(ISymbol receiverType, List<ISymbol> parameterTypes)	The figures for an instance method / operator, treating the receiver type as an implicit parameter p0 (design §4.5): its leaf dimensions are prepended to the argument leaves, so a no-arg instance method (e.g.
boolean	EquivalenceClassModel.isEnumeration(ISymbol typeSymbol)	True when this type's value-classes ARE its enumeration members — i.e.
List<LeafPath>	EquivalenceClassModel.leafPathsOf(ISymbol typeSymbol)	The same leaf dimensions EquivalenceClassModel.leavesOf(ISymbol) counts, but as LeafPaths — each carrying the field steps walked to reach it.
List<TypeVariety>	EquivalenceClassModel.leavesOf(ISymbol typeSymbol)	The scalar LEAF dimensions a type contributes to a callable's input space (design §4.5 v3.2 / §4.6) — the composition primitive.
TypeVariety	EquivalenceClassModel.varietyOf(ISymbol typeSymbol)	The variety of a resolved type symbol; EquivalenceClassModel.FLOOR for a null type (a parameter always has a resolved type by phase 5, so null is only a defensive guard).

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

Modifier and Type	Method	Description
InputVarietyDenominator	InputVarietyDenominatorCalculator.forInstanceMethod(ISymbol receiverType, List<ISymbol> parameterTypes)	The figures for an instance method / operator, treating the receiver type as an implicit parameter p0 (design §4.5): its leaf dimensions are prepended to the argument leaves, so a no-arg instance method (e.g.
InputVarietyDenominator	InputVarietyDenominatorCalculator.forParameterTypes(List<ISymbol> parameterTypes)	The denominator for a construct whose parameters have the given resolved type symbols, in declaration order.

Constructors in org.ek9lang.compiler.support.inputvariety with parameters of type ISymbol

Modifier	Constructor	Description
	LeafPath(List<LeafField> fields, ISymbol leafType)	Creates an instance of a LeafPath record class.

Uses of ISymbol in org.ek9lang.compiler.symbolic

Method parameters in org.ek9lang.compiler.symbolic with type arguments of type ISymbol

Modifier and Type	Method	Description
List<GuardCouplingReader.GuardCoupling>	GuardCouplingReader.read(org.antlr.v4.runtime.tree.ParseTree constructCtx, List<ISymbol> callParameters, ParsedModule module)	Read every coupling expressed by a control condition in constructCtx.
List<FunctionSummary.RequirePredicate>	RequirePredicateReader.read(org.antlr.v4.runtime.tree.ParseTree constructCtx, List<ISymbol> callParameters, ParsedModule module)	Read every modellable require precondition in constructCtx.

Uses of ISymbol in org.ek9lang.compiler.symbols

Subinterfaces of ISymbol in org.ek9lang.compiler.symbols

Modifier and Type	Interface	Description
interface	IAggregateSymbol	Interface for an aggregate, typically a class or something like that.
interface	ICanBeGeneric	Really a Marker interface for generic classes and generic functions.
interface	IFunctionSymbol	Interface to abstract FunctionSymbol away as concrete implementation.
interface	IScopedSymbol	For symbols that are both a pure symbol but can also define a scope.

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

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).
class	AssertDoesNotThrowSymbol	EK9 assertDoesNotThrow expression - validates that an expression does not throw.
class	AssertPanicSymbol	EK9 assertPanic expression - asserts that the wrapped expression fires an org.ek9.lang::Panic.
class	AssertThrowsSymbol	EK9 assertThrows expression - captures an expected exception type and expression.
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	CaptureScopedSymbol	Just focuses on the ability to possible capture variables from an enclosing scope.
class	ConstantSymbol	A very simple type that holds a single distinct value.
class	ControlSymbol	EK9 switch/try control type symbol - this can effectively return a value if it is configured with returning part.
class	ExpressionSymbol	While we don't add these in the scoped structures when compiling.
class	ForSymbol	EK9 'for' type symbol - we need a scope because we declare a new variable as the loop variable.
class	FunctionSymbol	Scope for functions that are part of a module.
class	MethodSymbol	Represents some type of method that exists on an aggregate type scope.
class	ParamExpressionSymbol	While we don't add these in the scoped structures when compiling.
class	PossibleGenericSymbol	Added as a common symbol type for both Functions and Aggregates that could possibly be generic in nature and also be a parameterised type.
class	ScopedSymbol	Represents a symbol that also has a scope.
class	ServiceOperationSymbol	Scope for callable methods (operations) that are part of a Service.
class	StackConsistencyScope	Used when duplicate symbols are found, where we need to add a placeholder.
class	StreamCallSymbol	Just re-uses the bulk of method symbol.
class	StreamPipeLineSymbol	Intended to model the pipeline flow in a streaming of cat or for loop though | and map etc.
class	SwitchSymbol	EK9 switch statement - this can effectively return a value if it is configured with returning part.
class	Symbol	A bit of a beast.
class	TrySymbol	EK9 try statement - this can effectively return a value if it is configured with returning part.
class	VariableSymbol	Models a variable.
class	WhileSymbol	EK9 'while' or 'do/while' type symbol - we need a scope because we can declare new variables as part of the pre-flow semantics.

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

Modifier and Type	Method	Description
ISymbol	ISymbol.clone(IScope withParentAsAppropriate)	Clone the symbol and re-parent if this symbol like a method should have a parent.
ISymbol	Ek9Types.ek9Bits()	Returns the value of the ek9Bits record component.
ISymbol	Ek9Types.ek9Boolean()	Returns the value of the ek9Boolean record component.
ISymbol	Ek9Types.ek9Character()	Returns the value of the ek9Character record component.
ISymbol	Ek9Types.ek9Comparator()	Returns the value of the ek9Comparator record component.
ISymbol	Ek9Types.ek9Consumer()	Returns the value of the ek9Consumer record component.
ISymbol	Ek9Types.ek9Date()	Returns the value of the ek9Date record component.
ISymbol	Ek9Types.ek9DateTime()	Returns the value of the ek9DateTime record component.
ISymbol	Ek9Types.ek9Dictionary()	Returns the value of the ek9Dictionary record component.
ISymbol	Ek9Types.ek9DictionaryEntry()	Returns the value of the ek9DictionaryEntry record component.
ISymbol	Ek9Types.ek9Duration()	Returns the value of the ek9Duration record component.
ISymbol	Ek9Types.ek9Exception()	Returns the value of the ek9Exception record component.
ISymbol	Ek9Types.ek9Float()	Returns the value of the ek9Float record component.
ISymbol	Ek9Types.ek9Function()	Returns the value of the ek9Function record component.
ISymbol	Ek9Types.ek9HttpContext()	Returns the value of the ek9HttpContext record component.
ISymbol	Ek9Types.ek9HttpRequest()	Returns the value of the ek9HttpRequest record component.
ISymbol	Ek9Types.ek9HttpResponse()	Returns the value of the ek9HttpResponse record component.
ISymbol	Ek9Types.ek9Integer()	Returns the value of the ek9Integer record component.
ISymbol	Ek9Types.ek9IO()	Returns the value of the ek9IO record component.
ISymbol	Ek9Types.ek9Iterator()	Returns the value of the ek9Iterator record component.
ISymbol	Ek9Types.ek9Json()	Returns the value of the ek9Json record component.
ISymbol	Ek9Types.ek9List()	Returns the value of the ek9List record component.
ISymbol	Ek9Types.ek9Locale()	Returns the value of the ek9Locale record component.
ISymbol	Ek9Types.ek9Millisecond()	Returns the value of the ek9Millisecond record component.
ISymbol	Ek9Types.ek9MutexKey()	Returns the value of the ek9MutexKey record component.
ISymbol	Ek9Types.ek9MutexLock()	Returns the value of the ek9MutexLock record component.
ISymbol	Ek9Types.ek9Optional()	Returns the value of the ek9Optional record component.
ISymbol	Ek9Types.ek9Panic()	Returns the value of the ek9Panic record component.
ISymbol	Ek9Types.ek9Path()	Returns the value of the ek9Path record component.
ISymbol	Ek9Types.ek9Predicate()	Returns the value of the ek9Predicate record component.
ISymbol	Ek9Types.ek9PriorityQueue()	Returns the value of the ek9PriorityQueue record component.
ISymbol	Ek9Types.ek9Privileged()	Returns the value of the ek9Privileged record component.
ISymbol	Ek9Types.ek9Result()	Returns the value of the ek9Result record component.
ISymbol	Ek9Types.ek9Routine()	Returns the value of the ek9Routine record component.
ISymbol	Ek9Types.ek9Sensitive()	Returns the value of the ek9Sensitive record component.
ISymbol	Ek9Types.ek9Set()	Returns the value of the ek9Set record component.
ISymbol	Ek9Types.ek9Signals()	Returns the value of the ek9Signals record component.
ISymbol	Ek9Types.ek9Stderr()	Returns the value of the ek9Stderr record component.
ISymbol	Ek9Types.ek9Stdin()	Returns the value of the ek9Stdin record component.
ISymbol	Ek9Types.ek9Stdout()	Returns the value of the ek9Stdout record component.
ISymbol	Ek9Types.ek9String()	Returns the value of the ek9String record component.
ISymbol	Ek9Types.ek9Supplier()	Returns the value of the ek9Supplier record component.
ISymbol	Ek9Types.ek9Tcp()	Returns the value of the ek9Tcp record component.
ISymbol	Ek9Types.ek9TcpConnection()	Returns the value of the ek9TcpConnection record component.
ISymbol	Ek9Types.ek9Time()	Returns the value of the ek9Time record component.
ISymbol	Ek9Types.ek9Udp()	Returns the value of the ek9Udp record component.
ISymbol	Ek9Types.ek9UnaryOperator()	Returns the value of the ek9UnaryOperator record component.
ISymbol	Ek9Types.ek9Version()	Returns the value of the ek9Version record component.
ISymbol	Ek9Types.ek9Void()	Returns the value of the ek9Void record component.
ISymbol	StreamCallSymbol.getConsumesSymbolType()
ISymbol	StreamCallSymbol.getProducesSymbolType()
ISymbol	RegistrationData.implementationSymbol()	Returns the value of the implementationSymbol record component.
ISymbol	RegistrationData.interfaceSymbol()	Returns the value of the interfaceSymbol record component.
ISymbol	AggregateSymbol.setType(Optional<ISymbol> type)
ISymbol	FunctionSymbol.setType(Optional<ISymbol> type)
ISymbol	FunctionSymbol.setType(ISymbol type)
ISymbol	ISymbol.setType(Optional<ISymbol> type)
default ISymbol	ISymbol.setType(ISymbol type)
ISymbol	Symbol.setType(Optional<ISymbol> type)

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

Modifier and Type	Method	Description
List<ISymbol>	RegistrationData.aspectSymbols()	Returns the value of the aspectSymbols record component.
List<ISymbol>	AggregateSymbol.getAllSymbolsMatchingName(String symbolName)
List<ISymbol>	AggregateWithTraitsSymbol.getAllSymbolsMatchingName(String symbolName)
List<ISymbol>	IScope.getAllSymbolsMatchingName(String symbolName)	Return a list of all the symbols that match the name.
List<ISymbol>	ScopedSymbol.getAllSymbolsMatchingName(String symbolName)
List<ISymbol>	SymbolTable.getAllSymbolsMatchingName(String symbolName)
List<ISymbol>	ICanBeGeneric.getAnyConceptualTypeParameters()
List<ISymbol>	PossibleGenericSymbol.getAnyConceptualTypeParameters()	If this scope has been parameterised, then go through those parameters and return a list of all those that are generic 'T' in nature and not actually concrete types.
List<ISymbol>	FunctionSymbol.getCallParameters()	Added convenience method to make the parameters a bit more obvious.
default List<ISymbol>	IFunctionSymbol.getCallParameters()
List<ISymbol>	MethodSymbol.getCallParameters()	Added convenience method to make the parameters a bit more obvious.
Set<ISymbol>	AggregateSymbol.getInjectionFields()	Get all fields marked for injection on this aggregate.
List<ISymbol>	ParamExpressionSymbol.getParameters()
List<ISymbol>	AggregateSymbol.getProperties()	Provides access to the properties on this aggregate - but only this aggregate.
default List<ISymbol>	IAggregateSymbol.getProperties()	Just access to the properties in this aggregate - no supers.
Map<String,ISymbol>	ModuleScope.getReferencedSymbols()	The declared references manifest of this module scope — the short-name to resolved-symbol map for every reference entry.
List<ISymbol>	ModuleScope.getSymbolsAcrossModule()	THE symbols defined in this module across ALL of its source files - use this, never SymbolTable.getSymbolsForThisScope(), for any question about the whole module.
List<ISymbol>	IScope.getSymbolsForThisScope()	Provide a list of all the parameters held in this scope and only this scope.
List<ISymbol>	ScopedSymbol.getSymbolsForThisScope()
List<ISymbol>	SymbolTable.getSymbolsForThisScope()	Get all the symbols in this table.
List<ISymbol>	SymbolTable.getSymbolsForThisScopeOfCategory(SymbolCategory category)	Find symbols in a specific category.
Optional<ISymbol>	AggregateSymbol.getType()
Optional<ISymbol>	FunctionSymbol.getType()
Optional<ISymbol>	ISymbol.getType()
Optional<ISymbol>	Symbol.getType()
List<ISymbol>	ICanBeGeneric.getTypeParameterOrArguments()
List<ISymbol>	PossibleGenericSymbol.getTypeParameterOrArguments()
Optional<ISymbol>	ModuleScope.referencedByModule(String moduleName, String shortName)	DIAGNOSTIC ONLY - never a resolution route: a qualified name resolves only to what its module defines.
Optional<ISymbol>	IScope.resolve(SymbolSearch search)	Find the nearest symbol of that name up the scope tree.
Optional<ISymbol>	MethodSymbol.resolve(SymbolSearch search)
Optional<ISymbol>	ModuleScope.resolve(SymbolSearch search)
Optional<ISymbol>	PossibleGenericSymbol.resolve(SymbolSearch search)	So this is where we alter the mechanism of normal symbol resolution.
Optional<ISymbol>	ScopedSymbol.resolve(SymbolSearch search)
Optional<ISymbol>	StackConsistencyScope.resolve(SymbolSearch search)
Optional<ISymbol>	SymbolTable.resolve(SymbolSearch search)	Search and resolve from a symbol search.
protected Optional<ISymbol>	SymbolTable.resolveByShortName(SymbolSearch search, String shortName)	SymbolTable.resolveInThisScopeOnly(SymbolSearch) for a caller that has ALREADY established the search is for this scope and holds its unqualified name - ModuleScope, which otherwise had both re-derived on every module-scope hop.
Optional<ISymbol>	CaptureScopedSymbol.resolveExcludingCapturedVariables(SymbolSearch search)
Optional<ISymbol>	ICanCaptureVariables.resolveExcludingCapturedVariables(SymbolSearch search)	Try and resolve a symbol but exclude looking in captured variables.
Optional<ISymbol>	StackConsistencyScope.resolveExcludingCapturedVariables(SymbolSearch search)
Optional<ISymbol>	PossibleGenericSymbol.resolveFromParameterTypes(SymbolSearch search)	Used when the type/function is one that is generic/template.
Optional<ISymbol>	ModuleScope.resolveInThisModuleOnly(SymbolSearch search)	Looks to resolve search in either the references held or the symbols in all the scopes for this module.
Optional<ISymbol>	CaptureScopedSymbol.resolveInThisScopeOnly(SymbolSearch search)
Optional<ISymbol>	FunctionSymbol.resolveInThisScopeOnly(SymbolSearch search)
Optional<ISymbol>	IScope.resolveInThisScopeOnly(SymbolSearch search)	Just look in own scope.
Optional<ISymbol>	MethodSymbol.resolveInThisScopeOnly(SymbolSearch search)
Optional<ISymbol>	ModuleScope.resolveInThisScopeOnly(SymbolSearch search)	Just does a search in this particular module scope.
Optional<ISymbol>	PossibleGenericSymbol.resolveInThisScopeOnly(SymbolSearch search)
Optional<ISymbol>	ScopedSymbol.resolveInThisScopeOnly(SymbolSearch search)
Optional<ISymbol>	StackConsistencyScope.resolveInThisScopeOnly(SymbolSearch search)
Optional<ISymbol>	SymbolTable.resolveInThisScopeOnly(SymbolSearch search)	Resolve a symbol in this symbol table only.
Optional<ISymbol>	AggregateSymbol.resolveMember(SymbolSearch search)	Just try and resolve a member in this or super scopes.
Optional<ISymbol>	AggregateWithTraitsSymbol.resolveMember(SymbolSearch search)
default Optional<ISymbol>	IAggregateSymbol.resolveMember(SymbolSearch search)	Just try and resolve a member in this or super scopes.
Optional<ISymbol>	IScope.resolveMember(SymbolSearch search)	Just resolve on this or supers/traits - but not anything outside of the class hierarchy.
Optional<ISymbol>	ScopedSymbol.resolveMember(SymbolSearch search)
Optional<ISymbol>	SymbolTable.resolveMember(SymbolSearch search)
Optional<ISymbol>	ModuleScope.resolveOrDefine(PossibleGenericSymbol parameterisedSymbol, SemanticErrorReporter errorListener)	Used when resolving or needing to define a parameterised type, like 'List of String' for example.
Optional<ISymbol>	ModuleScope.resolveReferenceInThisScopeOnly(SymbolSearch search)	Does a check if there is a references of that symbol already held in this module scope.
Optional<ISymbol>	CaptureScope.resolveWithEnclosingScope(SymbolSearch search)
Optional<ISymbol>	LocalScope.resolveWithEnclosingScope(SymbolSearch search)
Optional<ISymbol>	ModuleScope.resolveWithEnclosingScope(SymbolSearch search)
Optional<ISymbol>	SymbolTable.resolveWithEnclosingScope(SymbolSearch search)	This class is the root and so there is no enclosing scope.
Optional<ISymbol>	AggregateWithTraitsSymbol.resolveWithParentScope(SymbolSearch search)	Resolve using super aggregate and or any traits we have.
Optional<ISymbol>	FunctionSymbol.resolveWithParentScope(SymbolSearch search)	A function's body never resolves names through its super function - only through its enclosing scope.
Optional<ISymbol>	ScopedSymbol.resolveWithParentScope(SymbolSearch search)	Resolve with super type/function or via enclosing scope.

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

Modifier and Type	Method	Description
void	AggregateSymbol.addInjectionField(ISymbol field)	Record that a field on this aggregate is marked for injection.
void	ParamExpressionSymbol.addParameter(ISymbol symbol)
void	ICanBeGeneric.addTypeParameterOrArgument(ISymbol typeParameterOrArgument)
void	PossibleGenericSymbol.addTypeParameterOrArgument(ISymbol typeParameterOrArgument)	Add a parameter type to this scope.
MethodSymbol	MethodSymbol.clone(ISymbol withType, IScope withParentAsAppropriate)
void	AggregateSymbol.define(ISymbol symbol)
void	CaptureScope.define(ISymbol symbol)
void	IScope.define(ISymbol symbol)	Define a Symbol in this scope.
void	ModuleScope.define(ISymbol symbol)	Every module-level define invalidates any memoised "absent" that was answered from this module.
void	ScopedSymbol.define(ISymbol symbol)
void	SymbolTable.define(ISymbol symbol)
boolean	ModuleScope.defineOrError(ISymbol symbol, SymbolChecker symbolChecker)	Defines a new symbol and returns true if all when OK But if there were errors created then false is returned.
void	ModuleScope.defineReference(IToken token, ISymbol symbol)	Add a reference to another construct in another module, so it can be used in shorthand form in this module.
boolean	ModuleScope.errorsIfNameDiffersOnlyByCase(ISymbol symbol, SymbolChecker symbolChecker)	THE case-variant name check for module scope - call this from every path that defines a module-level construct, including any that bypasses ModuleScope.defineOrError(ISymbol, SymbolChecker) with a raw define.
double	AggregateWithTraitsSymbol.getAssignableCostTo(ISymbol s)
double	FunctionSymbol.getAssignableCostTo(ISymbol s)
double	ISymbol.getAssignableCostTo(ISymbol s)
double	Symbol.getAssignableCostTo(ISymbol s)
double	AggregateSymbol.getUnCoercedAssignableCostTo(ISymbol s)
double	AggregateWithTraitsSymbol.getUnCoercedAssignableCostTo(ISymbol s)
double	FunctionSymbol.getUnCoercedAssignableCostTo(ISymbol s)
double	ISymbol.getUnCoercedAssignableCostTo(ISymbol s)
double	Symbol.getUnCoercedAssignableCostTo(ISymbol s)
boolean	ISymbol.isAssignableTo(ISymbol s)
boolean	Symbol.isAssignableTo(ISymbol s)
boolean	ISymbol.isExactSameType(ISymbol symbolType)	If is the symbol is an exact match.
boolean	Symbol.isExactSameType(ISymbol symbolType)	Checks if the type match exactly.
boolean	ISymbol.isPromotionSupported(ISymbol s)	For some symbols we might support the _promote method via coercion.
boolean	Symbol.isPromotionSupported(ISymbol s)
void	StreamCallSymbol.setConsumesSymbolType(ISymbol consumesSymbolType)	This sets the type of symbol that stream can consume.
void	StreamCallSymbol.setProducesSymbolType(ISymbol producesSymbolType)	This sets the type of symbol that stream can produce.
ISymbol	FunctionSymbol.setType(ISymbol type)
default ISymbol	ISymbol.setType(ISymbol type)

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

Modifier and Type	Method	Description
protected String	FunctionSymbol.doGetFriendlyName(String withName, Optional<ISymbol> theType)
protected String	MethodSymbol.doGetFriendlyName(String withName, Optional<ISymbol> theType)
double	ISymbol.getAssignableCostTo(Optional<ISymbol> s)
double	Symbol.getAssignableCostTo(Optional<ISymbol> s)
protected String	Symbol.getSymbolTypeAsString(Optional<ISymbol> type)
boolean	ISymbol.isAssignableTo(Optional<ISymbol> s)
boolean	Symbol.isAssignableTo(Optional<ISymbol> s)
boolean	MethodSymbol.isParameterSignatureMatchTo(List<ISymbol> params)	Very important method; that checks if the parameter list provided can match the parameters declared for this method.
boolean	FunctionSymbol.isSignatureMatchTo(Optional<ISymbol> theirReturnType, List<ISymbol> theirParams)	Check if the parameter types and return types match.
boolean	FunctionSymbol.isSignatureMatchTo(Optional<ISymbol> theirReturnType, List<ISymbol> theirParams)	Check if the parameter types and return types match.
void	MethodSymbol.setCallParameters(List<ISymbol> params)	Typically used when making synthetic methods you want to add in all the params from another method or something.
ISymbol	AggregateSymbol.setType(Optional<ISymbol> type)
ISymbol	FunctionSymbol.setType(Optional<ISymbol> type)
ISymbol	ISymbol.setType(Optional<ISymbol> type)
ISymbol	Symbol.setType(Optional<ISymbol> type)

Constructors in org.ek9lang.compiler.symbols with parameters of type ISymbol

Modifier	Constructor	Description
	ConstantSymbol(String name, ISymbol type)
	ConstantSymbol(String name, ISymbol type, boolean fromLiteral)
	Ek9Types(AnyTypeSymbol ek9Any, ISymbol ek9Void, ISymbol ek9Boolean, ISymbol ek9Integer, ISymbol ek9Float, ISymbol ek9String, ISymbol ek9Character, ISymbol ek9Bits, ISymbol ek9Date, ISymbol ek9DateTime, ISymbol ek9Time, ISymbol ek9Duration, ISymbol ek9Json, ISymbol ek9Millisecond, ISymbol ek9Path, ISymbol ek9Version, ISymbol ek9HttpRequest, ISymbol ek9HttpResponse, ISymbol ek9HttpContext, ISymbol ek9Exception, ISymbol ek9Panic, ISymbol ek9List, ISymbol ek9Set, ISymbol ek9PriorityQueue, ISymbol ek9MutexLock, ISymbol ek9MutexKey, ISymbol ek9Tcp, ISymbol ek9Signals, ISymbol ek9Iterator, ISymbol ek9Optional, ISymbol ek9Dictionary, ISymbol ek9DictionaryEntry, ISymbol ek9Result, ISymbol ek9Supplier, ISymbol ek9Consumer, ISymbol ek9Function, ISymbol ek9Routine, ISymbol ek9UnaryOperator, ISymbol ek9Predicate, ISymbol ek9Comparator, ISymbol ek9IO, ISymbol ek9Sensitive, ISymbol ek9Privileged, ISymbol ek9Stdin, ISymbol ek9Stdout, ISymbol ek9Stderr, ISymbol ek9Udp, ISymbol ek9TcpConnection, ISymbol ek9Locale)	Creates an instance of a Ek9Types record class.
	ExpressionSymbol(ISymbol symbol)	Create a new expression based around an existing symbol.
	MethodSymbol(String name, ISymbol type, IScope enclosingScope)	Typically used for cloning constructors.
	RegistrationData(ISymbol implementationSymbol, ISymbol interfaceSymbol, List<ISymbol> aspectSymbols, IToken sourceToken)	Creates an instance of a RegistrationData record class.
	VariableSymbol(String name, ISymbol type)

Constructor parameters in org.ek9lang.compiler.symbols with type arguments of type ISymbol

Modifier	Constructor	Description
	AggregateSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)	A simple straight forward aggregate type, like a class or record.
	AggregateSymbol(String name, IScope enclosingScope, List<ISymbol> typeParameterOrArguments)	An aggregate that can be parameterised, i.e.
	AggregateWithTraitsSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	CaptureScopedSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	ConstantSymbol(String name, Optional<ISymbol> type)
	ConstantSymbol(String name, Optional<ISymbol> type, boolean fromLiteral)	Construction of a Constant.
	MethodSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)	Create new method symbol of a specific name with an enclosing scope (i.e.
	PossibleGenericSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	RegistrationData(ISymbol implementationSymbol, ISymbol interfaceSymbol, List<ISymbol> aspectSymbols, IToken sourceToken)	Creates an instance of a RegistrationData record class.
	ScopedSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	ServiceOperationSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	Symbol(String name, Optional<ISymbol> type)
	VariableSymbol(String name, Optional<ISymbol> type)