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.phase7.generation
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 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.
Optional<IScope>	ScopeStack.traverseBackUpStackBeyond(IScope beyond, IScope.ScopeType scopeType)	Like ScopeStack.traverseBackUpStack(IScope.ScopeType), but only considers the scopes OUTSIDE beyond - the ones pushed before it.
Optional<IScope>	SymbolsAndScopes.traverseBackUpStackBeyond(IScope beyond, IScope.ScopeType scopeType)	As SymbolsAndScopes.traverseBackUpStack(IScope.ScopeType), considering only the scopes outside beyond.

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.isInitialiserReplaced(ISymbol returningVariable, IScope inScope)	True when every path to the end of the scope has given the returning variable a new value - the definite assignment E08050 asks of a returning variable with no initialiser, asked of one that has an initialiser - so the value it was declared with cannot be the one returned.
boolean	SymbolsAndScopes.isSymbolAccessSafe(ISymbol identifierSymbol, IScope inScope)	true if identifier is safe to access within the specified scope (rather than the current top scope).
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.
Optional<IScope>	ScopeStack.traverseBackUpStackBeyond(IScope beyond, IScope.ScopeType scopeType)	Like ScopeStack.traverseBackUpStack(IScope.ScopeType), but only considers the scopes OUTSIDE beyond - the ones pushed before it.
Optional<IScope>	SymbolsAndScopes.traverseBackUpStackBeyond(IScope beyond, IScope.ScopeType scopeType)	As SymbolsAndScopes.traverseBackUpStack(IScope.ScopeType), considering only the scopes outside beyond.
Optional<AggregateSymbol>	ScopeStack.traverseBackUpStackToNearestAggregateBeyond(IScope beyond)	Like ScopeStack.traverseBackUpStackToNearestAggregate(), but only considers the scopes OUTSIDE beyond - the ones pushed before it (a null, or a scope not on the stack, means the whole stack).
Optional<AggregateSymbol>	SymbolsAndScopes.traverseBackUpStackToNearestAggregateBeyond(IScope beyond)	As SymbolsAndScopes.traverseBackUpStackToNearestAggregate(), considering only the scopes outside beyond.

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.

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

