Uses of Class
org.ek9lang.compiler.symbols.ScopedSymbol

Packages that use ScopedSymbol

Package	Description
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.calls
org.ek9lang.compiler.phase9	M - Intermediate Representation Analysis and Optimization.
org.ek9lang.compiler.support	Contains critical general components used in the Ek9Compiler listeners.
org.ek9lang.compiler.support.retention
org.ek9lang.compiler.symbols	This is the main source of EK9 Symbols used within the compiler.

Uses of ScopedSymbol in org.ek9lang.compiler.phase3

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

Modifier and Type	Class	Description
(package private) final class	OperationCallOrError	Used for resolving operation calls on aggregates, which can include properties that are delegates to functions.
(package private) final class	ResolveIdentifierReferenceCallOrError	Locate a possible call to an identifierReference, so some sort of call.

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

Modifier and Type	Method	Description
ScopedSymbol	OperationCallOrError.apply(EK9Parser.OperationCallContext ctx, IAggregateSymbol aggregate)
ScopedSymbol	ResolveIdentifierReferenceCallOrError.apply(EK9Parser.CallContext ctx)

Uses of ScopedSymbol in org.ek9lang.compiler.phase5

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

Modifier and Type	Class	Description
(package private) final class	DispatchedHandlerPairs	THE dispatcher half of "what may a call through this declaration run" (the closeable route-matrix verifier, 2026-10-22): a call to a dispatcher entry point runs, at run time, the handler most specific to its argument's type - so the entry returns and keeps whatever any of its handlers does.
(package private) final class	DispatchedHandlerPairs	THE dispatcher half of "what may a call through this declaration run" (the closeable route-matrix verifier, 2026-10-22): a call to a dispatcher entry point runs, at run time, the handler most specific to its argument's type - so the entry returns and keeps whatever any of its handlers does.
(package private) final class	DispatchedHandlerPairs	THE dispatcher half of "what may a call through this declaration run" (the closeable route-matrix verifier, 2026-10-22): a call to a dispatcher entry point runs, at run time, the handler most specific to its argument's type - so the entry returns and keeps whatever any of its handlers does.
(package private) final class	IsCaptureOf	THE "is this symbol a capture of the callable whose returning variable is being read" of the return-source readings (ReturnSourceClassifier, ReturnSourceOrigins): by IDENTITY (IsCapturedVariable), one the callable (a dynamic function) or the type it belongs to (a dynamic class) captured.
(package private) final class	IsUserDeclaration	A declaration whose retention was not DECLARED by a built-in: it carries no RETAINS, or only derived marks (IsDerivedRetention).
(package private) final class	JudgedCallable	The callable a CloseableArgumentKeeping record is about: a member of a parameterised type is judged by the generic's own declaration (GenericTemplateMember), anything else by itself.
(package private) final class	MayOverride	May a call through another declaration run this callable - a method of an aggregate (dynamic classes included, constructors not), or a function (dynamic functions included)? The callables the dispatch union of the RETAINS derivations (ReceiverInteriorReturns, CloseableArgumentKeeping) unions over.
(package private) final class	OverriddenBy	The declarations a call through which may run callable: those it overrides, or its super function - THE "what may a call through this declaration run" of the dispatch union, held by both RETAINS derivations (the returns one, ReceiverInteriorReturns, and the callee-keep one, CloseableArgumentKeeping), so what an override RETURNS and what it KEEPS are unioned over the same set.
(package private) final class	OverriddenBy	The declarations a call through which may run callable: those it overrides, or its super function - THE "what may a call through this declaration run" of the dispatch union, held by both RETAINS derivations (the returns one, ReceiverInteriorReturns, and the callee-keep one, CloseableArgumentKeeping), so what an override RETURNS and what it KEEPS are unioned over the same set.
(package private) final class	UnionDispatchedHandlers	Record on each dispatcher entry what its handlers return and keep (MarkOverriddenBy, over the pairs DispatchedHandlerPairs found); true when an entry gained a rule - one step of a RETAINS derivation's fixpoint.
(package private) final class	UnionDispatchedHandlers	Record on each dispatcher entry what its handlers return and keep (MarkOverriddenBy, over the pairs DispatchedHandlerPairs found); true when an entry gained a rule - one step of a RETAINS derivation's fixpoint.

