StaticScope (JRuby Core 9.0.0.0.pre1 API)

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

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

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[] 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.
`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.
`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()`
`int`	`getOptionalArgs()`
`StaticScope`	`getPreviousCRefScope()`
`int`	`getRequiredArgs()`
`int`	`getRestArg()`
`int`	`getScopeId()`
`IRScopeType`	`getScopeType()`
`StaticScope.Type`	`getType()`
`String[]`	`getVariables()`
`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
`int`	`isDefined(String name, int depth)`
`void`	`makeArgumentScope()`
`void`	`setArities(int required, int optional, int rest)`
`IRubyObject`	`setConstant(String internedName, IRubyObject result)`
`void`	`setIRScope(IRScope irScope)`
`void`	`setIRScope(IRScope irScope, boolean isForLoopBody)`
`void`	`setModule(RubyModule module)`
`void`	`setPreviousCRefScope(StaticScope crefScope)`
`void`	`setRequiredArgs(int requiredArgs)`
`void`	`setRestArg(int restArg)`
`void`	`setScopeType(IRScopeType scopeType)`
`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)
```
    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()
```
  - getScopeId
```
public int getScopeId()
```
  - getScopeType
```
public IRScopeType getScopeType()
```
  - setScopeType
```
public void setScopeType(IRScopeType scopeType)
```
  - setIRScope
```
public void setIRScope(IRScope irScope,
              boolean isForLoopBody)
```
  - 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)
```
  - 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 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
  - getOptionalArgs
```
public int getOptionalArgs()
```
  - getRequiredArgs
```
public int getRequiredArgs()
```
  - setRequiredArgs
```
public void setRequiredArgs(int requiredArgs)
```
  - getRestArg
```
public int getRestArg()
```
  - setRestArg
```
public void setRestArg(int restArg)
```
  - 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()
```
  - 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 StaticScope.Type getType()
```
  - duplicate
```
public StaticScope duplicate()
```

Class StaticScope

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

enclosingScope

scopeType

Constructor Detail

StaticScope

StaticScope

Method Detail

getIRScope

getScopeId

getScopeType

setScopeType

setIRScope

setIRScope

addVariableThisScope

addVariable

getVariables

getNumberOfVariables

setVariables

getConstantWithConstMissing

isConstantDefined

getConstant

getConstantInner

setConstant

getEnclosingScope

exists

isDefined

assign

getAllNamesInScope

isDefined

addAssign

assign

declare

declare

getLocalScope

getModule

getPreviousCRefScope

setPreviousCRefScope

setModule

determineModule

getOptionalArgs

getRequiredArgs

setRequiredArgs

getRestArg

setRestArg

isBlockScope

isArgumentScope

makeArgumentScope

getArity

setArities

getDummyScope

toString

getType

duplicate