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	Test if a symbol is externally implemented.
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	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)
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.
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.
boolean	SymbolsAndScopes.isErrorResultAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isGetOptionalAccessSafe(ISymbol identifierSymbol)
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.
boolean	SymbolsAndScopes.isNextIteratorAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isOkResultAccessSafe(ISymbol identifierSymbol)
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	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	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) 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	IsPropertyOfAggregate	Given an aggregate and a symbol, this predicate checks if the symbol is a property/field of that aggregate.
(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	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	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	SetTypeFromReturningParam.accept(ISymbol symbol, EK9Parser.ReturningParamContext ctx)
void	SymbolReferencedOrError.accept(ISymbol symbol)
void	TraitAccessibleOrError.accept(org.antlr.v4.runtime.Token errorLocation, ISymbol symbol)
Optional<PossibleGenericSymbol>	SymbolTypeOrEmpty.apply(ISymbol symbol)
(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) boolean	CaptureEvaluationScope.isAccessibleWhereEvaluated(org.antlr.v4.runtime.tree.ParseTree node, ISymbol propertyField)	True when the code that evaluates node holds the property field (a capture or an own property).
(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 '#^'.
(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	IsPropertyOfAggregate.test(IAggregateSymbol aggregate, ISymbol possibleProperty)
boolean	IsSetPresentOrError.test(IToken operatorUse, ISymbol symbol)
boolean	OperatorTest.test(IToken operatorUse, ISymbol symbol)
boolean	VoidTypeOrError.test(ISymbol symbol)	Test if the symbol has a Void type.
(package private) boolean	IsConvertableToStringOrError.testAndSetFlags(IToken errorReportingLocation, ISymbol typeSymbol, ExpressionSymbol expressionSymbol)	Test if the type can be converted to String and optionally set flags on the expression symbol.
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)	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

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

Modifier	Constructor	Description
(package private)	ParameterisedTypeOrError(ISymbol ek9Any, ErrorListener errorListener, Map<IAggregateSymbol, List<MethodSymbol>> accessedMethodsByT)	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	ConstrainedConstructionResolver.Site.constructorParamType()	Returns the value of the constructorParamType record component.
ISymbol	SafeAccessConjuncts.Proof.symbol()	Returns the value of the symbol record component.
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.
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)
int	InheritanceDepthCalculator.applyAsInt(ISymbol symbol)	Calculate the inheritance depth for a symbol.
protected void	AbstractSafeSymbolMarker.assessIsSetCall(ISymbol toBeAssessed, IScope scopeMadeSafe)
(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.
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).
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	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) 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.
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) 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) 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)	HasTypeOfGeneric(ISymbol matchType)	Constructor to check if symbol has a type that matches the use of the match generic type.
(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)	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 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)
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.recordMayValues(ISymbol symbol, Set<Object> values)	Record that symbol's value is not known exactly, but is one of values.
void	ValueTrackingAnalyzer.recordUnknownAssignment(ISymbol symbol)
void	ValueTrackingAnalyzer.registerModuleConstant(ISymbol symbol, AbstractValue abstractValue)	Register a module-level constant (from defines constant blocks).
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.
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.

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.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 and manage memory.
(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) String	Scenario2WrapperHelper.generateVirtualCall(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 on a target and manage its result as a BORROW (RETAIN + SCOPE_REGISTER).
(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.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.

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.

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

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

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.

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 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	TerminalSetup.consumesType()	Returns the value of the consumesType record component.
(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)
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, 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) List<IRInstr>	RangeIterationHelper.generateBodySetup(String loopVariableName, String currentTemp, ISymbol rangeType, DebugInfo debugInfo)	Generate body setup: loopVariable becomes a FRESH per-iteration value copied from the counter.
(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.
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.
List<IRInstr>	TeeStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType)
(package private) List<IRInstr>	UniqStageWrapper.wrap(StageWrapParams params, String pipelineItemVar, ISymbol elementType, StageState stageState)
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, List<IRInstr> innerBody, String pipelineItemVar, ISymbol elementType, DebugInfo debugInfo, List<StageState> stageStates)	Wrap inner body instructions with intermediate pipeline stages in reverse order.
(package private) StageWrapResult	StreamStageDispatcher.wrapWithStages(List<EK9Parser.StreamPartContext> stages, 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, 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, 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 startTemp, String endTemp, String byTemp, String directionTemp, String currentTemp, ISymbol rangeType, ISymbol byType)	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, boolean promotionRequired)	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?
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 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.

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

Modifier and Type	Method	Description
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.

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.

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.

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	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	RecordedSymbols.Reference.symbol()	Returns the value of the symbol record component.
ISymbol	ReferenceAssignment.target()	Returns the value of the target 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>	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>	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>	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 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.
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.

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

Modifier and Type	Method	Description
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.
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 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 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.
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 Optional<MethodSymbol>	Sameness.inheritedSameness(IAggregateSymbol aggregate, ISymbol ek9Any)	The concrete sameness this type INHERITS - from its super chain (stopping before Any) or any of its traits (its own, a super's, a trait's trait) - if any.
static 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	CapturedVariables.isCaptureOf(ISymbol candidate, ICanCaptureVariables capturer)	True when candidate is, by identity, one of the variables capturer captured.
static boolean	TypeCoercions.isCoercible(ISymbol from, ISymbol to)	Can the 'from' token type be coerced to the 'to' type.
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	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	TargetTypedConstruction.isMarked(ISymbol recordedCall)	Was this call completed from its declared target.
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	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	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	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	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	TargetTypedConstruction.mark(ISymbol recordedCall)	Record that this call was completed from its declared target.
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 boolean	PolymorphicCopy.needsCopyAccepts(IAggregateSymbol owner, ISymbol ek9Any)	Does the owner get a _copyAccepts? Only where one can be asked.
ExpressionSymbol	SymbolFactory.newExpressionSymbol(ISymbol fromSymbol)	Create a new expression around a symbol.
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 int	MeasuredComplexity.of(ISymbol symbol)	The symbol's measured complexity, or 0 when it was never measured (or is unparseable).
static ErrorListener	OwningErrorListener.of(ISymbol symbol, ErrorListener fallback)	The error listener of the source that declares symbol, or fallback if it has none.
static Optional<PossibleGenericSymbol>	TargetTypedConstruction.parameterisationOf(ISymbol generic, ISymbol target)	THE strict condition: the target type is a parameterisation of exactly this generic (not a sub or super type).
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 void	MeasuredComplexity.record(ISymbol symbol, int complexity)	Record a complexity against a symbol that phase 5 will never visit.
static void	ClonedMemberRetyping.retypeOne(ISymbol value, UnaryOperator<ISymbol> replacement)	Re-type a single symbol, in place, when it has a type.
static boolean	CopyConstructor.takesExactlyOne(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<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 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.
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.
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.
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 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)
	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.

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)
	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)