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

Packages that use IScope

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.phase1	E - Initial Symbol definition by traversing the 'ANTLR' - 'AST'.
org.ek9lang.compiler.phase3	G - Full Symbol Resolution can now take place.
org.ek9lang.compiler.phase5	I - PRE Intermediate Representation generation checks.
org.ek9lang.compiler.phase7	K - Intermediate Representation Generation.
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 IScope in org.ek9lang.compiler

Methods in org.ek9lang.compiler that return IScope

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

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

Modifier and Type	Method	Description
void	ParsedModule.recordScope(org.antlr.v4.runtime.tree.ParseTree node, IScope withScope)	Record a particular node context during listen/visit of a context with a particular scope.
void	ParsedModuleTransientData.recordScope(org.antlr.v4.runtime.tree.ParseTree node, IScope withScope)	Record a particular node context during listen/visit of a context with a particular scope.

Uses of IScope in org.ek9lang.compiler.common

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

Modifier and Type	Method	Description
IScope	SymbolsAndScopes.enterScope(org.antlr.v4.runtime.tree.ParseTree ctx)	Ensure that the correct scope is pushed on to the stack.
IScope	SymbolsAndScopes.getParentOfTopScope()
IScope	SymbolsAndScopes.getRecordedScope(org.antlr.v4.runtime.tree.ParseTree node)
IScope	SymbolsAndScopes.getTopScope()	Provides access to the top of the scope stack.
IScope	ScopeStack.getVeryBaseScope()
IScope	ScopeStack.peek()	Take a look at the top of the stack.
IScope	ScopeStack.pop()	Pop a scope of the stack (exception is empty.
IScope	ScopeStack.push(IScope scope)	Push a scope on to this stack.

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

Modifier and Type	Method	Description
Optional<IScope>	ScopeStack.traverseBackUpStack(IScope.ScopeType scopeType)	Navigates back up the scope stack to find the first match of the scope type passed in.
Optional<IScope>	SymbolsAndScopes.traverseBackUpStack(IScope.ScopeType scopeType)	Navigates back up the scope stack to find the first match of the scope type passed in.

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

Modifier and Type	Method	Description
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.enterNewScope(IScope scope, org.antlr.v4.runtime.tree.ParseTree node)	Enter a new scope and record in both the parsed module and push on to the working scope stack.
void	SymbolsAndScopes.enterScope(IScope scope)	To be used to ensure that a scope has been pushed on to the scopeStack.
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)
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.
IScope	ScopeStack.push(IScope scope)	Push a scope on to this stack.
void	SymbolsAndScopes.recordScopeForStackConsistency(IScope scope, org.antlr.v4.runtime.tree.ParseTree node)	There are times in parsing/listening when symbols are already defined (due to a developer error).
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.recordSymbolDeclaration(ISymbol identifierSymbol, IScope inScope)	Record variable declaration against a specific scope.

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

Modifier	Constructor	Description
	ScopeStack(IScope base)
	TypeDefResolver(IScope scopeForResolution)	Create new resolver.

Uses of IScope in org.ek9lang.compiler.phase1

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

Modifier and Type	Class	Description
(package private) final class	BuiltInTypeCacheResolver	Just resolves a number of built-in types so that internal compiler code can be more explicit.
(package private) final class	NormalTerminationOrError	Just check is a scope has normal termination.

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

Modifier and Type	Method	Description
void	NormalTerminationOrError.accept(IToken token, IScope scope)
Ek9Types	BuiltInTypeCacheResolver.apply(IScope scope)

Uses of IScope in org.ek9lang.compiler.phase3

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

Modifier and Type	Class	Description
(package private) final class	PropertyFieldOrError	Used for resolving and recoding of fields on specific types.

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

Modifier and Type	Method	Description
IScope	SymbolAccessData.fromScope()	Returns the value of the fromScope record component.
IScope	SymbolAccessData.inScope()	Returns the value of the inScope record component.

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

Modifier and Type	Method	Description
ISymbol	PropertyFieldOrError.apply(EK9Parser.IdentifierContext ctx, IScope scopeToResolveIn)

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

Modifier	Constructor	Description
(package private)	SymbolAccessData(IToken token, IScope fromScope, IScope inScope, String symbolName, ISymbol symbol)	Creates an instance of a SymbolAccessData record class.

Uses of IScope in org.ek9lang.compiler.phase5

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