Methods in org.ek9lang.compiler.phase5 that return ScopedSymbol

Modifier and Type	Method	Description
ScopedSymbol	JudgedCallable.apply(ScopedSymbol callable)
ScopedSymbol	CloseableArgumentKeeping.Holder.callable()	Returns the value of the callable record component.
ScopedSymbol	MutatedOnlyVariables.ReturningCallable.callable()	Returns the value of the callable record component.

Methods in org.ek9lang.compiler.phase5 that return types with arguments of type ScopedSymbol

Modifier and Type	Method	Description
List<Map.Entry<ScopedSymbol, ScopedSymbol>>	DispatchedHandlerPairs.apply(Collection<? extends ScopedSymbol> callables)
List<Map.Entry<ScopedSymbol, ScopedSymbol>>	DispatchedHandlerPairs.apply(Collection<? extends ScopedSymbol> callables)
List<ScopedSymbol>	OverriddenBy.apply(ScopedSymbol callable)

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

Modifier and Type	Method	Description
ScopedSymbol	JudgedCallable.apply(ScopedSymbol callable)
List<ScopedSymbol>	OverriddenBy.apply(ScopedSymbol callable)
(package private) void	CloseableArgumentKeeping.declared(ScopedSymbol callable)	A callable that was walked: what it does with each of its parameters is then known.
(package private) static CloseableArgumentKeeping.Holder	CloseableArgumentKeeping.Holder.of(ScopedSymbol callable, ISymbol symbol)
(package private) void	CloseableArgumentKeeping.passedToCall(CloseableArgumentKeeping.Holder from, ScopedSymbol callee, int argumentIndex)	The variable is passed, whole, to a method or function of the program's own.
(package private) void	CloseableArgumentKeeping.receiverPassed(CloseableArgumentKeeping.Holder from, ScopedSymbol callee)	The object a method runs on - Holder.of(method, null), its receiver - is passed on, as the receiver, to a method of the program's own: if that method keeps ITS receiver, so does this one.
boolean	IsCaptureOf.test(ISymbol symbol, ScopedSymbol callable)
boolean	IsUserDeclaration.test(ScopedSymbol declaration)
boolean	MayOverride.test(ScopedSymbol callable)

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

Modifier and Type	Method	Description
List<Map.Entry<ScopedSymbol, ScopedSymbol>>	DispatchedHandlerPairs.apply(Collection<? extends ScopedSymbol> callables)
boolean	UnionDispatchedHandlers.test(List<Map.Entry<ScopedSymbol, ScopedSymbol>> pairs)
boolean	UnionDispatchedHandlers.test(List<Map.Entry<ScopedSymbol, ScopedSymbol>> pairs)

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

Modifier	Constructor	Description
(package private)	Holder(ScopedSymbol callable, ISymbol symbol)	Creates an instance of a Holder record class.
(package private)	ReturningCallable(ParsedModule parsedModule, ScopedSymbol callable, List<EK9Parser.ExpressionContext> sources)	Creates an instance of a ReturningCallable record class.

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

Methods in org.ek9lang.compiler.phase7.calls that return types with arguments of type ScopedSymbol

Modifier and Type	Method	Description
Optional<ScopedSymbol>	OperatorTargetMethodResolver.apply(ISymbol targetType, String methodName, List<ISymbol> argumentTypes)	Resolve a method/operator on the target type, returning the resolved symbol itself (not just type names), so callers can read its defining type, return type and metadata rather than re-deriving them.
Optional<ScopedSymbol>	OperatorTargetMethodResolver.onTypeArgument(ScopedSymbol templateMember, UnaryOperator<ISymbol> typeArgumentOf)	THE member that serves, inside a monomorphisation, a call phase 3 resolved on a generic's bare T.
Optional<ScopedSymbol>	OperatorTargetMethodResolver.servingMember(ISymbol targetType, String methodName, List<ISymbol> argumentTypes, UnaryOperator<ISymbol> typeArgumentOf)	OperatorTargetMethodResolver.apply(ISymbol, String, List) followed by OperatorTargetMethodResolver.onTypeArgument(ScopedSymbol, UnaryOperator): the member that serves the call, read off the type argument when the call is resolved on a generic's bare T inside a monomorphisation.

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

