Class PossibleGenericSymbol

java.lang.Object

org.ek9lang.compiler.symbols.Symbol

org.ek9lang.compiler.symbols.ScopedSymbol

org.ek9lang.compiler.symbols.CaptureScopedSymbol

org.ek9lang.compiler.symbols.PossibleGenericSymbol

All Implemented Interfaces:

Serializable, ICanBeGeneric, ICanCaptureVariables, IScope, IScopedSymbol, ISymbol, ISymbolNature, ITokenReference

Direct Known Subclasses:

AggregateSymbol, FunctionSymbol

public class PossibleGenericSymbol
extends CaptureScopedSymbol
implements ICanBeGeneric

Added as a common symbol type for both Functions and Aggregates that could possibly be generic in nature and also be a parameterised type. This is quite (very) complex, as in ek9 both classes and functions can be: A 'GenericType' Have 'Type Parameters' Can be 'Parameterised Types' through the use of 'Type Arguments' This can result in 'Parameterised Types' actually still being a 'GenericType'. It's hard to get your (mine) head around all this.

See Also:

• Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface IScope

IScope.ScopeType

Constructor Summary

Constructors

Constructor	Description
PossibleGenericSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
PossibleGenericSymbol(String name, IScope enclosingScope)

Method Summary

Modifier and Type	Method	Description
void	addGenericSymbolReference(PossibleGenericSymbol genericSymbolReference)	Add a reference to a parameterised function.
void	addTypeParameterOrArgument(ISymbol typeParameterOrArgument)	Add a parameter type to this scope.
ScopedSymbol	clone(IScope withParentAsAppropriate)	Clone the symbol and re-parent if this symbol like a method should have a parent.
protected PossibleGenericSymbol	cloneIntoPossibleGenericSymbol(PossibleGenericSymbol newCopy)
boolean	equals(Object o)	Two symbols are the same symbol when they agree on name, category, genus, mutability AND the declaration site they came from.
List<ISymbol>	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.
protected String	getAnyGenericParamsAsFriendlyNames()
Optional<org.antlr.v4.runtime.ParserRuleContext>	getDefinitionContext()	Get the definition context (AST node) for this generic type.
String	getFriendlyName()	Provide the name an end user would need to see on the screen.
List<PossibleGenericSymbol>	getGenericSymbolReferences()	Used to keep track of any generic types/functions used in a generic type that use some or all of the generic type parameters or arguments.
Optional<PossibleGenericSymbol>	getGenericType()	Not only can a class/function that implements this interface be generic in nature, they can also be a 'parameterised type'.
List<ISymbol>	getTypeParameterOrArguments()
int	hashCode()	Mixes in exactly the fields Symbol.equals(Object) compares, and nothing else.
boolean	isConceptualTypeParameter()	Is this itself a 'conceptual' type.
boolean	isGenericInNature()	Is this symbol a type that is generic in nature i.e.
boolean	isOpenForExtension()	Is the symbol open for extension or not.
boolean	isParameterisedType()	So just to add to the confusion.
Optional<ISymbol>	resolve(SymbolSearch search)	So this is where we alter the mechanism of normal symbol resolution.
Optional<ISymbol>	resolveFromParameterTypes(SymbolSearch search)	Used when the type/function is one that is generic/template.
Optional<ISymbol>	resolveInThisScopeOnly(SymbolSearch search)	Just look in own scope.
void	setConceptualTypeParameter(boolean conceptualTypeParameter)	Set this type symbol to be conceptual in nature.
void	setDefinitionContext(org.antlr.v4.runtime.ParserRuleContext ctx)	Set the definition context (AST node) for this generic type.
void	setGenericType(Optional<PossibleGenericSymbol> genericType)	Used parameterizing a generic type with type arguments.
void	setGenericType(PossibleGenericSymbol genericType)
void	setOpenForExtension(boolean open)

Methods inherited from class CaptureScopedSymbol

cloneIntoCaptureScopedSymbol, getCapturedVariables, getModuleScope, getPrivateVariablesForDisplay, isMarkedAbstract, resolveExcludingCapturedVariables, setCapturedVariables, setCapturedVariables, setCapturedVariablesVisibility, setMarkedAbstract, setModuleScope

Methods inherited from class ScopedSymbol

cloneIntoScopeSymbol, copyScopedSymbolProperties, define, findNearestDynamicBlockScopeInEnclosingScopes, findNearestNonBlockScopeInEnclosingScopes, getActualScope, getAllSymbolsMatchingName, getAnySuperTypeOrFunction, getEnclosingScope, getEncounteredExceptionToken, getFriendlyScopeName, getOuterMostTypeOrFunction, getScopeName, getScopeType, getSymbolsForThisScope, isMarkedPure, isMutable, isNotMarkedPure, isScopeAMatchForEnclosingScope, isTerminatedNormally, resolveMatchingMethods, resolveMatchingMethodsInThisScopeOnly, resolveMember, resolveWithParentScope, setEncounteredExceptionToken, setMarkedPure, setOuterMostTypeOrFunction, setScopeType