Modifier and Type	Class	Description
(package private) class	ExpressionSafeSymbolMarker	Once an expression has been assessed as being simple enough to process, this consumer is called to mark the appropriate symbol(s) used in the expression as safe if the appropriate methods are called.
(package private) final class	ReturningVariableOrError	Checks if return variables are initialised.
(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 with parameters of type IScope

Modifier and Type	Method	Description
void	ExpressionSafeSymbolMarker.accept(EK9Parser.ExpressionContext ctx, IScope scopeMadeSafe)
void	ReturningVariableOrError.accept(IScope mainScope, EK9Parser.OperationDetailsContext ctx)
void	SafeSymbolMarker.accept(ISymbol symbol, IScope scope)
protected void	AbstractSafeSymbolMarker.assessIsSetCall(ISymbol toBeAssessed, IScope scopeMadeSafe)
protected void	AbstractSafeGenericAccessMarker.processExpression(EK9Parser.ExpressionContext ctx, IScope wouldBeSafeScope)
protected void	AbstractSafeGenericAccessMarker.processPreFlow(EK9Parser.PreFlowStatementContext ctx, IScope wouldBeSafeScope)
protected void	PossibleExpressionConstruct.pullUpAcceptableCriteriaToHigherScope(CodeFlowAnalyzer analyzer, List<IScope> allAppropriateBlocks, IScope outerScope)
protected void	PossibleExpressionConstruct.returningVariableValidOrError(EK9Parser.ReturningParamContext ctx, IScope constructScope, boolean noGuardExpression)

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

Modifier and Type	Method	Description
protected boolean	PossibleExpressionConstruct.isVariableInitialisedInScopes(CodeFlowAnalyzer analyzer, ISymbol variable, List<IScope> scopes)
protected void	PossibleExpressionConstruct.pullUpAcceptableCriteriaToHigherScope(CodeFlowAnalyzer analyzer, List<IScope> allAppropriateBlocks, IScope outerScope)

Uses of IScope in org.ek9lang.compiler.phase7

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

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.createInstanceInitOperation(IRConstruct construct, IScope symbol, EK9Parser.AggregatePartsContext ctx)	Create i_init operation for instance initialization.
protected OperationInstr	AbstractDfnGenerator.newSyntheticInitOperation(IScope scope, String methodName)

Uses of IScope in org.ek9lang.compiler.search

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

Modifier and Type	Method	Description
IScope	MethodSearchInScope.scopeToSearch()	Returns the value of the scopeToSearch record component.

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

Modifier	Constructor	Description
	MethodSearchInScope(IScope scopeToSearch, MethodSymbolSearch search)	Creates an instance of a MethodSearchInScope record class.

Uses of IScope in org.ek9lang.compiler.support

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

Modifier and Type	Class	Description
final class	MostSpecificScope	Used when trying to locate the current class or dynamic class, to be able to check if access to fields or methods should be allowed, or even resolve methods without 'this' prefix.
class	NoNameCollisionOrError	Designed to check if variable name and method names collide with Type/Function names.

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

Modifier and Type	Method	Description
IScope	MostSpecificScope.get()

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

Modifier and Type	Method	Description
protected List<AggregateSymbol>	CommonFactory.createAndRegisterParameterisedSymbols(EK9Parser.ParameterisedParamsContext ctx, ISymbol functionOrClass, IScope scope)
AggregateSymbol	AggregateManipulator.createGenericT(String name, String genericParent, IScope scope)	Create a generic parameter of specific name.
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.
CallSymbol	BasicSymbolFactory.newCall(EK9Parser.CallContext ctx, IScope scope)	Symbol to model some type of call to a function, dynamic function, constructor, this, super etc.
CallSymbol	SymbolFactory.newCall(EK9Parser.CallContext ctx, IScope scope)	Symbol to model some type of call to a function, dynamic function, constructor, this, super etc.
CallSymbol	OperationFactory.newCaseExpressionCall(EK9Parser.CaseExpressionContext ctx, IScope scope)	New CallSymbol for switch case expression operator.
CallSymbol	SymbolFactory.newCaseExpressionCall(EK9Parser.CaseExpressionContext ctx, IScope scope)	Create a new CallSymbol for switch case expression operator.
CallSymbol	BasicSymbolFactory.newDict(EK9Parser.DictContext ctx, IScope scope)	Create a new EK9 Dictionary - like a Map.
CallSymbol	SymbolFactory.newDict(EK9Parser.DictContext ctx, IScope scope)	Create a new EK9 Dictionary - like a Map.
CallSymbol	BasicSymbolFactory.newDictEntry(EK9Parser.InitValuePairContext ctx, IScope scope)	Create a new entry for the Dictionary, basically a tuple.
CallSymbol	SymbolFactory.newDictEntry(EK9Parser.InitValuePairContext ctx, IScope scope)	Create a new entry for the Dictionary, basically a tuple.
CaptureScope	BasicSymbolFactory.newDynamicVariableCapture(ICanCaptureVariables scope, IScope enclosingBlockScope)
CaptureScope	SymbolFactory.newDynamicVariableCapture(ICanCaptureVariables scope, IScope enclosingBlockScope)	Create a new local scope just for variables to be defined/captured in for dynamic classes/functions.
ForSymbol	SymbolFactory.newForLoop(org.antlr.v4.runtime.ParserRuleContext ctx, IScope scope)	Create a new symbol that represents an EK9 'for' loop.
CallSymbol	BasicSymbolFactory.newList(EK9Parser.ListContext ctx, IScope scope)	Create a new EK9 List (a generic type).
CallSymbol	SymbolFactory.newList(EK9Parser.ListContext ctx, IScope scope)	Create a new EK9 List (a generic type).
CallSymbol	OperationFactory.newOperationCall(EK9Parser.OperationCallContext ctx, IScope scope)	New call but modelled as an operator if marked as such.
CallSymbol	SymbolFactory.newOperationCall(EK9Parser.OperationCallContext ctx, IScope scope)	New call but modelled as an operator if marked as such.
CallSymbol	OperationFactory.newOperatorCall(String operator, EK9Parser.ExpressionContext ctx, IScope scope)	Create a CallSymbol for an operator in an expression.
CallSymbol	SymbolFactory.newOperatorCall(String operator, EK9Parser.ExpressionContext ctx, IScope scope)	Create a new CallSymbol for an operator in an expression.
ServiceOperationSymbol	ServiceFactory.newServiceOperation(EK9Parser.ServiceOperationDeclarationContext ctx, IScope scope)	Create a new aggregate that represents an EK9 service operation - a specialised method.
ServiceOperationSymbol	SymbolFactory.newServiceOperation(EK9Parser.ServiceOperationDeclarationContext ctx, IScope scope)	Create a new aggregate that represents an EK9 service operation - a specialised method.
StreamCallSymbol	StreamFactory.newStreamCat(EK9Parser.StreamCatContext ctx, IScope scope)	Create a new symbol that represents an EK9 'cat' part of a stream pipeline.
StreamCallSymbol	SymbolFactory.newStreamCat(EK9Parser.StreamCatContext ctx, IScope scope)	Create a new symbol that represents an EK9 'cat' part of a stream pipeline.
StreamCallSymbol	StreamFactory.newStreamFor(EK9Parser.StreamForContext ctx, IScope scope)	Create a new symbol that represents an EK9 'for' part of a stream pipeline.
StreamCallSymbol	SymbolFactory.newStreamFor(EK9Parser.StreamForContext ctx, IScope scope)	Create a new symbol that represents an EK9 'for' part of a stream pipeline.
StreamCallSymbol	StreamFactory.newStreamPart(EK9Parser.StreamPartContext ctx, IScope scope)	Create a new symbol that represents an EK9 stream function part of a stream pipeline.
StreamCallSymbol	SymbolFactory.newStreamPart(EK9Parser.StreamPartContext ctx, IScope scope)	Create a new symbol that represents an EK9 stream function part of a stream pipeline.
StreamCallSymbol	StreamFactory.newStreamTermination(org.antlr.v4.runtime.ParserRuleContext ctx, String operation, IScope scope)	Create a new symbol that represents an EK9 terminal part of a stream pipeline.
StreamCallSymbol	SymbolFactory.newStreamTermination(org.antlr.v4.runtime.ParserRuleContext ctx, String operation, IScope scope)	Create a new symbol that represents an EK9 terminal part of a stream pipeline.
SwitchSymbol	SymbolFactory.newSwitch(EK9Parser.SwitchStatementExpressionContext ctx, IScope scope)	Create a new symbol that represents an EK9 'switch' block.
MethodSymbol	SymbolFactory.newTextBody(EK9Parser.TextBodyDeclarationContext ctx, IScope scope)	Create a new aggregate that represents an EK9 text body - this is represented by a method.
MethodSymbol	TextFactory.newTextBody(EK9Parser.TextBodyDeclarationContext ctx, IScope scope)	Create a new aggregate that represents an EK9 text body - this is represented by a method.
TrySymbol	SymbolFactory.newTry(EK9Parser.TryStatementExpressionContext ctx, IScope scope)	Create a new symbol that represents an EK9 'try' block.
WhileSymbol	SymbolFactory.newWhileLoop(EK9Parser.WhileStatementExpressionContext ctx, IScope scope)	Create a new while or do/while scoped symbol.
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>	AggregateManipulator.resolveString(IScope scope)	Resolve String from cached ek9 types of full scope hierarchy resolution.
Optional<ISymbol>	AggregateManipulator.resolveVoid(IScope scope)	Resolve Void from cached ek9 types of full scope hierarchy resolution.
boolean	NoNameCollisionOrError.test(IScope inScope, ISymbol symbol)	Check for exising symbol in the scope.

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

Modifier	Constructor	Description
	GeneralTypeResolver(IScope scopeForResolution)

Uses of IScope in org.ek9lang.compiler.symbols

Subinterfaces of IScope in org.ek9lang.compiler.symbols

Modifier and Type	Interface	Description
interface	IAggregateSymbol	Interface for an aggregate, typically a class or something like that.
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 IScope

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	CaptureScope	Used to actually hold the captured symbols.
class	CaptureScopedSymbol	Just focuses on the ability to possible capture variables from an enclosing scope.
class	ControlSymbol	EK9 switch/try control type symbol - this can effectively return a value if it is configured with returning part.
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	LocalScope	Used in many ways via composition.
class	MethodSymbol	Represents some type of method that exists on an aggregate type scope.
class	ModuleScope	This is a very special scope, because the same 'module name' can be defined in multiple files.
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	SwitchSymbol	EK9 switch statement - this can effectively return a value if it is configured with returning part.
class	SymbolTable	We need to support simple things like classes which are unique per symbol table Or the fully qualified class names like 'com.some.A and com.other.A' so they won't collide.
class	TrySymbol	EK9 try statement - this can effectively return a value if it is configured with returning part.
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 IScope

Modifier and Type	Method	Description
IScope	IScope.clone(IScope withParentAsAppropriate)
IScope	IScope.getEnclosingScope()
IScope	LocalScope.getEnclosingScope()
IScope	ScopedSymbol.getEnclosingScope()
IScope	SymbolTable.getEnclosingScope()
IScope	CaptureScopedSymbol.getModuleScope()
IScope	MethodSymbol.getParentScope()	For actual methods this will be the aggregate they are part of.

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

Modifier and Type	Method	Description
Optional<IScope>	AggregateSymbol.getAnySuperTypeOrFunction()
Optional<IScope>	FunctionSymbol.getAnySuperTypeOrFunction()
Optional<IScope>	ScopedSymbol.getAnySuperTypeOrFunction()

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

Modifier and Type	Method	Description
AggregateSymbol	AggregateSymbol.clone(IScope withParentAsAppropriate)
AggregateWithTraitsSymbol	AggregateWithTraitsSymbol.clone(IScope withParentAsAppropriate)
CallSymbol	CallSymbol.clone(IScope withParentAsAppropriate)
CaptureScope	CaptureScope.clone(IScope withParentAsAppropriate)
ScopedSymbol	CaptureScopedSymbol.clone(IScope withParentAsAppropriate)
ConstantSymbol	ConstantSymbol.clone(IScope withParentAsAppropriate)
ControlSymbol	ControlSymbol.clone(IScope withParentAsAppropriate)
ExpressionSymbol	ExpressionSymbol.clone(IScope withParentAsAppropriate)
ForSymbol	ForSymbol.clone(IScope withParentAsAppropriate)
FunctionSymbol	FunctionSymbol.clone(IScope withParentAsAppropriate)
IScopedSymbol	IAggregateSymbol.clone(IScope withParentAsAppropriate)
IScope	IScope.clone(IScope withParentAsAppropriate)
IScopedSymbol	IScopedSymbol.clone(IScope withParentAsAppropriate)
ISymbol	ISymbol.clone(IScope withParentAsAppropriate)	Clone the symbol and re-parent if this symbol like a method should have a parent.
LocalScope	LocalScope.clone(IScope withParentAsAppropriate)
MethodSymbol	MethodSymbol.clone(IScope withParentAsAppropriate)
MethodSymbol	MethodSymbol.clone(ISymbol withType, IScope withParentAsAppropriate)
ParamExpressionSymbol	ParamExpressionSymbol.clone(IScope withParentAsAppropriate)
ScopedSymbol	PossibleGenericSymbol.clone(IScope withParentAsAppropriate)
ScopedSymbol	ScopedSymbol.clone(IScope withParentAsAppropriate)
ServiceOperationSymbol	ServiceOperationSymbol.clone(IScope withParentAsAppropriate)
StackConsistencyScope	StackConsistencyScope.clone(IScope withParentAsAppropriate)
StreamCallSymbol	StreamCallSymbol.clone(IScope withParentAsAppropriate)
StreamPipeLineSymbol	StreamPipeLineSymbol.clone(IScope withParentAsAppropriate)
SwitchSymbol	SwitchSymbol.clone(IScope withParentAsAppropriate)
Symbol	Symbol.clone(IScope withParentAsAppropriate)
SymbolTable	SymbolTable.clone(IScope withParentAsAppropriate)
TrySymbol	TrySymbol.clone(IScope withParentAsAppropriate)
VariableSymbol	VariableSymbol.clone(IScope withParentAsAppropriate)
WhileSymbol	WhileSymbol.clone(IScope withParentAsAppropriate)
protected SymbolTable	SymbolTable.cloneIntoSymbolTable(SymbolTable rtn, IScope withParentAsAppropriate)
boolean	IScope.isScopeAMatchForEnclosingScope(IScope toCheck)
boolean	LocalScope.isScopeAMatchForEnclosingScope(IScope toCheck)	Useful to be able to check if the scope you have in hand is the same the enclosing scope for this.
boolean	ScopedSymbol.isScopeAMatchForEnclosingScope(IScope toCheck)
boolean	SymbolTable.isScopeAMatchForEnclosingScope(IScope toCheck)
void	CaptureScopedSymbol.setModuleScope(IScope moduleScope)

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

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)	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)
	AggregateWithTraitsSymbol(String name, IScope enclosingScope)
	AnyTypeSymbol(String name, IScope enclosingScope)
	CallSymbol(String name, IScope enclosingScope)
	CaptureScope(IScope enclosingScope)
	CaptureScopedSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	CaptureScopedSymbol(String name, IScope enclosingScope)
	ControlSymbol(String name, IScope enclosingScope)	Create a new Control Symbol.
	ForSymbol(IScope enclosingScope)
	FunctionSymbol(String name, IScope enclosingScope)	Create a new Function Symbol with a specific unique name (in the enclosing scope).
	FunctionSymbol(String name, IScope enclosingScope, List<AggregateSymbol> typeParameterOrArguments)	A function that can be parameterised, i.e.
	LocalScope(String scopeName, IScope enclosingScope)	Create a new named local scope with an outer enclosing scope.
	LocalScope(IScope enclosingScope)
	LocalScope(IScope.ScopeType scopeType, String scopeName, IScope enclosingScope)	Create a new named local scope with an outer enclosing scope.
	MethodSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)	Create new method symbol of a specific name with an enclosing scope (i.e.
	MethodSymbol(String name, IScope enclosingScope)	Create new method symbol of a specific name with an enclosing scope (i.e.
	MethodSymbol(String name, ISymbol type, IScope enclosingScope)	Typically used for cloning constructors.
	PossibleGenericSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	PossibleGenericSymbol(String name, IScope enclosingScope)
	ScopedSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	ScopedSymbol(String name, IScope enclosingScope)
	ScopedSymbol(IScope.ScopeType scopeType, String scopeName, IScope enclosingScope)
	ServiceOperationSymbol(String name, Optional<ISymbol> type, IScope enclosingScope)
	ServiceOperationSymbol(String name, IScope enclosingScope)
	StackConsistencyScope(IScope enclosingScope)
	StackConsistencyScope(IScope enclosingScope, IScope.ScopeType scopeType)
	StreamCallSymbol(String name, IScope enclosingScope)
	SwitchSymbol(IScope enclosingScope)
	TrySymbol(IScope enclosingScope)
	WhileSymbol(IScope enclosingScope, boolean doWhile)