StaticScope (JRuby Core 1.7.7 API)

java.lang.Object
- org.jruby.parser.StaticScope

All Implemented Interfaces:

Serializable

Direct Known Subclasses:

BlockStaticScope, IRStaticScope, LocalStaticScope
```
public abstract 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

Nested Classes
Modifier and Type	Class and Description
`static class`	`StaticScope.Type`

Field Summary

Fields
Modifier and Type Field and Description

protected StaticScope enclosingScope

Fields
Modifier and Type	Field and Description
`protected StaticScope`	`enclosingScope`

Constructor Summary

Constructors
Modifier Constructor and Description

protected StaticScope(StaticScope enclosingScope, String[] names)
Construct a new static scope.

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

Method Summary

Methods
Modifier and Type	Method and Description
`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
`protected abstract 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
`protected abstract Node`	`declare(ISourcePosition position, String name, int depth)`
`RubyModule`	`determineModule()` Update current scoping structure to populate with proper cref scoping values.
`int`	`exists(String name)` Does the variable exist?
`abstract String[]`	`getAllNamesInScope()` Get all visible variables that we can see from this scope that have been assigned (e.g.
`Arity`	`getArity()`
`IRubyObject`	`getConstant(String internedName)`
`IRubyObject`	`getConstantInner(String internedName)`
`IRubyObject`	`getConstantWithConstMissing(String internedName)`
`DynamicScope`	`getDummyScope()`
`StaticScope`	`getEnclosingScope()` Next outer most scope in list of scopes.
`abstract StaticScope`	`getLocalScope()` Gets the Local Scope relative to the current Scope.
`RubyModule`	`getModule()` Get the live CRef module associated with this scope.
`int`	`getNumberOfVariables()`
`int`	`getOptionalArgs()`
`StaticScope`	`getPreviousCRefScope()`
`int`	`getRequiredArgs()`
`int`	`getRestArg()`
`abstract StaticScope.Type`	`getType()`
`String[]`	`getVariables()`
`abstract boolean`	`isArgumentScope()` Argument scopes represent scopes which contain arguments for zsuper.
`boolean`	`isBlockScope()`
`boolean`	`isConstantDefined(String internedName)`
`int`	`isDefined(String name)` Is this name in the visible to the current scope
`protected abstract int`	`isDefined(String name, int depth)`
`abstract void`	`makeArgumentScope()`
`void`	`setArities(int required, int optional, int rest)`
`IRubyObject`	`setConstant(String internedName, IRubyObject result)`
`void`	`setModule(RubyModule module)`
`void`	`setPreviousCRefScope(StaticScope crefScope)`
`void`	`setRequiredArgs(int requiredArgs)`
`void`	`setRestArg(int restArg)`
`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
```
- Constructor Detail
  - StaticScope
```
protected StaticScope(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:
    enclosingScope - The lexically containing scope.
    names - The list of interned String variable names.
- Method Detail
  - 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)
```
  - getConstantWithConstMissing
```
public IRubyObject getConstantWithConstMissing(String internedName)
```
  - isConstantDefined
```
public boolean isConstantDefined(String internedName)
```
  - getConstant
```
public IRubyObject getConstant(String internedName)
```
  - getConstantInner
```
public IRubyObject getConstantInner(String internedName)
```
  - setConstant
```
public IRubyObject setConstant(String internedName,
                      IRubyObject result)
```
  - 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 abstract 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
```
protected abstract int isDefined(String name,
            int depth)
```
  - assign
```
protected abstract AssignableNode assign(ISourcePosition position,
                    String name,
                    Node value,
                    StaticScope topScope,
                    int depth)
```
  - declare
```
protected abstract 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 abstract 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
  - getOptionalArgs
```
public int getOptionalArgs()
```
  - getRequiredArgs
```
public int getRequiredArgs()
```
  - setRequiredArgs
```
public void setRequiredArgs(int requiredArgs)
```
  - getRestArg
```
public int getRestArg()
```
  - setRestArg
```
public void setRestArg(int restArg)
```
  - isArgumentScope
```
public abstract 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 abstract void makeArgumentScope()
```
  - isBlockScope
```
public boolean isBlockScope()
```
  - getArity
```
public Arity getArity()
```
  - setArities
```
public void setArities(int required,
              int optional,
              int rest)
```
  - getDummyScope
```
public DynamicScope getDummyScope()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getType
```
public abstract StaticScope.Type getType()
```

Class StaticScope

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

enclosingScope

Constructor Detail

StaticScope

Method Detail

addVariableThisScope

addVariable

getVariables

getNumberOfVariables

setVariables

getConstantWithConstMissing

isConstantDefined

getConstant

getConstantInner

setConstant

getEnclosingScope

exists

isDefined

assign

getAllNamesInScope

isDefined

assign

declare

declare

getLocalScope

getModule

getPreviousCRefScope

setPreviousCRefScope

setModule

determineModule

getOptionalArgs

getRequiredArgs

setRequiredArgs

getRestArg

setRestArg

isArgumentScope

makeArgumentScope

isBlockScope

getArity

setArities

getDummyScope

toString

getType