IRScope

java.lang.Object
- org.jruby.ir.IRScope

Direct Known Subclasses:

IRClosure, IRMethod, IRModuleBody, IRScriptBody
```
public abstract class IRScope
extends java.lang.Object
```
Right now, this class abstracts the following execution scopes: Method, Closure, Module, Class, MetaClass Top-level Script, and Eval Script In the compiler-land, IR versions of these scopes encapsulate only as much information as is required to convert Ruby code into equivalent Java code. But, in the non-compiler land, there will be a corresponding java object for some of these scopes which encapsulates the runtime semantics and data needed for implementing them. In the case of Module, Class, MetaClass, and Method, they also happen to be instances of the corresponding Ruby classes -- so, in addition to providing code that help with this specific ruby implementation, they also have code that let them behave as ruby instances of their corresponding classes. Examples: - the runtime class object might have refs. to the runtime method objects. - the runtime method object might have a slot for a heap frame (for when it has closures that need access to the method's local variables), it might have version information, it might have references to other methods that were optimized with the current version number, etc. - the runtime closure object will have a slot for a heap frame (for when it has closures within) and might get reified as a method in the java land (but inaccessible in ruby land). So, passing closures in Java land might be equivalent to passing around the method handles. and so on ...

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class IRScope.LocalVariableAllocator

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`IRScope.LocalVariableAllocator`

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`bindingHasEscaped`
`private boolean`	`canCaptureCallersBinding`
`private boolean`	`canModifyCode`
`protected boolean`	`canReceiveBreaks` Can this scope receive breaks
`boolean`	`canReceiveNonlocalReturns` Can this scope receive a non-local return?
`private CFG`	`cfg` Control flow graph representation of this method's instructions
`private RubyModule`	`containerModule` Live version of module within whose context this method executes
`private TemporaryVariable`	`currentModuleVar` %current_module and %current_scope variables
`private TemporaryVariable`	`currentScopeVar`
`private java.util.Set<Variable>`	`definedLocalVars` Local variables defined in this scope
`private java.util.Map<java.lang.String,DataFlowProblem>`	`dfProbs` Map of name -> dataflow problem
`(package private) IRScope.LocalVariableAllocator`	`evalScopeVars`
`private java.lang.String`	`fileName` File within which this scope has been defined
`private boolean`	`flagsComputed` Have scope flags been computed?
`private static java.lang.Integer`	`globalScopeCount`
`protected boolean`	`hasBreakInstrs` Does this scope have a break instr?
`private boolean`	`hasExplicitCallProtocol` Does this scope have explicit call protocol instructions? If yes, there are IR instructions for managing bindings/frames, etc.
`private boolean`	`hasLoops` Does this scope have loops?
`protected boolean`	`hasNonlocalReturns` Does this scope have a non-local return instr?
`private boolean`	`hasUnusedImplicitBlockArg` Is %block implicit block arg unused?
`private java.util.List<Instr>`	`instrList` List of IR instructions for this method
`(package private) java.util.List<IRScope>`	`lexicalChildren`
`private IRScope`	`lexicalParent` Lexical parent scope
`private java.util.List<BasicBlock>`	`linearizedBBList`
`private Instr[]`	`linearizedInstrArray`
`private int`	`lineNumber` Starting line for this scope's definition
`(package private) IRScope.LocalVariableAllocator`	`localVars`
`private static Logger`	`LOG`
`private IRManager`	`manager`
`private java.lang.String`	`name` Name
`private java.util.List<IRClosure>`	`nestedClosures` List of (nested) closures in this scope
`private int`	`nextClosureIndex`
`private java.util.Map<java.lang.String,java.lang.Integer>`	`nextVarIndex` Keeps track of types of prefix indexes for variables and labels
`private boolean`	`receivesKeywordArgs` Does this scope receive keyword args?
`private boolean`	`relinearizeCFG` Should we re-run compiler passes -- yes after we've inlined, for example
`private int`	`scopeId` Unique global scope id
`private StaticScope`	`staticScope` Parser static-scope that this IR scope corresponds to
`protected int`	`temporaryVariableIndex`
`private int`	`threadPollInstrsCount` # of thread poll instrs added to this scope
`private java.util.Set<Variable>`	`usedLocalVars` Local variables used in this scope
`private boolean`	`usesBackrefOrLastline` Since backref ($~) and lastline ($_) vars are allocated space on the dynamic scope, this is an useful flag to compute.
`private boolean`	`usesEval` Does this scope call any eval
`private boolean`	`usesZSuper` Does this scope call any zsuper

Constructor Summary

Constructors
Modifier	Constructor and Description
	`IRScope(IRManager manager, IRScope lexicalParent, java.lang.String name, java.lang.String fileName, int lineNumber, StaticScope staticScope)`
`protected`	`IRScope(IRScope s, IRScope lexicalParent)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addChildScope(IRScope scope)`
`void`	`addClosure(IRClosure c)`
`void`	`addInstr(Instr i)`
`void`	`addInstrAtBeginning(Instr i)`
`protected int`	`allocateNextPrefixedName(java.lang.String prefix)`
`boolean`	`bindingHasEscaped()`
`CFG`	`buildCFG()`
`void`	`buildCFG(java.util.List<Instr> instrList)`
`private java.util.List<java.lang.Object[]>`	`buildJVMExceptionTable()`
`java.util.List<BasicBlock>`	`buildLinearization()`
`boolean`	`canCaptureCallersBinding()`
`boolean`	`canReceiveNonlocalReturns()`
`private static Label[]`	`catLabels(Label[] labels, Label cat)`
`CFG`	`cfg()`
`void`	`checkRelinearization()`
`void`	`computeScopeFlags()`
`private boolean`	`computeScopeFlags(boolean receivesClosureArg, java.util.List<Instr> instrs)`
`boolean`	`definesLocalVariable(Variable v)`
`protected void`	`depends(java.lang.Object obj)`
`boolean`	`equals(java.lang.Object other)`
`LocalVariable`	`findExistingLocalVariable(java.lang.String name, int depth)`
`CFG`	`getCFG()`
`java.util.List<IRClosure>`	`getClosures()`
`RubyModule`	`getContainerModule()`
`Variable`	`getCurrentModuleVariable()`
`Variable`	`getCurrentScopeVariable()`
`DataFlowProblem`	`getDataFlowSolution(java.lang.String name)`
`int`	`getEnsurerPC(Instr excInstr)`
`java.lang.String`	`getFileName()`
`abstract LocalVariable`	`getImplicitBlockArg()`
`java.util.List<Instr>`	`getInstrs()`
`Instr[]`	`getInstrsForInterpretation()`
`Instr`	`getLastInstr()`
`IRScope`	`getLexicalParent()` Returns the lexical scope that contains this scope definition
`java.util.List<IRScope>`	`getLexicalScopes()`
`int`	`getLineNumber()`
`LocalVariable`	`getLocalVariable(java.lang.String name, int scopeDepth)` Find or create a local variable.
`int`	`getLocalVariablesCount()`
`IRManager`	`getManager()`
`java.lang.String`	`getName()`
`IRScope`	`getNearestFlipVariableScope()`
`IRMethod`	`getNearestMethod()`
`IRScope`	`getNearestModuleReferencingScope()` Returns the nearest scope which we can extract a live module from.
`IRScope`	`getNearestTopLocalVariableScope()`
`LocalVariable`	`getNewFlipStateVariable()`
`Variable`	`getNewInlineVariable(java.lang.String inlinePrefix, Variable v)`
`Label`	`getNewLabel()`
`Label`	`getNewLabel(java.lang.String prefix)`
`LocalVariable`	`getNewLocalVariable(java.lang.String name, int depth)`
`TemporaryVariable`	`getNewTemporaryVariable()`
`TemporaryVariable`	`getNewTemporaryVariable(java.lang.String name)`
`int`	`getNextClosureId()`
`protected int`	`getPrefixCountSize(java.lang.String prefix)`
`int`	`getRescuerPC(Instr excInstr)`
`int`	`getScopeId()`
`abstract java.lang.String`	`getScopeName()`
`LocalVariable`	`getSelf()` --------------------------------------- SSS FIXME: What is this method for?
`StaticScope`	`getStaticScope()`
`int`	`getTemporaryVariableSize()`
`int`	`getThreadPollInstrsCount()`
`IRScope`	`getTopLevelScope()` Returns the top level scope
`int`	`getUsedVariablesCount()`
`boolean`	`hasExplicitCallProtocol()`
`int`	`hashCode()`
`private boolean`	`hasListener()`
`boolean`	`hasLoops()`
`protected void`	`initEvalScopeVariableAllocator(boolean reset)`
`void`	`initFlipStateVariable(Variable v, Operand initState)`
`void`	`inlineMethod(IRScope method, RubyModule implClass, int classToken, BasicBlock basicBlock, CallBase call)`
`boolean`	`isFlipScope()`
`boolean`	`isForLoopBody()`
`boolean`	`isModuleBody()` Does this scope represent a module body? (SSS FIXME: what about script or eval script bodies?)
`boolean`	`isNestedInClosure(IRClosure closure)`
`boolean`	`isNonSingletonClassBody()` Is this IRClassBody but not IRMetaClassBody?
`boolean`	`isScriptScope()` Is this an eval script or a regular file script?
`boolean`	`isTopLocalVariableScope()`
`java.util.List<BasicBlock>`	`linearization()`
`void`	`markUnusedImplicitBlockArg()`
`boolean`	`modifiesCode()`
`Tuple<Instr[],java.util.Map<java.lang.Integer,Label[]>>`	`prepareForCompilation()` Run any necessary passes to get the IR ready for compilation
`Instr[]`	`prepareForInterpretation(boolean isLambda)` Run any necessary passes to get the IR ready for interpretation
`private Instr[]`	`prepareInstructionsForInterpretation()`
`boolean`	`receivesKeywordArgs()`
`void`	`recordBeginBlock(IRClosure beginBlockClosure)`
`void`	`recordEndBlock(IRClosure endBlockClosure)`
`void`	`resetCFG()`
`void`	`resetDFProblemsState()`
`void`	`resetLinearizationData()`
`void`	`resetState()`
`void`	`resetTemporaryVariables()`
`protected void`	`resetVariableCounter(java.lang.String prefix)`
`private void`	`runCompilerPasses()`
`protected void`	`setCFG(CFG cfg)`
`void`	`setCodeModificationFlag(boolean f)`
`void`	`setDataFlowSolution(java.lang.String name, DataFlowProblem p)`
`void`	`setExplicitCallProtocolFlag(boolean flag)`
`void`	`setHasLoopsFlag(boolean f)`
`void`	`setName(java.lang.String name)`
`private void`	`setupLabelPCs(java.util.HashMap<Label,java.lang.Integer> labelIPCMap)`
`private void`	`setupLexicalContainment()`
`void`	`setUpUseDefLocalVarMaps()`
`void`	`splitCalls()`
`java.lang.String`	`toPersistableString()`
`java.lang.String`	`toString()`
`java.lang.String`	`toStringInstrs()`
`java.lang.String`	`toStringVariables()`
`boolean`	`usesBackrefOrLastline()`
`boolean`	`usesEval()`
`boolean`	`usesLocalVariable(Variable v)`
`boolean`	`usesZSuper()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail
- LOG
```
private static final Logger LOG
```
- globalScopeCount
```
private static java.lang.Integer globalScopeCount
```
- scopeId
```
private int scopeId
```
  Unique global scope id
- name
```
private java.lang.String name
```
  Name
- fileName
```
private final java.lang.String fileName
```
  File within which this scope has been defined
- lineNumber
```
private final int lineNumber
```
  Starting line for this scope's definition
- lexicalParent
```
private IRScope lexicalParent
```
  Lexical parent scope
- staticScope
```
private StaticScope staticScope
```
  Parser static-scope that this IR scope corresponds to
- containerModule
```
private RubyModule containerModule
```
  Live version of module within whose context this method executes
- instrList
```
private java.util.List<Instr> instrList
```
  List of IR instructions for this method
- cfg
```
private CFG cfg
```
  Control flow graph representation of this method's instructions
- nestedClosures
```
private java.util.List<IRClosure> nestedClosures
```
  List of (nested) closures in this scope
- definedLocalVars
```
private java.util.Set<Variable> definedLocalVars
```
  Local variables defined in this scope
- usedLocalVars
```
private java.util.Set<Variable> usedLocalVars
```
  Local variables used in this scope
- hasUnusedImplicitBlockArg
```
private boolean hasUnusedImplicitBlockArg
```
  Is %block implicit block arg unused?
- currentModuleVar
```
private TemporaryVariable currentModuleVar
```
  %current_module and %current_scope variables
- currentScopeVar
```
private TemporaryVariable currentScopeVar
```
- dfProbs
```
private java.util.Map<java.lang.String,DataFlowProblem> dfProbs
```
  Map of name -> dataflow problem
- linearizedInstrArray
```
private Instr[] linearizedInstrArray
```
- linearizedBBList
```
private java.util.List<BasicBlock> linearizedBBList
```
- temporaryVariableIndex
```
protected int temporaryVariableIndex
```
- nextVarIndex
```
private java.util.Map<java.lang.String,java.lang.Integer> nextVarIndex
```
  Keeps track of types of prefix indexes for variables and labels
- nextClosureIndex
```
private int nextClosureIndex
```
- lexicalChildren
```
java.util.List<IRScope> lexicalChildren
```
- localVars
```
IRScope.LocalVariableAllocator localVars
```
- evalScopeVars
```
IRScope.LocalVariableAllocator evalScopeVars
```
- flagsComputed
```
private boolean flagsComputed
```
  Have scope flags been computed?
- canCaptureCallersBinding
```
private boolean canCaptureCallersBinding
```
- canModifyCode
```
private boolean canModifyCode
```
- bindingHasEscaped
```
private boolean bindingHasEscaped
```
- usesEval
```
private boolean usesEval
```
  Does this scope call any eval
- receivesKeywordArgs
```
private boolean receivesKeywordArgs
```
  Does this scope receive keyword args?
- hasBreakInstrs
```
protected boolean hasBreakInstrs
```
  Does this scope have a break instr?
- canReceiveBreaks
```
protected boolean canReceiveBreaks
```
  Can this scope receive breaks
- hasNonlocalReturns
```
protected boolean hasNonlocalReturns
```
  Does this scope have a non-local return instr?
- canReceiveNonlocalReturns
```
public boolean canReceiveNonlocalReturns
```
  Can this scope receive a non-local return?
- usesBackrefOrLastline
```
private boolean usesBackrefOrLastline
```
  Since backref ($~) and lastline ($_) vars are allocated space on the dynamic scope, this is an useful flag to compute.
- usesZSuper
```
private boolean usesZSuper
```
  Does this scope call any zsuper
- hasLoops
```
private boolean hasLoops
```
  Does this scope have loops?
- threadPollInstrsCount
```
private int threadPollInstrsCount
```
  # of thread poll instrs added to this scope
- hasExplicitCallProtocol
```
private boolean hasExplicitCallProtocol
```
  Does this scope have explicit call protocol instructions? If yes, there are IR instructions for managing bindings/frames, etc. If not, this has to be managed implicitly as in the current runtime For now, only dyn-scopes are managed explicitly. Others will come in time
- relinearizeCFG
```
private boolean relinearizeCFG
```
  Should we re-run compiler passes -- yes after we've inlined, for example
- manager
```
private IRManager manager
```

Constructor Detail

IRScope

protected IRScope(IRScope s,
                  IRScope lexicalParent)

IRScope

public IRScope(IRManager manager,
               IRScope lexicalParent,
               java.lang.String name,
               java.lang.String fileName,
               int lineNumber,
               StaticScope staticScope)

Method Detail

setupLexicalContainment

private final void setupLexicalContainment()

hasListener
```
private boolean hasListener()
```

getScopeId
```
public int getScopeId()
```

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

equals

public boolean equals(java.lang.Object other)

Overrides:: equals in class java.lang.Object

addChildScope

protected void addChildScope(IRScope scope)

getLexicalScopes

public java.util.List<IRScope> getLexicalScopes()

addClosure
```
public void addClosure(IRClosure c)
```

getLastInstr
```
public Instr getLastInstr()
```

addInstrAtBeginning

public void addInstrAtBeginning(Instr i)

addInstr
```
public void addInstr(Instr i)
```

getNewFlipStateVariable

public LocalVariable getNewFlipStateVariable()

initFlipStateVariable

public void initFlipStateVariable(Variable v,
                                  Operand initState)

isForLoopBody
```
public boolean isForLoopBody()
```

getNewLabel

public Label getNewLabel(java.lang.String prefix)

getNewLabel
```
public Label getNewLabel()
```

getClosures

public java.util.List<IRClosure> getClosures()

getManager
```
public IRManager getManager()
```

getLexicalParent
```
public IRScope getLexicalParent()
```
Returns the lexical scope that contains this scope definition

getStaticScope
```
public StaticScope getStaticScope()
```

getNearestMethod
```
public IRMethod getNearestMethod()
```

getNearestFlipVariableScope

public IRScope getNearestFlipVariableScope()

getNearestTopLocalVariableScope

public IRScope getNearestTopLocalVariableScope()

getNearestModuleReferencingScope
```
public IRScope getNearestModuleReferencingScope()
```
Returns the nearest scope which we can extract a live module from. If this returns null (like for evals), then it means it cannot be statically determined.

getName
```
public java.lang.String getName()
```

setName

public void setName(java.lang.String name)

getFileName
```
public java.lang.String getFileName()
```

getLineNumber
```
public int getLineNumber()
```

getTopLevelScope
```
public IRScope getTopLevelScope()
```
Returns the top level scope

isNestedInClosure

public boolean isNestedInClosure(IRClosure closure)

setHasLoopsFlag

public void setHasLoopsFlag(boolean f)

hasLoops
```
public boolean hasLoops()
```

hasExplicitCallProtocol

public boolean hasExplicitCallProtocol()

setExplicitCallProtocolFlag

public void setExplicitCallProtocolFlag(boolean flag)

setCodeModificationFlag

public void setCodeModificationFlag(boolean f)

receivesKeywordArgs
```
public boolean receivesKeywordArgs()
```

modifiesCode
```
public boolean modifiesCode()
```

bindingHasEscaped
```
public boolean bindingHasEscaped()
```

usesBackrefOrLastline

public boolean usesBackrefOrLastline()

usesEval
```
public boolean usesEval()
```

usesZSuper
```
public boolean usesZSuper()
```

canCaptureCallersBinding

public boolean canCaptureCallersBinding()

canReceiveNonlocalReturns

public boolean canReceiveNonlocalReturns()

buildCFG
```
public CFG buildCFG()
```

setCFG
```
protected void setCFG(CFG cfg)
```

getCFG
```
public CFG getCFG()
```

setupLabelPCs

private void setupLabelPCs(java.util.HashMap<Label,java.lang.Integer> labelIPCMap)

prepareInstructionsForInterpretation

private Instr[] prepareInstructionsForInterpretation()

runCompilerPasses
```
private void runCompilerPasses()
```

prepareForInterpretation
```
public Instr[] prepareForInterpretation(boolean isLambda)
```
Run any necessary passes to get the IR ready for interpretation

prepareForCompilation

public Tuple<Instr[],java.util.Map<java.lang.Integer,Label[]>> prepareForCompilation()

Run any necessary passes to get the IR ready for compilation

buildJVMExceptionTable

private java.util.List<java.lang.Object[]> buildJVMExceptionTable()

catLabels

private static Label[] catLabels(Label[] labels,
                                 Label cat)

computeScopeFlags

private boolean computeScopeFlags(boolean receivesClosureArg,
                                  java.util.List<Instr> instrs)

computeScopeFlags
```
public void computeScopeFlags()
```

getScopeName

public abstract java.lang.String getScopeName()

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

toStringInstrs

public java.lang.String toStringInstrs()

toPersistableString

public java.lang.String toPersistableString()

toStringVariables

public java.lang.String toStringVariables()

getSelf
```
public LocalVariable getSelf()
```
--------------------------------------- SSS FIXME: What is this method for?

getCurrentModuleVariable

public Variable getCurrentModuleVariable()

getCurrentScopeVariable

public Variable getCurrentScopeVariable()

getImplicitBlockArg

public abstract LocalVariable getImplicitBlockArg()

markUnusedImplicitBlockArg

public void markUnusedImplicitBlockArg()

findExistingLocalVariable

public LocalVariable findExistingLocalVariable(java.lang.String name,
                                               int depth)

getLocalVariable
```
public LocalVariable getLocalVariable(java.lang.String name,
                                      int scopeDepth)
```
Find or create a local variable. By default, scopes are assumed to only check current depth. Blocks/Closures override this because they have special nesting rules.

getNewLocalVariable

public LocalVariable getNewLocalVariable(java.lang.String name,
                                         int depth)

initEvalScopeVariableAllocator

protected void initEvalScopeVariableAllocator(boolean reset)

getNewTemporaryVariable

public TemporaryVariable getNewTemporaryVariable()

getNewTemporaryVariable

public TemporaryVariable getNewTemporaryVariable(java.lang.String name)

resetTemporaryVariables
```
public void resetTemporaryVariables()
```

getTemporaryVariableSize
```
public int getTemporaryVariableSize()
```

getNewInlineVariable

public Variable getNewInlineVariable(java.lang.String inlinePrefix,
                                     Variable v)

getThreadPollInstrsCount
```
public int getThreadPollInstrsCount()
```

getLocalVariablesCount
```
public int getLocalVariablesCount()
```

getUsedVariablesCount
```
public int getUsedVariablesCount()
```

setUpUseDefLocalVarMaps
```
public void setUpUseDefLocalVarMaps()
```

usesLocalVariable

public boolean usesLocalVariable(Variable v)

definesLocalVariable

public boolean definesLocalVariable(Variable v)

setDataFlowSolution

public void setDataFlowSolution(java.lang.String name,
                                DataFlowProblem p)

getDataFlowSolution

public DataFlowProblem getDataFlowSolution(java.lang.String name)

getInstrs

public java.util.List<Instr> getInstrs()

getInstrsForInterpretation

public Instr[] getInstrsForInterpretation()

resetLinearizationData
```
public void resetLinearizationData()
```

checkRelinearization
```
public void checkRelinearization()
```

buildLinearization

public java.util.List<BasicBlock> buildLinearization()

getRescuerPC

public int getRescuerPC(Instr excInstr)

getEnsurerPC

public int getEnsurerPC(Instr excInstr)

linearization

public java.util.List<BasicBlock> linearization()

depends

protected void depends(java.lang.Object obj)

cfg
```
public CFG cfg()
```

splitCalls
```
public void splitCalls()
```

resetDFProblemsState
```
public void resetDFProblemsState()
```

resetState
```
public void resetState()
```

inlineMethod

public void inlineMethod(IRScope method,
                         RubyModule implClass,
                         int classToken,
                         BasicBlock basicBlock,
                         CallBase call)

buildCFG

public void buildCFG(java.util.List<Instr> instrList)

resetCFG
```
public void resetCFG()
```

recordBeginBlock

public void recordBeginBlock(IRClosure beginBlockClosure)

recordEndBlock

public void recordEndBlock(IRClosure endBlockClosure)

allocateNextPrefixedName

protected int allocateNextPrefixedName(java.lang.String prefix)

resetVariableCounter

protected void resetVariableCounter(java.lang.String prefix)

getPrefixCountSize

protected int getPrefixCountSize(java.lang.String prefix)

getContainerModule

public RubyModule getContainerModule()

getNextClosureId
```
public int getNextClosureId()
```

isModuleBody
```
public boolean isModuleBody()
```
Does this scope represent a module body? (SSS FIXME: what about script or eval script bodies?)

isNonSingletonClassBody
```
public boolean isNonSingletonClassBody()
```
Is this IRClassBody but not IRMetaClassBody?

isFlipScope
```
public boolean isFlipScope()
```

isTopLocalVariableScope

public boolean isTopLocalVariableScope()

isScriptScope
```
public boolean isScriptScope()
```
Is this an eval script or a regular file script?

Class IRScope

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

globalScopeCount

scopeId

name

fileName

lineNumber

lexicalParent

staticScope

containerModule

instrList

cfg

nestedClosures

definedLocalVars

usedLocalVars

hasUnusedImplicitBlockArg

currentModuleVar

currentScopeVar

dfProbs

linearizedInstrArray

linearizedBBList

temporaryVariableIndex

nextVarIndex

nextClosureIndex

lexicalChildren

localVars

evalScopeVars

flagsComputed

canCaptureCallersBinding

canModifyCode

bindingHasEscaped

usesEval

receivesKeywordArgs

hasBreakInstrs

canReceiveBreaks

hasNonlocalReturns

canReceiveNonlocalReturns

usesBackrefOrLastline

usesZSuper

hasLoops

threadPollInstrsCount

hasExplicitCallProtocol

relinearizeCFG

manager

Constructor Detail

IRScope

IRScope

Method Detail

setupLexicalContainment

hasListener

getScopeId

hashCode

equals

addChildScope

getLexicalScopes

addClosure

getLastInstr

addInstrAtBeginning

addInstr

getNewFlipStateVariable

initFlipStateVariable

isForLoopBody

getNewLabel

getNewLabel

getClosures

getManager

getLexicalParent

getStaticScope

getNearestMethod

getNearestFlipVariableScope

getNearestTopLocalVariableScope

getNearestModuleReferencingScope

getName

setName