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
org.ek9lang.compiler.ir.support
org.ek9lang.compiler.phase1	E - Initial Symbol definition by traversing the 'ANTLR' - 'AST'.
org.ek9lang.compiler.phase2	F - Resolution of Explicitly Defined Type Symbols - at this point phase3 processing should have defined most of the explicitly defined symbols, so they should be resolvable.
org.ek9lang.compiler.phase3	G - Full Symbol Resolution can now take place.
org.ek9lang.compiler.phase4	H - Generic/Parameterised types can have their methods checked when used in specific contexts.
org.ek9lang.compiler.phase5	I - PRE Intermediate Representation generation checks.
org.ek9lang.compiler.phase7	K - Intermediate Representation Generation.
org.ek9lang.compiler.phase7.calls
org.ek9lang.compiler.phase7.generation
org.ek9lang.compiler.phase7.generator
org.ek9lang.compiler.phase7.support
org.ek9lang.compiler.search	Used primarily to hold structures that are related to searching for symbols.
org.ek9lang.compiler.support	Contains critical general components used in the Ek9Compiler listeners.
org.ek9lang.compiler.symbols	This is the main source of EK9 Symbols used within the compiler.

Uses of ISymbol in org.ek9lang.compiler

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>	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	Defaulted	Test if a symbol is externally implemented.
final class	ExternallyImplemented	Test if a symbol is externally implemented.
final class	LhsFromPreFlowOrError	Access the Symbol for the lhs of the preflow statement.
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)

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

Modifier and Type	Method	Description
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, ErrorListener errorListener)
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)
boolean	CodeFlowAnalyzer.doesSymbolMeetAcceptableCriteria(ISymbol identifierSymbol, IScope inScope)
boolean	CodeFlowMap.doesSymbolMeetAcceptableCriteria(ISymbol identifierSymbol, IScope inScope)	Check if a variable meets the criteria of being acceptable.
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.
boolean	SymbolsAndScopes.isErrorResultAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isGetOptionalAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isNextIteratorAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isOkResultAccessSafe(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isSymbolAccessSafe(ISymbol identifierSymbol)	true if identifier is safe to access.
boolean	SymbolsAndScopes.isVariableInitialised(ISymbol identifierSymbol)
boolean	SymbolsAndScopes.isVariableInitialised(ISymbol identifierSymbol, IScope inScope)
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	Defaulted.test(ISymbol symbol)
boolean	ExternallyImplemented.test(ISymbol symbol)
boolean	UninitialisedVariableToBeChecked.test(ISymbol symbol)

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)

Uses of ISymbol in org.ek9lang.compiler.directives

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