Modifier and Type	Method	Description
Optional<ScopedSymbol>	OperatorTargetMethodResolver.onTypeArgument(ScopedSymbol templateMember, UnaryOperator<ISymbol> typeArgumentOf)	THE member that serves, inside a monomorphisation, a call phase 3 resolved on a generic's bare T.

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

Modifier and Type	Method	Description
static DispatchFacts	DispatchFacts.ofOperatorFallback(Optional<ScopedSymbol> servingMember, ISymbol staticType, boolean explicitSuperReceiver, TypeNameOrException typeNames, UnaryOperator<ISymbol> concreteType)	The facts of an operator call with no parse node (path B of CallDetailsBuilder: a compound assignment, a unary operator, a phase-7 protocol call): the call names the type that declares the serving member when one resolves, else the static type; a trait call is virtual by definition, otherwise dispatch is the static type's openness; extern is the STATIC type's (MONO-5 - see the class note).

Uses of ScopedSymbol in org.ek9lang.compiler.phase9

Classes in org.ek9lang.compiler.phase9 that implement interfaces with type arguments of type ScopedSymbol

Modifier and Type	Class	Description
(package private) final class	CalleeOfCall	THE symbol an IR call runs, read back from what the call names: its target type (a user construct of the program's IR first, else a type or function the program resolves by fully qualified name - a core type, a parameterisation), the method by its IR name (OperatorMap.resolvedMethodName(MethodSymbol), so _addAss finds +=) and the fully qualified types of its parameters; a function's _call is the function itself.

Methods in org.ek9lang.compiler.phase9 that return types with arguments of type ScopedSymbol

Modifier and Type	Method	Description
Optional<ScopedSymbol>	CalleeOfCall.apply(CallInstr call)
(package private) Optional<ScopedSymbol>	PublishedValues.calleeOf(CallInstr call)	The symbol a call runs, when its names lead to one.

Constructor parameters in org.ek9lang.compiler.phase9 with type arguments of type ScopedSymbol

Modifier	Constructor	Description
	PublishedValues(Predicate<String> mayBeRegistered, Function<CallInstr, Optional<ScopedSymbol>> calleeOf)
(package private)	ReferenceEdges(Function<CallInstr, Optional<ScopedSymbol>> calleeOf)

Uses of ScopedSymbol in org.ek9lang.compiler.support

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

Modifier and Type	Method	Description
Optional<ScopedSymbol>	MostSpecificScope.getIfAny()	The nearest dynamic block, else the nearest non-block scope, of the current scope's enclosing scopes - empty when the code is in neither.

Uses of ScopedSymbol in org.ek9lang.compiler.support.retention

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

Modifier and Type	Class	Description
(package private) final class	AddRetentionRule	THE write of a derived RETAINS rule: marks the callable as DERIVED and adds the rule text.
(package private) final class	ArgumentRule	THE argument question the argument readers ask (RetainsArgument, HandsBackArgument, KeepsArgumentBeyondResult, DefinitelyKeepsArgument, MayKeepArgument), so they differ only in which rules count (wanted) and in whether the unknown opt-out answers for them (unknownCounts): does a rule of callee (declared, derived, or the generic's own) that matches wanted take the argument given at parameterIndex as its source? With unknownCounts, a callee declaring unknown answers yes - also for an index it does not declare.
final class	CallableParameters	THE declared parameters of a method, operator or function a RETAINS rule names; none for anything else.
final class	CalleeOfCall	THE method or function a recorded symbol CALLS, when it is a call that hands back a value made elsewhere: a method, operator or function call - never a constructor, whose result is always fresh.
final class	CalleeOfExpression	THE method, operator or function an expression CALLS when the whole expression is that call - a.get(k), first(), a + b, (a.get(k)) - so its value is whatever the call handed back.
(package private) final class	DeclaresAnyRule	Does the callee (or, for a member of a parameterised type, the generic's own member) declare a rule matching wanted - or the unknown opt-out, under which nothing may be assumed.
final class	DefinitelyKeepsArgument	Does callee say, by an EXPLICIT rule - declared by a built-in or derived for a user callable - that it keeps the argument it is given at parameterIndex somewhere other than its result? The narrower question than KeepsArgumentBeyondResult, which also counts the inexpressible unknown opt-out: an unnamed closeable given to a callee that DEFINITELY keeps it is E81072; one given to a callee that may is handed on.
final class	DefinitelyKeepsReceiver	Does callee say, by an EXPLICIT rule - declared by a built-in (readyHandler <- receiver) or derived for a user method - that it keeps the object it is called ON beyond the call: stores it in an argument or where nothing here can name it? The receiver's half of DefinitelyKeepsArgument: an unnamed closeable that is the RECEIVER of such a call is E81072 (D80 follow-up, 2026-10-21: Tracked("r").registerIn(kept), whose body is items += this, closed the receiver and then the list held a closed object).
final class	HandsBackArgument	May the call hand the argument it is given at parameterIndex back as (part of) its result - return <- <that parameter>? The narrower question than RetainsArgument, which also counts an argument kept anywhere else (receiver <- item) and the unknown opt-out: the closeable ownership decision reports a hand-back (E81072) and treats any other keeping as handed on.
final class	IsDerivedRetention	Was the callee's retention DERIVED by phase 5 (a user callable) rather than DECLARED (a built-in's @Ek9Retains)? The closeable ownership decision treats the two differently: a derived link is honoured only where the return type may hold a borrowed view (support/BorrowedViewReturn).
final class	KeepsArgumentBeyondResult	May callee keep the argument it is given at parameterIndex somewhere other than its result - into its receiver, another argument, or anywhere (receiver <- item, unknown)? The question a constructor passing its own parameter on asks to know whether the parameter outlives the construction.
final class	KeepsReceiverBeyondResult	May callee keep its receiver beyond the call - an explicit rule, or the unknown opt-out?
final class	KeptArgumentHolders	What may come to HOLD the argument callee is given at parameterIndex, other than its result: the receiver (RetentionRule.RECEIVER) and the names of the other parameters it may store the argument into (receiver <- item, items <- item).
final class	MarkKeepsParameter	Record, on a user method, operator or function, that the argument given for a parameter may be kept beyond the call - the rule <destination> <- <parameter> (RetentionRule.destination() and RetentionRule.source()), exactly the text a built-in declares: the destination is receiver (stored in a property of the object), another parameter's name (added to the object that argument refers to), ambient (held where nothing here can name it: a capture, a returned closure, a call that keeps it) or ReturnRetention.UNIMPLEMENTED.
final class	MarkKeepsReceiver	Record, on a user method or operator, that the object it is called on may be kept beyond the call - <destination> <- receiver, exactly the text a built-in declares (HTTP.whenReady's readyHandler <- receiver): the destination is another parameter's name (the receiver is stored in what that argument refers to) or ambient (held where nothing here can name it: a capture, a returned closure, a call that keeps it).
final class	MarkMayKeepEachParameter	Record that an abstract declaration nothing implements MAY keep each of its arguments (unimplemented <- <parameter>, ReturnRetention.UNIMPLEMENTED); the keep counterpart of MarkReturnsEachParameter.
final class	MarkOverriddenBy	THE dispatch union (Steve, 2026-10-21, D61): a call through declaration may run override - a method that overrides it, or a function (dynamic functions included) whose super function it is - so the declaration also returns whatever the override does, and keeps whatever the override keeps (the lane callee-keep, 2026-10-21: receiver <- item, <otherParam> <- item, ambient <- item).
final class	MarkOverriddenBy	THE dispatch union (Steve, 2026-10-21, D61): a call through declaration may run override - a method that overrides it, or a function (dynamic functions included) whose super function it is - so the declaration also returns whatever the override does, and keeps whatever the override keeps (the lane callee-keep, 2026-10-21: receiver <- item, <otherParam> <- item, ambient <- item).
final class	MarkReturnsEachParameter	An abstract declaration no program code implements: which implementation runs cannot be known, so its result may be any of its arguments - return <- <each parameter>.
final class	MarkReturnsParameter	Record, on a user method, operator or function, that what it returns may be the argument given for the parameter parameterName - return <- parameterName, exactly the text a built-in declares (List.getOrDefault's return <- defaultValue).
final class	MayAlias	Does what callee returns possibly share an object with its receiver or an argument.
final class	MayKeepArgument	The MAY half of DefinitelyKeepsArgument: does callee say, by an EXPLICIT rule, that it keeps the argument - or is it an abstract declaration nothing implements, which MAY keep any argument (ReturnRetention.UNIMPLEMENTED)? An unnamed closeable given to such a callee is E81072 (nothing could close it); a named try resource given to it is allowed.
final class	ParameterIndex	THE index of the parameter a RETAINS rule names (parameterName) in callee's declared parameters; -1 when it declares none of that name.
final class	ReceiverKeptInto	The parameters callee stores its receiver INTO by an explicit rule (items <- receiver, declared or derived): the names of the arguments that end up holding the object it is called on.
final class	RetainsArgument	May callee keep (a reference to) the argument it is given at parameterIndex - into its receiver, another argument, its result or anywhere else (receiver <- item, return <- other, or unknown)? An argument the callee keeps is no longer the caller's alone.
(package private) final class	RetentionsOf	The RETAINS text of the callee itself and of the generic it is a parameterisation, or member, of.
final class	ReturnRules	THE rules saying what callee RETURNS (every return <- source it declares or has derived, the generic's own for a parameterisation or a member of one) - for a caller that must map each source back onto the receiver or the argument it names (phase5/ReturnSourceKind.origins).
final class	ReturnsReceiverInterior	Does what callee returns possibly share an object with its RECEIVER.
(package private) final class	RulesOf	Every rule the callee declares or has derived, the generic's own included; none for unknown.

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

Modifier and Type	Method	Description
Optional<ScopedSymbol>	CalleeOfCall.apply(ISymbol recorded)
Optional<ScopedSymbol>	CalleeOfExpression.apply(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	The callee of the expression.

Methods in org.ek9lang.compiler.support.retention with parameters of type ScopedSymbol

Modifier and Type	Method	Description
void	AddRetentionRule.accept(ScopedSymbol callable, String rule)
void	MarkKeepsParameter.accept(ScopedSymbol callable, org.ek9lang.tooling.construct.RetentionRule keep)
void	MarkKeepsReceiver.accept(ScopedSymbol callable, String destination)
void	MarkMayKeepEachParameter.accept(ScopedSymbol callable)
void	MarkReturnsEachParameter.accept(ScopedSymbol callable)
void	MarkReturnsParameter.accept(ScopedSymbol callable, String parameterName)
List<ISymbol>	CallableParameters.apply(ScopedSymbol callee)
List<String>	KeptArgumentHolders.apply(ScopedSymbol callee, Integer parameterIndex)
List<String>	ReceiverKeptInto.apply(ScopedSymbol callee)
List<String>	RetentionsOf.apply(ScopedSymbol callee)
List<org.ek9lang.tooling.construct.RetentionRule>	ReturnRules.apply(ScopedSymbol callee)
List<org.ek9lang.tooling.construct.RetentionRule>	RulesOf.apply(ScopedSymbol callee)
int	ParameterIndex.applyAsInt(ScopedSymbol callee, String parameterName)
boolean	ArgumentRule.test(ScopedSymbol callee, Integer parameterIndex)
boolean	DeclaresAnyRule.test(ScopedSymbol callee, Predicate<org.ek9lang.tooling.construct.RetentionRule> wanted)
boolean	DefinitelyKeepsArgument.test(ScopedSymbol callee, Integer parameterIndex)
boolean	DefinitelyKeepsReceiver.test(ScopedSymbol callee)
boolean	HandsBackArgument.test(ScopedSymbol callee, Integer parameterIndex)
boolean	IsDerivedRetention.test(ScopedSymbol callee)
boolean	KeepsArgumentBeyondResult.test(ScopedSymbol callee, Integer parameterIndex)
boolean	KeepsReceiverBeyondResult.test(ScopedSymbol callee)
boolean	MarkOverriddenBy.test(ScopedSymbol declaration, ScopedSymbol override)	Record every rule of the override on the declaration.
boolean	MayAlias.test(ScopedSymbol callee)
boolean	MayKeepArgument.test(ScopedSymbol callee, Integer parameterIndex)
boolean	RetainsArgument.test(ScopedSymbol callee, Integer parameterIndex)
boolean	ReturnsReceiverInterior.test(ScopedSymbol callee)

Uses of ScopedSymbol in org.ek9lang.compiler.symbols

Subclasses of ScopedSymbol in org.ek9lang.compiler.symbols

Modifier and Type	Class	Description
class	AggregateSymbol	This is typically a 'class' or an interface type where it can include the definitions of new properties.
class	AggregateWithTraitsSymbol	An aggregate, but one that can have zero or more traits (like interfaces).
class	AnyTypeSymbol	Special type that is super of Aggregate and super of Function (if they don't have supers).
class	AssertDoesNotThrowSymbol	EK9 assertDoesNotThrow expression - validates that an expression does not throw.
class	AssertPanicSymbol	EK9 assertPanic expression - asserts that the wrapped expression fires an org.ek9.lang::Panic.
class	AssertThrowsSymbol	EK9 assertThrows expression - captures an expected exception type and expression.
class	CallSymbol	Just re-uses the bulk of method symbol for when we want to make a symbol that is a call to an actual method.
class	CaptureScopedSymbol	Just focuses on the ability to possible capture variables from an enclosing scope.
class	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	MethodSymbol	Represents some type of method that exists on an aggregate type scope.
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	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	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 ScopedSymbol

Modifier and Type	Method	Description
ScopedSymbol	CaptureScopedSymbol.clone(IScope withParentAsAppropriate)
ScopedSymbol	PossibleGenericSymbol.clone(IScope withParentAsAppropriate)
ScopedSymbol	ScopedSymbol.clone(IScope withParentAsAppropriate)
protected ScopedSymbol	ScopedSymbol.cloneIntoScopeSymbol(ScopedSymbol newCopy)
ScopedSymbol	ScopedSymbol.copyScopedSymbolProperties(ScopedSymbol newCopy)	Just copies the properties over.
ScopedSymbol	CallSymbol.getResolvedSymbolToCall()

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

Modifier and Type	Method	Description
Optional<ScopedSymbol>	IScope.findNearestDynamicBlockScopeInEnclosingScopes()
Optional<ScopedSymbol>	LocalScope.findNearestDynamicBlockScopeInEnclosingScopes()
Optional<ScopedSymbol>	ScopedSymbol.findNearestDynamicBlockScopeInEnclosingScopes()
Optional<ScopedSymbol>	SymbolTable.findNearestDynamicBlockScopeInEnclosingScopes()
Optional<ScopedSymbol>	IScope.findNearestNonBlockScopeInEnclosingScopes()
Optional<ScopedSymbol>	LocalScope.findNearestNonBlockScopeInEnclosingScopes()	Traverses up the scope tree of enclosing scopes to find the first scope type that is an aggregate.
Optional<ScopedSymbol>	ScopedSymbol.findNearestNonBlockScopeInEnclosingScopes()
Optional<ScopedSymbol>	SymbolTable.findNearestNonBlockScopeInEnclosingScopes()

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

Modifier and Type	Method	Description
protected ScopedSymbol	ScopedSymbol.cloneIntoScopeSymbol(ScopedSymbol newCopy)
ScopedSymbol	ScopedSymbol.copyScopedSymbolProperties(ScopedSymbol newCopy)	Just copies the properties over.
void	CallSymbol.setResolvedSymbolToCall(ScopedSymbol symbol)	Set the actual method/function that should be called.