Methods inherited from class Symbol

clearInitialisedBy, cloneIntoSymbol, copySymbolProperties, getAssignableCostTo, getAssignableCostTo, getCategory, getFullyQualifiedName, getGenus, getInitialisedBy, getName, getParsedModule, getProduceFullyQualifiedName, getSourceToken, getSquirrelledData, getSymbolTypeAsString, getType, getUnCoercedAssignableCostTo, isAssignableTo, isAssignableTo, isDevSource, isEk9Core, isExactSameType, isInjectionExpected, isLibSource, isNullAllowed, isPromotionSupported, isReferenced, putSquirrelledData, setCategory, setEk9Core, setGenus, setInitialisedBy, setInjectionExpected, setName, setNotMutable, setNullAllowed, setParsedModule, setProduceFullyQualifiedName, setReferenced, setSourceToken, setType, toString

Methods inherited from class Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface ISymbol

clearInitialisedBy, getAssignableCostTo, getAssignableCostTo, getFullyQualifiedName, getInitialisedBy, getName, getParsedModule, getSourceToken, getSquirrelledData, getType, getUnCoercedAssignableCostTo, isAssignableTo, isAssignableTo, isDeclaredAsConstant, isDevSource, isExactSameType, isExtensionOfInjectable, isFromLiteral, isIncomingParameter, isInitialised, isInjectable, isInjectionExpected, isLibSource, isLoopVariable, isMarkedAbstract, isMarkedPure, isMutable, isNullAllowed, isPrivate, isPromotionSupported, isPropertyField, isProtected, isPublic, isReferenced, isReturningParameter, putSquirrelledData, setInitialisedBy, setInjectionExpected, setName, setNotMutable, setNullAllowed, setParsedModule, setReferenced, setType, setType

Methods inherited from interface ISymbolNature

getCategory, getGenus, isApplication, isConstant, isControl, isEk9Core, isFunction, isMethod, isPrimitiveType, isTemplateFunction, isTemplateType, isType, isVariable, setGenus

Methods inherited from interface ITokenReference

setSourceToken

Constructor Details

PossibleGenericSymbol

public PossibleGenericSymbol(String name,
 IScope enclosingScope)

PossibleGenericSymbol

public PossibleGenericSymbol(String name,
 Optional<ISymbol> type,
 IScope enclosingScope)

Method Details

clone

public ScopedSymbol clone(IScope withParentAsAppropriate)

Description copied from interface: ISymbol

Clone the symbol and re-parent if this symbol like a method should have a parent. Other symbols like VariableSymbols are un-parented

Specified by:

clone in interface IScope

Specified by:

clone in interface IScopedSymbol

Specified by:

clone in interface ISymbol

Overrides:

clone in class CaptureScopedSymbol

cloneIntoPossibleGenericSymbol

protected PossibleGenericSymbol cloneIntoPossibleGenericSymbol(PossibleGenericSymbol newCopy)

isParameterisedType

public boolean isParameterisedType()

Description copied from interface: ISymbolNature

So just to add to the confusion. A type that has been used with a type that is generic in nature with some parameters. So this would normally result in a type that is now concrete. i.e. List (generic in nature) and String (concrete) so this resulting type 'List of String' isAParameterisedType=true and isGenericInNature=false. But if List were parameterised with another generic parameter it would still be of a generic nature. For example, consider List T and Iterator I when we defined List T and use the Iterator with it; we parameterise Iterator with 'T'. But they are still both 'isGenericTypeParameter' it only when we use List (and by implication Iterator) with String do they both stop being generic in nature.

Specified by:

isParameterisedType in interface ISymbolNature

Returns:

true if a parameterised type (note parameterised not just of a generic nature).

getGenericType

public Optional<PossibleGenericSymbol> getGenericType()

Description copied from interface: ICanBeGeneric

Not only can a class/function that implements this interface be generic in nature, they can also be a 'parameterised type'.

Specified by:

getGenericType in interface ICanBeGeneric

setGenericType

public void setGenericType(Optional<PossibleGenericSymbol> genericType)

Used parameterizing a generic type with type arguments.

setGenericType

public void setGenericType(PossibleGenericSymbol genericType)

isGenericInNature

public boolean isGenericInNature()

Description copied from interface: ISymbolNature

Is this symbol a type that is generic in nature i.e. can it be parameterised with types. Aggregate Symbols can be defined to accept one or more parameters ie S and T.

Specified by:

isGenericInNature in interface ISymbolNature

isOpenForExtension

public boolean isOpenForExtension()

Description copied from interface: ICanBeGeneric

Is the symbol open for extension or not. Typically, this means a function is open/abstract and therefore can/must be extended. The same with classes and components.

Specified by:

isOpenForExtension in interface ICanBeGeneric

setOpenForExtension

public void setOpenForExtension(boolean open)

isConceptualTypeParameter

public boolean isConceptualTypeParameter()

Is this itself a 'conceptual' type.

Specified by:

isConceptualTypeParameter in interface ISymbolNature

setConceptualTypeParameter