Modifier and Type	Method	Description
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.
IScope	MethodOnAggregateData.scopeToSearch()	Returns the value of the scopeToSearch 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)	MethodOnAggregateData(IToken token, IScope scopeToSearch, String methodName, List<ISymbol> callArguments)	Creates an instance of a MethodOnAggregateData record class.
(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) final class	ReturningVariableOrError	Checks if return variables are initialised.
(package private) final class	ReturnInitialisedBeforeRequireOrError	Enforces guard-first return ordering (E08055; docs/language-design/EK9_REQUIRE_RETURN_ORDERING_SPEC.md).
(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	ReturningVariableOrError.accept(IScope mainScope, EK9Parser.OperationDetailsContext ctx)
void	ReturnInitialisedBeforeRequireOrError.accept(IScope mainScope, EK9Parser.OperationDetailsContext ctx)
void	SafeSymbolMarker.accept(ISymbol symbol, IScope scope)
protected void	AbstractSafeSymbolMarker.assessIsSetCall(ISymbol toBeAssessed, IScope scopeMadeSafe)
(package private) List<ISymbol>	ScopeVariableCollector.getAccessibleFields(IScope scope)	The property fields of the nearest enclosing aggregate, or an empty list if there is none.
(package private) void	SafeGenericContainers.markAccessSafe(ISymbol symbol, IScope scopeMadeSafe)	Mark the (OK for a Result) unwrapping access of this symbol safe in the scope; nothing for other symbols.
(package private) void	SafeAccessConjuncts.markProven(EK9Parser.ExpressionContext condition, IScope scopeMadeSafe)	Mark everything the top-level conjuncts of condition prove as safe in scopeMadeSafe.
protected void	PossibleExpressionConstruct.pullUpAcceptableCriteriaToHigherScope(CodeFlowAnalyzer analyzer, List<IScope> allAppropriateBlocks, IScope outerScope)
protected void	PossibleExpressionConstruct.returningVariableValidOrError(EK9Parser.ReturningParamContext ctx, IScope constructScope, boolean bodyGuaranteedToRun)	Validates the returning variable of an expression-form construct.

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.createEmptyInitOperation(IRConstruct construct, IScope scope, String methodName)	THE empty init operation (_c_init or _i_init): nothing to do but return, as for a program, an application, a dynamic function's instance init (its captures are constructor arguments) and the abstract text base.
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.phase7.generation

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

Modifier and Type	Method	Description
String	IRGenerationContext.resolveScopeTypeName(IScope scope)	IRGenerationContext.resolveTypeName(ISymbol) for an owning SCOPE that is usually - but not always - a symbol (a method's parent scope, giving the type the method is emitted on).

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

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

Modifier and Type	Method	Description
static void	CycleGuardOwner.addIfNeeded(IRConstruct construct, IScope scope, IRInstructionBuilder cInitBuilder, DebugInfo debugInfo, Ek9Types ek9Types)	THE step every _c_init generator calls (there are two: AbstractDfnGenerator and Scenario3SourceIRGenerator for a developer's parameterised generic): when the type's generated operators are guarded, declare the constant on the construct and make it in the _c_init being built.
static boolean	CycleGuardOwner.isNeeded(IScope scope)	Does this construct's type carry the owner constant? True exactly when its generated operators are guarded.
static Optional<CallDetails>	TextFactoryDispatch.redirectForTextBase(IScope constructorParentScope, String typeName, List<String> parameterTypes, List<String> argumentVariables, CallMetaDataDetails metaData)	If constructorParentScope is a TEXT base type, return the static _textFactory CallDetails to emit (via CallInstr.callStatic) instead of a direct constructor call; otherwise Optional.empty() and the caller emits a normal constructor call.

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.

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

Modifier and Type	Method	Description
MatchResults	FuzzySymbolSearch.findSimilarSymbols(IScope scope, String targetName)	Search for symbols with names similar to the target name in the given scope and all enclosing scopes.
MatchResults	FuzzySymbolSearch.findSimilarTypes(IScope scope, String typeName)	Search for types with names similar to the target type name in the given scope and all enclosing scopes.

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
(package private) final class	CheckForMissingSecurityPosture	Checks that a service operation has a security posture, either inherited from its parent service or declared on the operation itself.
final class	MostSpecificScope	THE "whose code is running here?" - used when trying to locate the current class, dynamic class or dynamic function, to be able to check if access to fields or methods should be allowed, or even resolve methods without 'this' prefix.
final class	NoBuiltInNameOrError	THE check that a construct being defined in a user module does not take the name of a built-in construct (E01090).
class	NoNameCollisionOrError	Designed to check if variable name and method names collide with Type/Function names.
final class	NormalTerminationOrError	THE check that a body which must return a value can do so: a scope whose every path ends in an exception has an unreachable return (E07380).

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

Modifier and Type	Method	Description
IScope	MostSpecificScope.get()

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

Modifier and Type	Method	Description
Optional<IScope>	MostSpecificScope.beyond(IScope beyond)	The scope whose code runs, from the scope STACK, considering only the scopes outside beyond (null: the whole stack): the nearest dynamic block, else the nearest non-block scope.

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

Modifier and Type	Method	Description
void	CheckForMissingSecurityPosture.accept(ServiceOperationSymbol operation, IScope parentService)
void	NormalTerminationOrError.accept(IToken token, IScope scope)
Optional<IScope>	MostSpecificScope.beyond(IScope beyond)	The scope whose code runs, from the scope STACK, considering only the scopes outside beyond (null: the whole stack): the nearest dynamic block, else the nearest non-block scope.
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	SymbolChecker.errorsIfNameIsBuiltIn(IScope moduleScope, ISymbol symbol)	Check the symbol about to be defined in a user module does not take the name of a built-in construct (E01090).
boolean	NoNameCollisionOrError.errorsIfResolved(IScope inScope, ISymbol symbol, SymbolSearch search, ErrorListener.SemanticClassification classificationError)	If a symbol is resolved then this will emit an error.
boolean	SymbolChecker.errorsIfSymbolAlreadyDefined(IScope inScope, ISymbol symbol, boolean limitVarSearchToBlockScope)	Check for exising symbol in the scope.
AssertDoesNotThrowSymbol	SymbolFactory.newAssertDoesNotThrow(EK9Parser.AssertDoesNotThrowExpressionContext ctx, IScope scope)	Create a new symbol that represents an EK9 'assertDoesNotThrow' expression.
AssertPanicSymbol	SymbolFactory.newAssertPanic(EK9Parser.AssertPanicExpressionContext ctx, IScope scope)	Create a new symbol that represents an EK9 'assertPanic' expression.
AssertThrowsSymbol	SymbolFactory.newAssertThrows(EK9Parser.AssertThrowsExpressionContext ctx, IScope scope)	Create a new symbol that represents an EK9 'assertThrows' expression.
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)
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.
static Optional<ISymbol>	AggregateManipulator.resolveAny(IScope scope)	THE search for the built-in Any through a scope: the fully qualified name, of category ANY - a category only AnyTypeSymbol has, so nothing a user declares can answer it.
Optional<ISymbol>	AggregateManipulator.resolveBits(IScope scope)	Resolve Bits from cached ek9 types or full scope hierarchy resolution.
Optional<ISymbol>	AggregateManipulator.resolveBoolean(IScope scope)	Resolve Boolean from cached ek9 types of full scope hierarchy resolution.
Optional<ISymbol>	AggregateManipulator.resolveInteger(IScope scope)	Resolve Integer from cached ek9 types of full scope hierarchy resolution.
Optional<ISymbol>	AggregateManipulator.resolveJson(IScope scope)	Resolve JSON from cached ek9 types of full scope hierarchy resolution.
Optional<ISymbol>	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	NoBuiltInNameOrError.test(IScope moduleScope, ISymbol symbol)	Check the symbol about to be defined in the module scope given.
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	AssertDoesNotThrowSymbol	EK9 assertDoesNotThrow expression - validates that an expression does not throw.
class	AssertPanicSymbol	EK9 assertPanic expression - asserts that the wrapped expression fires an org.ek9.lang::Panic.
class	AssertThrowsSymbol	EK9 assertThrows expression - captures an expected exception type and expression.
class	CallSymbol	Just re-uses the bulk of method symbol for when we want to make a symbol that is a call to an actual method.
class	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)
AssertDoesNotThrowSymbol	AssertDoesNotThrowSymbol.clone(IScope withParentAsAppropriate)
AssertPanicSymbol	AssertPanicSymbol.clone(IScope withParentAsAppropriate)
AssertThrowsSymbol	AssertThrowsSymbol.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)
AggregateWithTraitsSymbol	AggregateWithTraitsSymbol.cloneWithoutMembers(IScope withParentAsAppropriate)	A copy of this aggregate, everything but its members - for a caller that clones the members onto the copy, re-types them and then defines them (a constructor renamed after it was defined could no longer be found by its name).
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)
	AssertDoesNotThrowSymbol(IScope enclosingScope)
	AssertPanicSymbol(IScope enclosingScope)
	AssertThrowsSymbol(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)