Modifier and Type	Method	Description
protected void	ByteCodeDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	ComplexityDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	GenusDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective resolutionDirective, ISymbol symbol)
protected void	ImplementsDirectiveListener.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 abstract void	ResolutionDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective directive, ISymbol symbol)
protected void	ResolvedDirectiveListener.symbolMatch(CompilationEvent compilationEvent, ResolutionDirective directive, 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 with parameters of type ISymbol

Modifier and Type	Method	Description
boolean	IRConstruct.isForSymbol(ISymbol toCheck)

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 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 methods are 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	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	SuitableGenusOrError	Checks for a type is resolved and is suitable genus and category.
(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>	SuitableGenusOrError.apply(org.antlr.v4.runtime.ParserRuleContext ctx)
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	HttpAccessOrError.accept(ISymbol param)
void	NotGenericTypeParameterOrError.accept(ISymbol variable)
void	PopulateConstrainedTypeOrError.accept(AggregateSymbol newType, ISymbol constrainedType)
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) 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	Typically used when a direct call is being bad on the symbol.
(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.

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	CovarianceData.fromVar()	Returns the value of the fromVar record component.
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>	DelegateFunctionData.callArgumentTypes()	Returns the value of the callArgumentTypes record component.
List<ISymbol>	FunctionData.callArgumentTypes()	Returns the value of the callArgumentTypes record component.
List<ISymbol>	ParametersData.from()	Returns the value of the from record component.
protected Optional<ISymbol>	OperatorTest.getSymbolType(ISymbol symbol)
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)
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)
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)
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)

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)	Creates an instance of a CheckOperatorData record class.
(package private)	CovarianceData(IToken token, 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)	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)	ParametersData(IToken token, String errorMessage, List<ISymbol> from, List<ISymbol> to)	Creates an instance of a ParametersData 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)

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	GetGuardVariable	Extracts the guard variable if there is a guard expression.
(package private) final class	HasTypeOfGeneric
(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 types with arguments of type ISymbol

Modifier and Type	Method	Description
Optional<ISymbol>	GetGuardVariable.apply(EK9Parser.PreFlowStatementContext ctx)
protected Optional<ISymbol>	PossibleExpressionConstruct.getGuardExpressionVariable(EK9Parser.PreFlowAndControlContext ctx)
protected Optional<ISymbol>	PossibleExpressionConstruct.getGuardExpressionVariable(EK9Parser.PreFlowStatementContext ctx)

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

Modifier and Type	Method	Description
void	SafeGenericAccessMarker.accept(ISymbol symbol)
void	SafeSymbolMarker.accept(ISymbol symbol, IScope scope)
protected void	AbstractSafeSymbolMarker.assessIsSetCall(ISymbol toBeAssessed, IScope scopeMadeSafe)
protected boolean	SafeSymbolAccess.isAccessUnSafe(ISymbol calledFromSymbol, String methodName)
protected boolean	PossibleExpressionConstruct.isVariableInitialisedInScopes(CodeFlowAnalyzer analyzer, ISymbol variable, List<IScope> scopes)
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.
boolean	HasTypeOfGeneric.test(ISymbol symbol)
boolean	SafeGenericAccessPredicate.test(ISymbol symbol)

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

Modifier	Constructor	Description
(package private)	HasTypeOfGeneric(ISymbol matchType)	Constructor to check if symbol has a type that matches the use of the match generic type.

Uses of ISymbol in org.ek9lang.compiler.phase7

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

Modifier and Type	Method	Description
protected void	AbstractDfnGenerator.createInitOperation(IRConstruct construct, IScope aggregateSymbol, ISymbol superType)	Create c_init operation for class/static initialization.
protected void	AbstractDfnGenerator.processAsMethodOrOperator(IRConstruct construct, ISymbol symbol, EK9Parser.OperationDetailsContext ctx)

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

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

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

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

Modifier and Type	Method	Description
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)
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.forUnaryOperation(ISymbol targetType, String methodName, String targetVariable, ISymbol returnType, String scopeId)	Create context for unary operation: target.method()

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

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

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)	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)	Creates an instance of a CallContext record class.

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

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.

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
protected ISymbol	AbstractGenerator.extractReturnType(org.antlr.v4.runtime.tree.ParseTree ctx, ISymbol fallbackSymbol)	Extract return type from a CallSymbol's resolved method.
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	SwitchStatementGenerator.EvalVariable.typeSymbol()	Returns the value of the typeSymbol 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)
protected ISymbol	AbstractGenerator.extractReturnType(org.antlr.v4.runtime.tree.ParseTree ctx, ISymbol fallbackSymbol)	Extract return type from a CallSymbol's resolved method.
List<IRInstr>	ControlFlowChainGenerator.generateGuardedAssignment(ISymbol lhsSymbol, List<IRInstr> assignmentEvaluation, String assignmentResult, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for guarded assignment (:=?).
List<IRInstr>	ControlFlowChainGenerator.generateQuestionOperatorForVariable(ISymbol variableSymbol, String resultVariable, DebugInfo debugInfo)	Generate SWITCH_CHAIN_BLOCK for Question operator applied to a variable.

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

Modifier	Constructor	Description
	EvalVariable(String name, String type, ISymbol typeSymbol)	Creates an instance of a EvalVariable 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.
class	NotImplicitSuper	Checks if the ISymbol as a type passed in is deemed to be an implicit super.
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	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	GuardedAssignmentDetails.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.

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.

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

Modifier and Type	Method	Description
void	FieldCreator.accept(ISymbol symbol)
String	VariableNameForIR.apply(ISymbol symbol)
boolean	NotImplicitSuper.test(ISymbol symbol)

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

Modifier	Constructor	Description
	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.
	GuardedAssignmentDetails(ISymbol lhsSymbol, EK9Parser.AssignmentExpressionContext assignmentExpression)	Creates an instance of a GuardedAssignmentDetails record class.
	IncrementParams(String counterVar, String operator, ISymbol counterType, String incrementResultTemp, 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.
	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.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.
class	CommonTypeOrError	Attempts to find a common type from the CommonTypeDeterminationDetails or issues errors.
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.
class	LocationExtractorFromSymbol	Extracts a string for the form "on line 6 in 'filename.ek9'".
class	NoNameCollisionOrError	Designed to check if variable name and method names collide with Type/Function names.
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	ParameterisedTypeData.genericTypeSymbol()	Returns the value of the genericTypeSymbol record component.

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

Modifier and Type	Method	Description
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.
protected Consumer<ISymbol>	CommonFactory.getDefaultOperatorInitializer(IToken startToken)
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.
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.

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.
Optional<GenericInGenericData>	AccessGenericInGeneric.apply(ISymbol typeDef)
String	LocationExtractorFromSymbol.apply(ISymbol symbol)
Optional<ISymbol>	ReturnTypeExtractor.apply(ISymbol symbol)
protected void	CommonFactory.configureSymbol(ISymbol symbol, IToken start)
protected List<AggregateSymbol>	CommonFactory.createAndRegisterParameterisedSymbols(EK9Parser.ParameterisedParamsContext ctx, ISymbol functionOrClass, IScope scope)
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 boolean	TypeCoercions.isCoercible(ISymbol from, ISymbol to)	Can the 'from' token type be coerced to the 'to' type.
ExpressionSymbol	SymbolFactory.newExpressionSymbol(ISymbol fromSymbol)	Create a new expression around a symbol.
boolean	NoNameCollisionOrError.test(IScope inScope, ISymbol symbol)	Check for exising symbol in the scope.
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)

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)
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.
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.
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)
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
	ParameterisedTypeData(IToken location, ISymbol genericTypeSymbol, List<ISymbol> typeArguments)	Creates an instance of a ParameterisedTypeData record class.
	ToCommaSeparated(ISymbol fromType, boolean includeParenthesis)

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

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	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.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.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.ek9Millisecond()	Returns the value of the ek9Millisecond record component.
ISymbol	Ek9Types.ek9Optional()	Returns the value of the ek9Optional 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.ek9Result()	Returns the value of the ek9Result record component.
ISymbol	Ek9Types.ek9Routine()	Returns the value of the ek9Routine 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.ek9Time()	Returns the value of the ek9Time 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	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>	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.
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.
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>	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.
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, ErrorListener 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>	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	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	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.
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 ek9Date, ISymbol ek9DateTime, ISymbol ek9Time, ISymbol ek9Duration, ISymbol ek9Json, ISymbol ek9Millisecond, ISymbol ek9Path, ISymbol ek9Version, ISymbol ek9HttpRequest, ISymbol ek9HttpResponse, ISymbol ek9Exception, ISymbol ek9List, 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)	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.
	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)
	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)