public void setConceptualTypeParameter(boolean conceptualTypeParameter)

Set this type symbol to be conceptual in nature.

getGenericSymbolReferences

public List<PossibleGenericSymbol> getGenericSymbolReferences()

Description copied from interface: ICanBeGeneric

Used to keep track of any generic types/functions used in a generic type that use some or all of the generic type parameters or arguments. For example a 'List of type T' might use or return an 'Iterator of type T'. It is the 'Iterator' that would be a generic symbol reference.

Specified by:

getGenericSymbolReferences in interface ICanBeGeneric

addGenericSymbolReference

public void addGenericSymbolReference(PossibleGenericSymbol genericSymbolReference)

Add a reference to a parameterised function. I'm still in two minds about adding these references. Leave as is at the moment, and then see what I think later on.

Specified by:

addGenericSymbolReference in interface ICanBeGeneric

addTypeParameterOrArgument

public void addTypeParameterOrArgument(ISymbol typeParameterOrArgument)

Add a parameter type to this scope.

Specified by:

addTypeParameterOrArgument in interface ICanBeGeneric

getFriendlyName

public String getFriendlyName()

Description copied from interface: ISymbol

Provide the name an end user would need to see on the screen. Normally this is just 'getName' but in the case of Templates We use a very nasty internal naming for List of SomeClass - which will probably be something like _List_hashed_version_of_ComeClass and the end user needs to see 'List of SomeClass' for it to be meaningful.

Specified by:

getFriendlyName in interface ISymbol

Overrides:

getFriendlyName in class Symbol

Returns:

a user presentable of the symbol name.

getAnyGenericParamsAsFriendlyNames

protected String getAnyGenericParamsAsFriendlyNames()

getAnyConceptualTypeParameters

public List<ISymbol> 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.

Specified by:

getAnyConceptualTypeParameters in interface ICanBeGeneric

getTypeParameterOrArguments

public List<ISymbol> getTypeParameterOrArguments()

Specified by:

getTypeParameterOrArguments in interface ICanBeGeneric

resolveFromParameterTypes

public Optional<ISymbol> resolveFromParameterTypes(SymbolSearch search)

Used when the type/function is one that is generic/template. It will have a number of parameterTypes, these are 'T' and the like. The conceptual or concrete types.

resolveInThisScopeOnly

public Optional<ISymbol> resolveInThisScopeOnly(SymbolSearch search)

Description copied from interface: IScope

Just look in own scope.

Specified by:

resolveInThisScopeOnly in interface IScope

Overrides:

resolveInThisScopeOnly in class CaptureScopedSymbol

resolve

public Optional<ISymbol> resolve(SymbolSearch search)

So this is where we alter the mechanism of normal symbol resolution.

Specified by:

resolve in interface IScope

Overrides:

resolve in class ScopedSymbol

getDefinitionContext

public Optional<org.antlr.v4.runtime.ParserRuleContext> getDefinitionContext()

Get the definition context (AST node) for this generic type. Only present for generic types (isGenericInNature() == true) that were created from EK9 source code (not extern/built-in types).

Returns:

The ParserRuleContext (ClassDeclarationContext or FunctionDeclarationContext) where this generic type was defined, or empty if not available.

setDefinitionContext

public void setDefinitionContext(org.antlr.v4.runtime.ParserRuleContext ctx)

Set the definition context (AST node) for this generic type. Called during Phase 1 symbol definition when creating generic types from EK9 source.

Parameters:

ctx - The ParserRuleContext where this generic type was defined.

equals

public boolean equals(Object o)

Description copied from class: Symbol

Two symbols are the same symbol when they agree on name, category, genus, mutability AND the declaration site they came from.

The source token is part of identity deliberately. Name alone is not enough: symbol names are unqualified here, so two unrelated variables both called count, or two types called Foo in different modules, would otherwise compare equal. The compiler relies on telling those apart - CodeFlowMap keys initialisation state on Map<IScope, Map<ISymbol, SymbolAccess>>, and conflating two same-named declarations there makes flow analysis attribute one variable's initialisation to another.

That distinction used to be present ONLY in Symbol.hashCode(), which is why this looked like it worked: two same-named symbols compared equal yet hashed apart, so hash collections usually - but not reliably - kept them separate, while any direct equals call saw them as one. Encoding it here makes the two agree. See SymbolEqualsHashCodeContractTest.

Overrides:

equals in class CaptureScopedSymbol

hashCode

public int hashCode()

Description copied from class: Symbol

Mixes in exactly the fields Symbol.equals(Object) compares, and nothing else.

A hashCode may legitimately use FEWER fields than equals (that only causes collisions, which are correct), but never MORE: any extra field makes two symbols that compare equal land in different buckets, so a HashSet silently holds visible duplicates and a HashMap lookup misses an entry that is present. This method used to mix in purity, which no equals at THIS level consults - purity belongs in FunctionSymbol, the level whose equals compares it. The source token stays, and is now matched by Symbol.equals(Object). See SymbolEqualsHashCodeContractTest.

Overrides:

hashCode in class CaptureScopedSymbol