org.jruby.parser

Class StaticScope

java.lang.Object

org.jruby.parser.StaticScope

All Implemented Interfaces:

Serializable

public class StaticScope
extends Object
implements Serializable

StaticScope represents lexical scoping of variables and module/class constants. At a very high level every scopes enclosing scope contains variables in the next outer lexical layer. The enclosing scopes variables may or may not be reachable depending on the scoping rules for variables (governed by BlockStaticScope and LocalStaticScope). StaticScope also keeps track of current module/class that is in scope. previousCRefScope will point to the previous scope of the enclosing module/class (cref).

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	StaticScope.Type

Field Summary

Fields

Modifier and Type	Field and Description
protected StaticScope	enclosingScope
protected IRScopeType	scopeType

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	StaticScope(StaticScope.Type type, StaticScope enclosingScope) Construct a new static scope.
protected	StaticScope(StaticScope.Type type, StaticScope enclosingScope, String file)
protected	StaticScope(StaticScope.Type type, StaticScope enclosingScope, String[] names) Construct a new static scope.

Method Summary

Methods

Modifier and Type	Method and Description
AssignableNode	addAssign(ISourcePosition position, String name, Node value)
int	addVariable(String name) Add a new variable to this (current) scope unless it is already defined in any reachable scope.
int	addVariableThisScope(String name) Add a new variable to this (current) scope unless it is already defined in the current scope.
AssignableNode	assign(ISourcePosition position, String name, Node value) Make a DASgn or LocalAsgn node based on scope logic
AssignableNode	assign(ISourcePosition position, String name, Node value, StaticScope topScope, int depth)
Node	declare(ISourcePosition position, String name) Make a DVar or LocalVar node based on scoping logic
Node	declare(ISourcePosition position, String name, int depth)
RubyModule	determineModule() Update current scoping structure to populate with proper cref scoping values.
StaticScope	duplicate()
int	exists(String name) Does the variable exist?
String[]	getAllNamesInScope() Get all visible variables that we can see from this scope that have been assigned (e.g.
long	getCommandArgumentStack()
IRubyObject	getConstant(String internedName)
IRubyObject	getConstantInner(String internedName)
DynamicScope	getDummyScope()
StaticScope	getEnclosingScope() Next outer most scope in list of scopes.
String	getFile()
IRScope	getIRScope()
StaticScope	getLocalScope() Gets the Local Scope relative to the current Scope.
RubyModule	getModule() Get the live CRef module associated with this scope.
int	getNumberOfVariables()
RubyModule	getOverlayModule(ThreadContext context)
StaticScope	getPreviousCRefScope()
IRScopeType	getScopeType()
Signature	getSignature() For all block or method associated with static scopes this will return the signature for that signature-providing scope.
StaticScope.Type	getType()
String[]	getVariables()
boolean	isArgumentScope() Argument scopes represent scopes which contain arguments for zsuper.
boolean	isBlockScope()
int	isDefined(String name) Is this name in the visible to the current scope
int	isDefined(String name, int depth)
void	makeArgumentScope()
void	setCommandArgumentStack(long commandArgumentStack)
void	setIRScope(IRScope irScope)
void	setModule(RubyModule module)
void	setPreviousCRefScope(StaticScope crefScope)
void	setScopeType(IRScopeType scopeType)
void	setSignature(Signature signature) This happens in when first defining ArgsNodes or when reifying a method from AOT.
void	setVariables(String[] names)
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

enclosingScope

protected final StaticScope enclosingScope

scopeType

protected IRScopeType scopeType

Constructor Detail

StaticScope

protected StaticScope(StaticScope.Type type,
           StaticScope enclosingScope,
           String file)

StaticScope

protected StaticScope(StaticScope.Type type,
           StaticScope enclosingScope)

Construct a new static scope.

Parameters:

type - the type of scope

enclosingScope - the lexically containing scope.

StaticScope

protected StaticScope(StaticScope.Type type,
           StaticScope enclosingScope,
           String[] names)

Construct a new static scope. The array of strings should all be the interned versions, since several other optimizations depend on being able to do object equality checks.

Parameters:

type - the type of scope

enclosingScope - the lexically containing scope.

names - The list of interned String variable names.

Method Detail

getIRScope

public IRScope getIRScope()

getScopeType

public IRScopeType getScopeType()

setScopeType

public void setScopeType(IRScopeType scopeType)

setIRScope

public void setIRScope(IRScope irScope)

addVariableThisScope

public int addVariableThisScope(String name)

Add a new variable to this (current) scope unless it is already defined in the current scope.

Parameters:

name - of new variable

Returns:

index+depth merged location of scope

addVariable

public int addVariable(String name)

Add a new variable to this (current) scope unless it is already defined in any reachable scope.

Parameters:

name - of new variable

Returns:

index+depth merged location of scope

getVariables

public String[] getVariables()

getNumberOfVariables

public int getNumberOfVariables()

setVariables

public void setVariables(String[] names)

getConstant

public IRubyObject getConstant(String internedName)

getConstantInner

public IRubyObject getConstantInner(String internedName)

getEnclosingScope

public StaticScope getEnclosingScope()

Next outer most scope in list of scopes. An enclosing scope may have no direct scoping relationship to its child. If I am in a localScope and then I enter something which creates another localScope the enclosing scope will be the first scope, but there are no valid scoping relationships between the two. Methods which walk the enclosing scopes are responsible for enforcing appropriate scoping relationships.

Returns:

the parent scope

exists

public int exists(String name)

Does the variable exist?

Parameters:

name - of the variable to find

Returns:

index of variable or -1 if it does not exist

isDefined

public int isDefined(String name)

Is this name in the visible to the current scope

Parameters:

name - to be looked for

Returns:

a location where the left-most 16 bits of number of scopes down it is and the right-most 16 bits represents its index in that scope

assign

public AssignableNode assign(ISourcePosition position,
                    String name,
                    Node value)

Make a DASgn or LocalAsgn node based on scope logic

Parameters:

position -

name -

value -

Returns:

getAllNamesInScope

public String[] getAllNamesInScope()

Get all visible variables that we can see from this scope that have been assigned (e.g. seen so far)

Returns:

a list of all names (sans $~ and $_ which are special names)

isDefined

public int isDefined(String name,
            int depth)

addAssign

public AssignableNode addAssign(ISourcePosition position,
                       String name,
                       Node value)

assign

public AssignableNode assign(ISourcePosition position,
                    String name,
                    Node value,
                    StaticScope topScope,
                    int depth)

declare

public Node declare(ISourcePosition position,
           String name,
           int depth)

declare

public Node declare(ISourcePosition position,
           String name)

Make a DVar or LocalVar node based on scoping logic

Parameters:

position - the location that in the source that the new node will come from

name - of the variable to be created is named

Returns:

a DVarNode or LocalVarNode

getLocalScope

public StaticScope getLocalScope()

Gets the Local Scope relative to the current Scope. For LocalScopes this will be itself. Blocks will contain the LocalScope it contains.

Returns:

localScope

getModule

public RubyModule getModule()

Get the live CRef module associated with this scope.

Returns:

the live module

getPreviousCRefScope

public StaticScope getPreviousCRefScope()

setPreviousCRefScope

public void setPreviousCRefScope(StaticScope crefScope)

setModule

public void setModule(RubyModule module)

determineModule

public RubyModule determineModule()

Update current scoping structure to populate with proper cref scoping values. This should be called at any point when you reference a scope for the first time. For the interpreter this is done in a small number of places (defnNode, defsNode, and getBlock). The compiler does this in the same places.

Returns:

the current cref, though this is largely an implementation detail

isBlockScope

public boolean isBlockScope()

isArgumentScope

public boolean isArgumentScope()

Argument scopes represent scopes which contain arguments for zsuper. All LocalStaticScopes are argument scopes and BlockStaticScopes can be when they are used by define_method.

makeArgumentScope

public void makeArgumentScope()

getSignature

public Signature getSignature()

For all block or method associated with static scopes this will return the signature for that signature-providing scope. module bodies and other non-arity specific code will return null.

setSignature

public void setSignature(Signature signature)

This happens in when first defining ArgsNodes or when reifying a method from AOT.

getDummyScope

public DynamicScope getDummyScope()

setCommandArgumentStack

public void setCommandArgumentStack(long commandArgumentStack)

getCommandArgumentStack

public long getCommandArgumentStack()

toString

public String toString()

Overrides:

toString in class Object

getType

public StaticScope.Type getType()

getFile

public String getFile()

duplicate

public StaticScope duplicate()

getOverlayModule

public RubyModule getOverlayModule(ThreadContext context)