rsense-core 0.5.0

data/src/org/cx4a/rsense/typing/runtime/ObjectAllocator.java

@@ -0,0 +1,40 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.util.Map;
+import java.util.HashMap;
+
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.RubyClass;
+import org.cx4a.rsense.ruby.RubyObject;
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.typing.annotation.ClassType;
+
+public class ObjectAllocator implements Ruby.ObjectAllocator {
+    private Map<RubyClass, IRubyObject> instances;
+
+    public ObjectAllocator() {
+        instances = new HashMap<RubyClass, IRubyObject>();
+    }
+
+    public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+        ClassType classType = RuntimeHelper.getClassAnnotation(klass);
+        if (classType != null && classType.isPolymorphic()) {
+            return newPolymorphicInstance(runtime, klass, classType);
+        } else {
+            return newMonomorphicInstance(runtime, klass);
+        }
+    }
+
+    public IRubyObject newPolymorphicInstance(Ruby runtime, RubyClass klass, ClassType type) {
+        return new PolymorphicObject(runtime, klass);
+    }
+
+    public IRubyObject newMonomorphicInstance(Ruby runtime, RubyClass klass) {
+        IRubyObject instance = instances.get(klass);
+        if (instance == null) {
+            instance = new RubyObject(runtime, klass);
+            instances.put(klass, instance);
+        }
+        return instance;
+    }
+}

data/src/org/cx4a/rsense/typing/runtime/PolymorphicObject.java

@@ -0,0 +1,90 @@
+package org.cx4a.rsense.typing.runtime;
+
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.RubyClass;
+import org.cx4a.rsense.ruby.RubyObject;
+
+public class PolymorphicObject extends RubyObject {
+    // data polymorphic modified?
+    private boolean modified = false;
+    private long modifiedTime;
+
+    public PolymorphicObject(Ruby runtime) {
+        this(runtime, runtime.getObject());
+    }
+
+    public PolymorphicObject(Ruby runtime, RubyClass metaClass) {
+        this(runtime, metaClass, new TypeVarMap());
+    }
+
+    protected PolymorphicObject(Ruby runtime, RubyClass metaClass, TypeVarMap tvmap) {
+        super(runtime, metaClass);
+        setTag(tvmap);
+    }
+
+    public TypeVarMap getTypeVarMap() {
+        return (TypeVarMap) getTag();
+    }
+
+    public boolean isModified() {
+        return modified;
+    }
+
+    public long getModifiedTime() {
+        return modifiedTime;
+    }
+
+    public void setModified(boolean modified) {
+        this.modified = modified;
+        this.modifiedTime = System.currentTimeMillis();
+    }
+
+    public MonomorphicObject[] generateMonomorphicObjects() {
+        TypeVarMap[] tvmaps = getTypeVarMap().generateTuples();
+        if (tvmaps.length == 0) {
+            return new MonomorphicObject[] { new MonomorphicObject(this, getTypeVarMap()) };
+        } else {
+            MonomorphicObject[] result = new MonomorphicObject[tvmaps.length];
+            for (int i = 0; i < tvmaps.length; i++) {
+                result[i] = new MonomorphicObject(this, tvmaps[i]);
+            }
+            return result;
+        }
+    }
+
+    public PolymorphicObject clone() {
+        return new PolymorphicObject(runtime, metaClass, getTypeVarMap().clone());
+    }
+
+    @Override
+    public int hashCode() {
+        return hashCode(1);
+    }
+
+    @Override
+    public int hashCode(int depth) {
+        if (depth > 2)
+            // Approximate hash code for nested polymorphic object
+            return getMetaClass().hashCode();
+        else
+            return getMetaClass().hashCode() ^ getTypeVarMap().hashCode(depth + 1);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other)
+            return true;
+
+        if (!(other instanceof PolymorphicObject))
+            return false;
+
+        PolymorphicObject o = (PolymorphicObject) other;
+        return getMetaClass() == o.getMetaClass()
+            && getTypeVarMap().equals(o.getTypeVarMap());
+    }
+
+    @Override
+    public String toString() {
+        return "<pobj:" + getMetaClass().toString() + getTypeVarMap() + ">";
+    }
+}

data/src/org/cx4a/rsense/typing/runtime/Proc.java

@@ -0,0 +1,100 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Collections;
+
+import org.jrubyparser.ast.Node;
+
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.ruby.Frame;
+import org.cx4a.rsense.ruby.Scope;
+import org.cx4a.rsense.ruby.RubyObject;
+import org.cx4a.rsense.typing.vertex.YieldVertex;
+import org.cx4a.rsense.util.NodeUtil;
+
+public class Proc extends RubyObject implements Block {
+    private Node varNode;
+    private Node bodyNode;
+    private Frame frame;
+    private Scope scope;
+    private Set<YieldVertex> yields;
+    private int varNodeHashCode, bodyNodeHashCode;
+
+    public Proc(Ruby runtime, Node varNode, Node bodyNode, Frame frame, Scope scope) {
+        super(runtime, runtime.getProc());
+        this.varNode = varNode;
+        this.bodyNode = bodyNode;
+        this.frame = frame;
+        this.scope = scope;
+        this.varNodeHashCode = 0;
+        this.bodyNodeHashCode = 0;
+    }
+
+    public Node getVarNode() {
+        return varNode;
+    }
+
+    public Node getBodyNode() {
+        return bodyNode;
+    }
+
+    public int getVarNodeHashCode() {
+        if (varNodeHashCode == 0) {
+            varNodeHashCode = NodeUtil.nodeHashCode(varNode);
+        }
+        return varNodeHashCode;
+    }
+
+    public int getBodyNodeHashCode() {
+        if (bodyNodeHashCode == 0) {
+            bodyNodeHashCode = NodeUtil.nodeHashCode(bodyNode);
+        }
+        return bodyNodeHashCode;
+    }
+
+    public Frame getFrame() {
+        return frame;
+    }
+
+    public Scope getScope() {
+        return scope;
+    }
+
+    public Set<YieldVertex> getYields() {
+        return yields != null ? yields : Collections.<YieldVertex>emptySet();
+    }
+
+    public boolean recordYield(YieldVertex vertex) {
+        if (yields == null) {
+            yields = new HashSet<YieldVertex>();
+        }
+        return yields.add(vertex);
+    }
+
+    public boolean isApplied(YieldVertex vertex) {
+        return yields != null && yields.contains(vertex);
+    }
+
+    @Override
+    public int hashCode() {
+        return getVarNodeHashCode() ^ getBodyNodeHashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+
+        if (!(other instanceof Proc)) {
+            return false;
+        }
+
+        Proc o = (Proc) other;
+        return hashCode() == o.hashCode()
+            && frame.equals(o.frame)
+            && scope.equals(o.scope);
+    }
+}

data/src/org/cx4a/rsense/typing/runtime/RuntimeHelper.java

@@ -0,0 +1,1339 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.jrubyparser.LocalStaticScope;
+import org.jrubyparser.SourcePosition;
+import org.jrubyparser.ast.*;
+
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.ruby.Context;
+import org.cx4a.rsense.ruby.DynamicMethod;
+import org.cx4a.rsense.ruby.DynamicScope;
+import org.cx4a.rsense.ruby.Frame;
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.ruby.LocalScope;
+import org.cx4a.rsense.ruby.MetaClass;
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.RubyClass;
+import org.cx4a.rsense.ruby.RubyModule;
+import org.cx4a.rsense.ruby.Scope;
+import org.cx4a.rsense.ruby.Visibility;
+import org.cx4a.rsense.typing.Graph;
+import org.cx4a.rsense.typing.Template;
+import org.cx4a.rsense.typing.TemplateAttribute;
+import org.cx4a.rsense.typing.TypeSet;
+import org.cx4a.rsense.typing.annotation.ClassType;
+import org.cx4a.rsense.typing.annotation.MethodType;
+import org.cx4a.rsense.typing.annotation.TypeAnnotation;
+import org.cx4a.rsense.typing.annotation.TypeExpression;
+import org.cx4a.rsense.typing.annotation.TypeVariable;
+import org.cx4a.rsense.typing.vertex.CallVertex;
+import org.cx4a.rsense.typing.vertex.MultipleAsgnVertex;
+import org.cx4a.rsense.typing.vertex.PassThroughVertex;
+import org.cx4a.rsense.typing.vertex.SValueVertex;
+import org.cx4a.rsense.typing.vertex.SplatVertex;
+import org.cx4a.rsense.typing.vertex.ToAryVertex;
+import org.cx4a.rsense.typing.vertex.TypeVarVertex;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.vertex.YieldVertex;
+import org.cx4a.rsense.util.Logger;
+import org.cx4a.rsense.util.SourceLocation;
+import org.jrubyparser.util.diff.Change;
+import org.jrubyparser.util.diff.IsJunk;
+
+public class RuntimeHelper {
+    public static final String TYPE_INFERENCE_METHOD_NAME = "__rsense_type_inference__";
+    public static final String FIND_DEFINITION_METHOD_NAME_PREFIX = "__rsense_find_definition__";
+
+    private RuntimeHelper() {}
+
+    public static Vertex assign(Graph graph, Node node) {
+        return assign(graph, node);
+    }
+
+    public static Vertex assign(Graph graph, Node node, Vertex src) {
+        switch (node.getNodeType()) {
+        case LOCALASGNNODE:
+            return localAssign(graph, (LocalAsgnNode) node, src);
+        case DASGNNODE:
+            return dynamicAssign(graph, (DAsgnNode) node, src);
+        case INSTASGNNODE:
+            return instanceAssign(graph, (InstAsgnNode) node, src);
+        case CONSTDECLNODE:
+            return constDeclaration(graph, (ConstDeclNode) node, src);
+        case CLASSVARASGNNODE:
+            return classVarAssign(graph, (ClassVarAsgnNode) node, src);
+        case CLASSVARDECLNODE:
+            return classVarDeclaration(graph, (ClassVarDeclNode) node, src);
+        case ARGUMENTNODE:
+        case RESTARG:
+            return argumentAssign(graph, (ArgumentNode) node, src);
+        }
+        Logger.error("unknown assignable node: %s", node);
+        Logger.message("Type: %s", node.getNodeType());
+        throw new RuntimeException("Unknown: " + node);
+//        return Vertex.EMPTY;
+    }
+
+    public static Vertex localAssign(Graph graph, LocalAsgnNode node) {
+        return localAssign(graph, node, null);
+    }
+
+    public static Vertex localAssign(Graph graph, LocalAsgnNode node, Vertex src) {
+        Scope scope = graph.getRuntime().getContext().getCurrentScope();
+        VertexHolder holder = (VertexHolder) scope.getValue(node.getName());
+        if (src == null) {
+            src = graph.createVertex(node.getValue());
+        }
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            scope.setValue(node.getName(), holder);
+        }
+        graph.addEdgeAndPropagate(src, holder.getVertex());
+        return src;
+    }
+
+    public static Vertex dynamicAssign(Graph graph, DAsgnNode node) {
+        return dynamicAssign(graph, node, null);
+    }
+
+    public static Vertex dynamicAssign(Graph graph, Node node, Vertex src) {
+        Scope scope = graph.getRuntime().getContext().getCurrentScope();
+        if (node.getNodeType() == NodeType.DASGNNODE) {
+            DAsgnNode dAsgnNode = (DAsgnNode) node;
+
+            VertexHolder holder = (VertexHolder) scope.getValue(dAsgnNode.getName());
+            if (src == null) {
+                src = graph.createVertex(dAsgnNode.getValue());
+            }
+            if (holder == null) {
+                holder = graph.createFreeVertexHolder();
+                scope.setValue(dAsgnNode.getName(), holder);
+            }
+            graph.addEdgeAndPropagate(src, holder.getVertex());
+            return src;
+
+        } else {
+            ArgumentNode argumentNode = (ArgumentNode) node;
+
+            VertexHolder holder = (VertexHolder) scope.getValue(argumentNode.getName());
+            if (src == null) {
+                src = graph.createVertex(null);
+            }
+            if (holder == null) {
+                holder = graph.createFreeVertexHolder();
+                scope.setValue(argumentNode.getName(), holder);
+            }
+            graph.addEdgeAndPropagate(src, holder.getVertex());
+            return src;
+
+        }
+
+    }
+
+
+    public static Vertex instanceAssign(Graph graph, InstAsgnNode node) {
+        return instanceAssign(graph, node, null);
+    }
+
+    public static Vertex instanceAssign(Graph graph, InstAsgnNode node, Vertex src) {
+        IRubyObject self = graph.getRuntime().getContext().getFrameSelf();
+        VertexHolder holder = (VertexHolder) self.getInstVar(node.getName());
+        if (src == null) {
+            src = graph.createVertex(node.getValue());
+        }
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            self.setInstVar(node.getName(), holder);
+        }
+        graph.addEdgeAndPropagate(src, holder.getVertex());
+        return src;
+    }
+
+
+    public static Vertex instanceVariable(Graph graph, InstVarNode node) {
+        IRubyObject self = graph.getRuntime().getContext().getFrameSelf();
+        VertexHolder holder = (VertexHolder) self.getInstVar(node.getName());
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            self.setInstVar(node.getName(), holder);
+        }
+        return holder.getVertex();
+    }
+
+    public static Vertex classVarDeclaration(Graph graph, ClassVarDeclNode node) {
+        return classVarDeclaration(graph, node, null);
+    }
+
+    public static Vertex classVarDeclaration(Graph graph, ClassVarDeclNode node, Vertex src) {
+        RubyModule klass = graph.getRuntime().getContext().getFrameModule();
+        if (src == null) {
+            src = graph.createVertex(node.getValue());
+        }
+        VertexHolder holder = (VertexHolder) klass.getClassVar(node.getName());
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            klass.setClassVar(node.getName(), holder);
+        }
+        // Clear older types (performance issue)
+        holder.getVertex().getTypeSet().clear();
+        graph.addEdgeAndPropagate(src, holder.getVertex());
+        return src;
+    }
+
+    public static Vertex classVarAssign(Graph graph, ClassVarAsgnNode node) {
+        return classVarAssign(graph, node, null);
+    }
+
+    public static Vertex classVarAssign(Graph graph, ClassVarAsgnNode node, Vertex src) {
+        RubyModule klass = graph.getRuntime().getContext().getFrameModule();
+        if (src == null) {
+            src = graph.createVertex(node.getValue());
+        }
+        VertexHolder holder = (VertexHolder) klass.getClassVar(node.getName());
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            klass.setClassVar(node.getName(), holder);
+        }
+        // Clear older types (performance issue)
+        holder.getVertex().getTypeSet().clear();
+        graph.addEdgeAndPropagate(src, holder.getVertex());
+        return src;
+    }
+
+    public static Vertex classVariable(Graph graph, ClassVarNode node) {
+        RubyModule klass = graph.getRuntime().getContext().getFrameModule();
+        VertexHolder holder = (VertexHolder) klass.getClassVar(node.getName());
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            klass.setClassVar(node.getName(), holder);
+        }
+        return holder.getVertex();
+    }
+
+    public static Vertex constDeclaration(Graph graph, ConstDeclNode node) {
+        return constDeclaration(graph, node, null);
+    }
+
+    public static Vertex constDeclaration(Graph graph, ConstDeclNode node, Vertex src) {
+        RubyModule module = null;
+        String name = null;
+        INameNode constNode = (INameNode) node.getConstNode();
+        if (constNode == null) {
+            name = node.getName();
+            module = graph.getRuntime().getContext().getFrameModule();
+        } else if (constNode instanceof Colon2Node) {
+            Node leftNode = ((Colon2Node) constNode).getLeftNode();
+
+            Vertex v = graph.createVertex(leftNode);
+            for (IRubyObject mod : v.getTypeSet()) {
+                if (mod instanceof RubyModule) {
+                    module = (RubyModule) mod;
+                    break;
+                }
+            }
+            name = constNode.getName();
+        } else { // colon3
+            module = graph.getRuntime().getObject();
+            name = constNode.getName();
+        }
+
+        if (src == null) {
+            src = graph.createVertex(node.getValue());
+        }
+        if (module != null && name != null) {
+            module.setConstant(name, graph.createVertexHolder(src));
+        }
+
+        return src;
+    }
+
+    public static Vertex globalAssign(Graph graph, GlobalAsgnNode node) {
+        return globalAssign(graph, node, null);
+    }
+
+    public static Vertex globalAssign(Graph graph, GlobalAsgnNode node, Vertex src) {
+        Ruby runtime = graph.getRuntime();
+        VertexHolder holder = (VertexHolder) runtime.getGlobalVar(node.getName());
+        if (src == null) {
+            src = graph.createVertex(node.getValue());
+        }
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            runtime.setGlobalVar(node.getName(), holder);
+        }
+        // Clear older types (performance issue)
+        holder.getVertex().getTypeSet().clear();
+        graph.addEdgeAndPropagate(src, holder.getVertex());
+        return src;
+    }
+
+    public static Vertex globalVariable(Graph graph, GlobalVarNode node) {
+        Ruby runtime = graph.getRuntime();
+        VertexHolder holder = (VertexHolder) runtime.getGlobalVar(node.getName());
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            runtime.setGlobalVar(node.getName(), holder);
+        }
+        return holder.getVertex();
+    }
+
+    public static void aliasGlobalVariables(Graph graph, String newName, String oldName) {
+        Ruby runtime = graph.getRuntime();
+        VertexHolder holder = (VertexHolder) runtime.getGlobalVar(oldName);
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            runtime.setGlobalVar(oldName, holder);
+        }
+        runtime.setGlobalVar(newName, holder); // no propagation ?
+    }
+
+    public static void blockAssign(Graph graph, BlockArgNode node, Block block) {
+        if (block == null)
+            return;
+
+        Scope scope = graph.getRuntime().getContext().getCurrentScope();
+        VertexHolder holder = (VertexHolder) scope.getValue(node.getName());
+        if (holder == null) {
+            holder = graph.createFreeVertexHolder();
+            scope.setValue(node.getName(), holder);
+        }
+        holder.getVertex().addType((Proc) block);
+    }
+
+    public static int handleOptArgs(OptArgNode optArgs, Graph graph, Vertex[] args, Block block, int num) {
+        int argsCount = 0;
+        for (Node node: optArgs.childNodes()) {
+            assign(graph, node, args[num + argsCount]);
+            argsCount++;
+//            System.out.println("Debug: " + optArgs);
+        }
+        return argsCount;
+    }
+
+    public static void argsAssign(Graph graph, ArgsNode argsNode, Vertex[] args, Block block) {
+        Scope scope = graph.getRuntime().getContext().getCurrentScope();
+        ListNode pre = argsNode.getPre();
+        ListNode post = argsNode.getPost();
+        int preCount = argsNode.getPreCount();
+        int postCount = argsNode.getPostCount();
+        if (preCount > 0) {
+            int size = pre.size();
+            for (int i = 0; i < size; i++) {
+                Node next = pre.get(i);
+                Vertex arg = i < args.length ? args[i] : Vertex.EMPTY;
+                assign(graph, next, arg);
+            }
+        }
+        if (postCount > 0) {
+            int size = post.size();
+            int argsLength = args.length;
+            for (int i = 0; i < size; i++) {
+                Node next = post.get(i);
+                Vertex arg = argsLength - postCount + i < args.length
+                    ? args[argsLength - postCount + i]
+                    : Vertex.EMPTY;
+                if (next instanceof AssignableNode) {
+                    assign(graph, next, arg);
+                } else {
+                    //scope.setValue(((INameNode) next).getName(), arg);
+                    Logger.fixme("argsAssign2");
+                }
+            }
+        }
+
+        int index = preCount;
+        ListNode optArgs = argsNode.getOptional();
+        Node restArgNode = argsNode.getRest();
+        int restArg = argsNode.getRest() == null ? -1 : argsNode.getRest().getIndex();
+        int givenArgsCount = preCount;
+        if (optArgs != null) {
+            int j = 0;
+            for (int i = preCount; i < args.length - postCount && j < optArgs.size(); i++, j++) {
+                if (optArgs.get(j).getNodeType() == NodeType.OPTARGNODE) {
+                    int plusCount = handleOptArgs((OptArgNode)optArgs.get(j), graph, args, block, i);
+                    givenArgsCount+= plusCount;
+                }
+                else {
+                    assign(graph, optArgs.get(j), args[i]);
+                    givenArgsCount++;
+                }
+            }
+            for (int i = 0; j < optArgs.size(); i++, j++) {
+                if (optArgs.get(j).getNodeType() == NodeType.OPTARGNODE) {
+                    graph.createVertex(optArgs.get(j).childNodes().get(0));
+                }
+                graph.createVertex(optArgs.get(j));
+            }
+        }
+        if (restArg >= 0) {
+            int sizeOfRestArg = args.length - postCount - givenArgsCount;
+            if (sizeOfRestArg <= 0) {
+                assign(graph, restArgNode, createArrayVertex(graph, null, null));
+            } else {
+                assign(graph, restArgNode, createArrayVertex(graph, null, args, givenArgsCount, sizeOfRestArg));
+            }
+        }
+        if (argsNode.getBlock() != null) {
+            blockAssign(graph, argsNode.getBlock(), block);
+        }
+    }
+
+    public static Vertex argumentAssign(Graph graph, ArgumentNode node, Vertex src) {
+        Scope scope = graph.getRuntime().getContext().getCurrentScope();
+        VertexHolder holder = graph.createFreeVertexHolder();
+        scope.setValue(node.getName(), holder);
+        if (src != null) {
+            graph.addEdgeAndUpdate(src, holder.getVertex());
+        }
+        return src;
+    }
+
+    public static Vertex multipleAssign(Graph graph, MultipleAsgnNode node) {
+        return multipleAssign(graph, node, (Vertex) null);
+    }
+
+    public static Vertex multipleAssign(Graph graph, MultipleAsgnNode node, Vertex src) {
+        if (src == null) {
+            src = graph.createVertex(node.getValue());
+        }
+        MultipleAsgnVertex vertex = new MultipleAsgnVertex(node, src);
+        graph.addEdgeAndPropagate(src, vertex);
+        return src;
+    }
+
+    public static void multiAssignfromArgsNode(Graph graph, ArgsNode node, IRubyObject object) {
+        boolean isArray = object instanceof Array;
+        Array array = null;
+        Vertex element = Vertex.EMPTY;
+
+        if (isArray) {
+            array = (Array) object;
+            if (array.isModified()) {
+                return;
+            }
+        } else {
+            TypeVarMap tvmap = getTypeVarMap(object);
+            TypeVariable var = TypeVariable.valueOf("t");
+            if (tvmap != null && tvmap.containsKey(var)) {
+                element = tvmap.get(var);
+            }
+        }
+
+        int valLen = array != null ? array.length() : 256; // magic number
+        int varLen = node.getPre() == null ? 0 : node.getPre().size();
+
+        int j = 0;
+        for (; j < valLen && j < varLen; j++) {
+            dynamicAssign(graph, node.getPre().get(j), array != null ? array.getElement(j) : element);
+        }
+
+        Node argsNode = node.getRest();
+        if (argsNode != null) {
+            if (argsNode.getNodeType() == NodeType.STARNODE) {
+                // no check for '*'
+            } else if (varLen < valLen && array != null) {
+                assign(graph, argsNode, createArrayVertex(graph, null, array.getElements(), varLen, valLen - varLen));
+            } else {
+                Vertex[] elements = null;
+                if (element != null) {
+                    elements = new Vertex[] { element };
+                }
+                assign(graph, argsNode, createArrayVertex(graph, null, elements));
+            }
+        }
+
+        while (j < varLen) {
+            assign(graph, node.getPre().get(j++), element);
+        }
+    }
+
+    public static void multipleAssign(Graph graph, MultipleAsgnNode node, IRubyObject object) {
+        boolean isArray = object instanceof Array;
+        Array array = null;
+        Vertex element = Vertex.EMPTY;
+
+        if (isArray) {
+            array = (Array) object;
+            if (array.isModified()) {
+                return;
+            }
+        } else {
+            TypeVarMap tvmap = getTypeVarMap(object);
+            TypeVariable var = TypeVariable.valueOf("t");
+            if (tvmap != null && tvmap.containsKey(var)) {
+                element = tvmap.get(var);
+            }
+        }
+
+        int valLen = array != null ? array.length() : 256; // magic number
+        int varLen = node.getPre() == null ? 0 : node.getPre().size();
+
+        int j = 0;
+        for (; j < valLen && j < varLen; j++) {
+            assign(graph, node.getPre().get(j), array != null ? array.getElement(j) : element);
+        }
+
+        Node argsNode = node.getRest();
+        if (argsNode != null) {
+            if (argsNode.getNodeType() == NodeType.STARNODE) {
+                // no check for '*'
+            } else if (varLen < valLen && array != null) {
+                assign(graph, argsNode, createArrayVertex(graph, null, array.getElements(), varLen, valLen - varLen));
+            } else {
+                Vertex[] elements = null;
+                if (element != null) {
+                    elements = new Vertex[] { element };
+                }
+                assign(graph, argsNode, createArrayVertex(graph, null, elements));
+            }
+        }
+
+        while (j < varLen) {
+            assign(graph, node.getPre().get(j++), element);
+        }
+    }
+
+    public static Vertex[] setupCallArgs(Graph graph, Node argsNode) {
+        List<Vertex> args = new ArrayList<Vertex>();
+        if (argsNode != null) {
+            switch (argsNode.getNodeType()) {
+            case ARGSCATNODE:
+            case SPLATNODE: {
+                Vertex arrayVertex = graph.createVertex(argsNode);
+                for (IRubyObject object : arrayVertex.getTypeSet()) {
+                    if (object instanceof Array) {
+                        Array array = (Array) object;
+                        if (array.getElements() != null) {
+                            for (Vertex element : array.getElements()) {
+                                args.add(element);
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            default:
+                for (Node arg : argsNode.childNodes()) {
+                    args.add(graph.createVertex(arg));
+                }
+            }
+        }
+        return args.isEmpty() ? null : args.toArray(new Vertex[0]);
+    }
+
+    public static Block setupCallBlock(Graph graph, Node iterNode) {
+        Context context = graph.getRuntime().getContext();
+        Block block = null;
+        if (iterNode != null) {
+            switch (iterNode.getNodeType()) {
+            case ITERNODE: {
+                IterNode inode = (IterNode) iterNode;
+                DynamicScope scope = new DynamicScope(context.getCurrentScope().getModule(), context.getCurrentScope());
+                block = new Proc(graph.getRuntime(), inode.getVar(), inode.getBody(), context.getCurrentFrame(), scope);
+                break;
+            }
+            case BLOCKPASSNODE:
+                block = context.getFrameBlock();
+                break;
+            }
+        }
+        return block;
+    }
+
+    public static Vertex call(Graph graph, CallVertex vertex) {
+        return call(graph, vertex, false);
+    }
+
+    public static Vertex callSuper(Graph graph, CallVertex vertex) {
+        return call(graph, vertex, true);
+    }
+
+    private static Vertex call(Graph graph, CallVertex vertex, boolean callSuper) {
+        if (vertex.isApplicable() && vertex.isChanged()) {
+            vertex.markUnchanged();
+
+            String name = vertex.getName();
+            TypeSet receivers = vertex.getReceiverVertex().getTypeSet();
+            Block block = vertex.getBlock();
+            boolean noReturn = false;
+            Vertex[] argVertices = vertex.getArgVertices();
+            SpecialMethod.Result prevResult = null;
+            TypeSet accumulator = new TypeSet();
+
+            while (!receivers.isEmpty()) {
+                SpecialMethod.Result result = new SpecialMethod.Result(prevResult, accumulator);
+                prevResult = result;
+                SpecialMethod spec = graph.getSpecialMethod(name);
+                if (spec != null) {
+                    spec.call(graph.getRuntime(), receivers, argVertices, block, result);
+                    if (result.getResultTypeSet() != null) {
+                        accumulator.addAll(result.getResultTypeSet());
+                    }
+                    if (result.hasPrivateVisibility()) {
+                        vertex.setPrivateVisibility(true);
+                    }
+                    if (result.isNeverCallAgain()) {
+                        vertex.cutout();
+                    } else if (!result.isCallNextMethod()) {
+                        break;
+                    }
+                }
+
+                List<Collection<IRubyObject>> args = new ArrayList<Collection<IRubyObject>>();
+                if (vertex.getArgVertices() != null) {
+                    for (Vertex v : argVertices) {
+                        args.add(v.getTypeSet());
+                    }
+                }
+
+                List<TemplateAttribute> attrs = generateTemplateAttributes(receivers, args, block);
+                boolean applied = false;
+                for (TemplateAttribute attr : attrs) {
+                    Vertex returnVertex = applyTemplateAttribute(graph, vertex, name, attr, callSuper);
+                    if (returnVertex != null) {
+                        applied = true;
+                        if (!noReturn)
+                            accumulator.addAll(returnVertex.getTypeSet());
+                    }
+                }
+                if (!applied)
+                    graph.notifyMethodMissingEvent(vertex);
+                if (result.isNextMethodChange()) {
+                    name = result.getNextMethodName();
+                    receivers = result.getNextMethodReceivers();
+                    block = result.getNextMethodBlock();
+                    noReturn = result.isNextMethodNoReturn();
+                } else {
+                    break;
+                }
+            }
+
+            vertex.addTypes(accumulator);
+        }
+        return vertex;
+    }
+
+    public static void methodPartialUpdate(Graph graph, MethodDefNode node, DynamicMethod newMethod, DynamicMethod oldMethod, IRubyObject receiver) {
+        if (newMethod instanceof Method && oldMethod instanceof Method) {
+            Method newmeth = (Method) newMethod;
+            Method oldmeth = (Method) oldMethod;
+
+             if (shouldShare(node, oldmeth)) {
+                 newmeth.shareTemplates(oldmeth);
+             } else {
+                Logger.debug(SourceLocation.of(node), "templates not shared: %s", newmeth);
+            }
+
+        }
+    }
+
+    public static boolean shouldShare(MethodDefNode node, Method oldmeth) {
+
+        if ((node.getArgs() != null && oldmeth.getArgsNode() != null) && (node.getBody() != null && oldmeth.getBodyNode() != null)) {
+            Node nodeArgs = node.getArgs();
+            Node omethArgs = oldmeth.getArgsNode();
+            Node nodeBody = skipNewLines(node.getBody());
+            Node omethBody = skipNewLines(oldmeth.getBodyNode());
+
+            if ((isRsenseCallNode(nodeArgs)) || (isRsenseCallNode(nodeBody))) {
+                return false;
+            }
+
+            if ((nodeArgs.isSame(omethArgs)) && (nodeBody.isSame(omethBody))) {
+                return true;
+            }
+        }
+
+        return false;
+
+    }
+
+    public static boolean isRsenseCallNode(Node a) {
+        if (a.getNodeType() == NodeType.CALLNODE) {
+            String name = ((INameNode) a).getName();
+            if (name.equals(TYPE_INFERENCE_METHOD_NAME)
+                    || name.startsWith(FIND_DEFINITION_METHOD_NAME_PREFIX)) {
+                // scratch!
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static Node skipNewLines(Node node) {
+        if (node.getNodeType() == NodeType.NEWLINENODE) {
+            return ((NewlineNode) node).getNextNode();
+        } else {
+            return node;
+        }
+    }
+
+    public static void classPartialUpdate(Graph graph, RubyModule klass, Node bodyNode) {
+
+        if (bodyNode != null) {
+            ClassTag oldTag = getClassTag(klass);
+            if (oldTag != null) {
+                ArrayList<Node> partialDiff = addToUndiff(bodyNode, oldTag.getBodyNode());
+
+
+                if ((partialDiff != null) && !(partialDiff.isEmpty())) {
+                    Logger.debug(SourceLocation.of(bodyNode), "class partial update: %s %s", klass, partialDiff.size());
+                    for (Node dirty : partialDiff) {
+                        graph.createVertex(dirty);
+                    }
+                } else {
+                    graph.createVertex(bodyNode);
+                }
+            } else {
+                graph.createVertex(bodyNode);
+            }
+        }
+    }
+
+    public static ArrayList<Node> addToUndiff(Node node, Node tagNode) {
+        if ((node == null) || (tagNode == null)) return null;
+
+        ArrayList<Node> undiff = new ArrayList<Node>();
+
+        List<Node> nkids = node.childNodes();
+        List<Node> tkids = tagNode.childNodes();
+
+        if ((nkids.isEmpty()) || (tkids.isEmpty())) return null;
+
+        if (nkids.size() == tkids.size()) {
+            for (int i = 0; i < nkids.size(); i++) {
+                Node nchild = nkids.get(i);
+                Node tchild = tkids.get(i);
+
+                if ((nchild == null) || (tchild == null)) continue;
+
+                if ((nchild instanceof ILocalScope && !(nchild instanceof RootNode))) {
+                    if (nchild.isSame(tchild)) {
+                        undiff.add(nchild);
+                    }
+                }
+
+            }
+        }
+
+        return undiff;
+
+
+    }
+
+    public static void dummyCall(Graph graph, MethodDefNode node, Method method, IRubyObject receiver) {
+        if (node.getBody() != null) {
+            Context context = graph.getRuntime().getContext();
+            context.pushFrame(context.getFrameModule(), node.getName(), receiver, null, Visibility.PUBLIC);
+            context.pushScope(new LocalScope(method.getModule()));
+            graph.createVertex(node.getBody());
+            context.popScope();
+            context.popFrame();
+        }
+        Logger.debug(SourceLocation.of(node), "dummy call: %s", method);
+    }
+
+    public static void dummyCallForTemplates(Graph graph, MethodDefNode node, Method method, Collection<TemplateAttribute> templateAttributes) {
+        String name = node.getName();
+        for (TemplateAttribute attr : templateAttributes) {
+            createTemplate(graph, null, name, method, attr);
+        }
+        Logger.debug(SourceLocation.of(node), "template dummy call: %s", method);
+    }
+
+    private static Vertex applyTemplateAttribute(Graph graph, CallVertex vertex, String name, TemplateAttribute attr, boolean callSuper) {
+        IRubyObject receiver = attr.getReceiver();
+        IRubyObject[] args = attr.getArgs();
+        RubyClass receiverType = null;
+        if (callSuper) {
+            RubyModule module = graph.getRuntime().getContext().getFrameModule();
+            if (module instanceof RubyClass) {
+                RubyClass klass = (RubyClass) module;
+                receiverType = klass.getSuperClass();
+            } else {
+                Logger.error("Cannot call super in module");
+                return null;
+            }
+        } else if (receiver != null) {
+            receiverType = receiver.getMetaClass();
+        }
+        if (receiverType != null) {
+            Method method = (Method) receiverType.searchMethod(name);
+            if (method != null
+                && (method.getVisibility() != Visibility.PRIVATE
+                    || vertex.hasPrivateVisibility())) {
+                Template template = method.getTemplate(attr);
+                if (template == null) {
+                    template = createTemplate(graph, vertex, name, method, attr);
+                    Logger.debug(SourceLocation.of(vertex), "template created: %s", method);
+                } else {
+                    template.reproduceSideEffect(graph, receiver, args, vertex.getBlock());
+                    Logger.debug(SourceLocation.of(vertex), "template reused: %s", method);
+                }
+                return template.getReturnVertex();
+            }
+        }
+        return null;
+    }
+
+    private static Template createTemplate(Graph graph, CallVertex vertex, String name, Method method, TemplateAttribute attr) {
+        IRubyObject receiver = attr.getReceiver();
+        IRubyObject[] args = attr.getArgs();
+        Vertex[] argVertices = new Vertex[args.length];
+        for (int i = 0; i < argVertices.length; i++) {
+            argVertices[i] = graph.createFreeSingleTypeVertex(args[i]);
+        }
+
+        Ruby runtime = graph.getRuntime();
+        Context context = runtime.getContext();
+
+        Block block = attr.getBlock();
+        Scope scope = new LocalScope(method.getModule());
+        context.pushFrame(context.getFrameModule(), name, receiver, block, Visibility.PUBLIC);
+        context.pushScope(scope);
+
+        Template template = new Template(method, context.getCurrentFrame(), scope, attr);
+        method.addTemplate(attr, template);
+
+        Vertex returnVertex = template.getReturnVertex();
+        setFrameTemplate(context.getCurrentFrame(), template);
+
+        AnnotationResolver.Result result = AnnotationHelper.resolveMethodAnnotation(graph, template);
+
+        if (result == AnnotationResolver.Result.UNRESOLVED) {
+            Logger.warn(SourceLocation.of(vertex), "annotation unmatched: %s", method);
+        }
+
+        Vertex ret = method.call(graph, template, receiver, args, argVertices, block);
+        if (ret != null && result != AnnotationResolver.Result.RESOLVED) {
+            graph.addEdgeAndUpdate(ret, returnVertex);
+        }
+
+        context.popScope();
+        context.popFrame();
+
+        return template;
+    }
+
+    private static List<TemplateAttribute> generateTemplateAttributes(Collection<IRubyObject> receivers, List<Collection<IRubyObject>> args, Block block) {
+        int size = 1;
+        for (Collection<IRubyObject> c : args) {
+            size *= c.size();
+        }
+        if (size == 0) {
+            return Collections.emptyList();
+        } else if (size >= 128) {
+            Logger.warn("too big application: %s", size);
+            return Collections.emptyList();
+        }
+
+        int unit = size;
+        List<TemplateAttribute> result = new ArrayList<TemplateAttribute>(size);
+        for (int i = 0; i < size; i++) {
+            result.add(new TemplateAttribute(new IRubyObject[args.size()]));
+        }
+
+        for (int i = 0; i < args.size(); i++) {
+            Collection<IRubyObject> c = args.get(i);
+            Iterator<IRubyObject> ite = c.iterator();
+            int k = 0, n = c.size();
+            int newUnit = unit / n;
+            IRubyObject v = ite.next();
+            for (int j = 0; j < size; j++) {
+                result.get(j).setArg(i, v);
+                if (++k == newUnit) {
+                    k = 0;
+                    if (!ite.hasNext()) {
+                        ite = c.iterator();
+                    }
+                    v = ite.next();
+                }
+            }
+            unit = newUnit;
+        }
+
+        // handle receiver polymorphic and data polymorphic
+        int resultSize = result.size();
+        for (int i = 0; i < resultSize; i++) {
+            TemplateAttribute base = result.get(i);
+            boolean first = true;
+            for (IRubyObject recv : receivers) {
+                base.setReceiver(recv);
+                base.setBlock(block);
+                if (recv instanceof PolymorphicObject) {
+                    for (PolymorphicObject mrecv : ((PolymorphicObject) recv).generateMonomorphicObjects()) {
+                        base.setReceiver(mrecv);
+                        if (!first) {
+                            result.add(base);
+                        }
+                        first = false;
+                        base = base.clone();
+                    }
+                } else {
+                    if (!first) {
+                        result.add(base);
+                    }
+                    first = false;
+                    base = base.clone();
+                }
+            }
+        }
+
+        // handle arguments data polymorphic
+        for (int i = 0; i < args.size(); i++) {
+            resultSize = result.size();
+            for (int j = 0; j < resultSize; j++) {
+                TemplateAttribute base = result.get(j);
+                IRubyObject arg = base.getArg(i);
+                if (arg instanceof PolymorphicObject) {
+                    boolean first = true;
+                    for (PolymorphicObject marg : ((PolymorphicObject) arg).generateMonomorphicObjects()) {
+                        base.setArg(i, marg);
+                        if (!first) {
+                            result.add(base);
+                        }
+                        first = false;
+                        base = base.clone();
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public static Vertex yield(Graph graph, Block block, IRubyObject arg, boolean expanded, Vertex returnVertex) {
+        return yield(graph, block, Arrays.asList(arg), expanded, returnVertex);
+    }
+
+    public static Vertex yield(Graph graph, Block block, IRubyObject[] args, boolean expanded, Vertex returnVertex) {
+        return yield(graph, block, Arrays.asList(args), expanded, returnVertex);
+    }
+
+    public static Vertex yield(Graph graph, Block block, Collection<IRubyObject> args, boolean expanded, Vertex returnVertex) {
+        if (block == null) {
+            return Vertex.EMPTY;
+        }
+        Ruby runtime = graph.getRuntime();
+        Context context = runtime.getContext();
+
+        Node varNode = block.getVarNode();
+
+        boolean noargblock = false;
+        boolean multiAssign = false;
+        MultipleAsgnNode masgn = null;
+        int preCount = 0;
+        boolean isRest = false;
+        Node rest = null;
+        ListNode pre = null;
+        Vertex vertex = graph.createFreeVertex();
+
+        if (varNode == null || varNode instanceof ZeroArgNode) {
+            noargblock = true;
+        } else if (varNode instanceof MultipleAsgnNode) {
+            masgn = (MultipleAsgnNode) varNode;
+            multiAssign = true;
+            preCount = masgn.getPre().size();
+            isRest = masgn.getRest() != null;
+            rest = masgn.getRest();
+            pre = masgn.getPre();
+        }
+
+        if (args != null && !args.isEmpty()) {
+            for (IRubyObject value : args) {
+                pushLoopFrame(context, block.getFrame(), returnVertex, vertex);
+                context.pushScope(block.getScope());
+
+                if (noargblock) {}
+                else if (multiAssign) {
+                    Array array;
+                    if (!expanded) {
+                        array = to_ary(value, graph);
+
+                    } else {
+                        array = to_ary(value, graph);
+                    }
+                    multipleAssign(graph, masgn, array);
+                } else {
+                    // TODO what do we do here?
+                    if (varNode.getNodeType() == NodeType.ARGSNODE ) {
+                        //debug
+                        ArgsNode argsFromBlock = (ArgsNode) varNode;
+
+                        if (argsFromBlock.getPre() != null) {
+                            isRest = argsFromBlock.getRest() != null;
+                            rest = argsFromBlock.getRest();
+                            pre = argsFromBlock.getPre();
+                            preCount = pre.size();
+                            if (preCount > 1 || isRest) {
+                                multiAssignfromArgsNode(graph, argsFromBlock, to_ary(value, graph));
+                            } else {
+                                dynamicAssign(graph, pre.get(0), graph.createFreeSingleTypeVertex(value));
+                            }
+
+                        } else {
+                            argsAssign(graph, argsFromBlock, new Vertex[]{graph.createFreeSingleTypeVertex(value)}, block);
+                        }
+
+                    } else {
+                        assign(graph, varNode, graph.createFreeSingleTypeVertex(value));
+                    }
+                }
+
+                if (block.getBodyNode() != null) {
+                    Vertex v = graph.createVertex(block.getBodyNode());
+                    graph.addEdgeAndPropagate(v, vertex);
+                }
+
+                context.popScope();
+                popLoopFrame(context);
+            }
+        } else {
+            pushLoopFrame(context, block.getFrame(), returnVertex, vertex);
+            context.pushScope(block.getScope());
+
+            if (block.getBodyNode() != null) {
+                Vertex v = graph.createVertex(block.getBodyNode());
+                graph.addEdgeAndPropagate(v, vertex);
+            }
+
+            context.popScope();
+            popLoopFrame(context);
+        }
+
+        return vertex;
+    }
+
+    public static Vertex yield(Graph graph, YieldVertex vertex) {
+        Vertex returnVertex = null;
+        if (vertex.getTemplate() != null)
+            returnVertex = vertex.getTemplate().getReturnVertex();
+
+        // return immediately if no need to apply
+        Proc block = (Proc) vertex.getBlock();
+        Vertex argsVertex = vertex.getArgsVertex();
+        if (block != null
+            && block.isApplied(vertex)
+            && (argsVertex == null
+                || !argsVertex.isChanged())) {
+            return vertex;
+        }
+        if (argsVertex != null)
+            argsVertex.markUnchanged();
+
+        if (block != null)
+            block.recordYield(vertex);
+        returnVertex = yield(graph, block, (argsVertex != null ? argsVertex.getTypeSet() : TypeSet.EMPTY), vertex.getExpandArguments(), returnVertex);
+        if (returnVertex != null)
+            graph.addEdgeAndUpdate(returnVertex, vertex);
+
+        return vertex;
+    }
+
+    public static void splatValue(Graph graph, SplatVertex vertex) {
+        vertex.addTypes(arrayValue(graph, vertex.getValueVertex()));
+    }
+
+    public static void toAryValue(Graph graph, ToAryVertex vertex) {
+        vertex.addTypes(arrayValue(graph, vertex.getValueVertex()));
+    }
+
+    public static TypeSet arrayValue(Graph graph, Vertex vertex) {
+        Ruby runtime = graph.getRuntime();
+        TypeSet typeSet = new TypeSet();
+        for (IRubyObject object : vertex.getTypeSet()) {
+            if (object.isKindOf(runtime.getArray())) {
+                typeSet.add(object);
+            } else {
+                CallVertex callVertex = new CallVertex(vertex.getNode(), "to_a", vertex, null, null);
+                for (IRubyObject array : call(graph, callVertex).getTypeSet()) {
+                    if (array.isKindOf(runtime.getArray())) {
+                        typeSet.add(array);
+                    } else {
+                        Logger.warn("to_a should be return Array");
+                    }
+                }
+            }
+        }
+        return typeSet;
+    }
+
+    public static Array to_ary(IRubyObject value, Graph graph) {
+        Array array;
+
+        if (value instanceof Array) {
+            array = (Array) value;
+        } else {
+            array = createArray(graph, new Vertex[] { graph.createFreeSingleTypeVertex(value) });
+        }
+        return array;
+
+    }
+
+    public static void aValueSplat(Graph graph, SValueVertex vertex) {
+        for (IRubyObject object : vertex.getValueVertex().getTypeSet()) {
+            if (object.isKindOf(graph.getRuntime().getArray())) {
+                if (object instanceof Array) {
+                    Array array = (Array) object;
+                    if (!array.isModified()) {
+                        if (array.length() == 1) {
+                            vertex.update(array.getElement(0));
+                        } else {
+                            vertex.addType(object);
+                        }
+                        continue;
+                    }
+                }
+                TypeVariable var = TypeVariable.valueOf("t");
+                TypeVarMap tvmap = getTypeVarMap(object);
+                if (tvmap != null && tvmap.containsKey(var)) {
+                    vertex.update(tvmap.get(var));
+                }
+            }
+        }
+    }
+
+    public static RubyModule getNamespace(Graph graph, Colon3Node node) {
+        if (node instanceof Colon2ImplicitNode) {
+            return graph.getRuntime().getContext().getFrameModule();
+        } else if (node instanceof Colon2Node) {
+            Vertex left = graph.createVertex(((Colon2Node) node).getLeftNode());
+            IRubyObject object = left.singleType();
+            if (object instanceof RubyModule) {
+                return (RubyModule) object;
+            } else {
+                return null;
+            }
+        } else if (node instanceof Colon3Node) {
+            return graph.getRuntime().getObject();
+        }
+        Logger.fixme("Namespace unresolved: %s", node);
+        return null;
+    }
+
+    public static Template getFrameTemplate(Frame frame) {
+        Object tag;
+        while (frame != null) {
+            tag = frame.getTag();
+            if (tag instanceof Template) {
+                return (Template) tag;
+            }
+            frame = frame.getPrevious();
+        }
+        return null;
+    }
+
+    public static void setFrameTemplate(Frame frame, Template template) {
+        frame.setTag(template);
+    }
+
+    public static LoopTag getFrameLoopTag(Frame frame) {
+        Object tag = frame.getTag();
+        if (tag instanceof LoopTag) {
+            return (LoopTag) tag;
+        } else {
+            return null;
+        }
+    }
+
+    public static void pushLoopFrame(Context context, Vertex returnVertex, Vertex yieldVertex) {
+        pushLoopFrame(context, context.getCurrentFrame(), returnVertex, yieldVertex);
+    }
+
+    public static void pushLoopFrame(Context context, Frame prev, Vertex returnVertex, Vertex yieldVertex) {
+        Frame frame = context.pushFrame(prev.getModule(), prev.getName(), prev.getSelf(), prev.getBlock(), prev.getVisibility());
+        frame.setTag(new LoopTag(returnVertex, yieldVertex));
+    }
+
+    public static void popLoopFrame(Context context) {
+        context.popFrame();
+    }
+
+    public static ClassTag getClassTag(RubyModule klass) {
+        if (klass instanceof MetaClass) {
+            MetaClass metaClass = (MetaClass) klass;
+            if (metaClass.getAttached() instanceof RubyModule) {
+                klass = (RubyModule) metaClass.getAttached();
+            }
+        }
+        if (klass != null && klass.getTag() instanceof ClassTag) {
+            return (ClassTag) klass.getTag();
+        } else {
+            return null;
+        }
+    }
+
+    public static ClassType getClassAnnotation(RubyModule klass) {
+        ClassTag tag = getClassTag(klass);
+        return tag != null ? tag.getType() : null;
+    }
+
+    public static void setClassTag(RubyModule klass, Node node, List<TypeAnnotation> annotations) {
+        if (getClassAnnotation(klass) == null) {
+            ClassType type = null;
+            for (TypeAnnotation annot : annotations) {
+                if (annot instanceof ClassType) {
+                    type = (ClassType) annot;
+                    break;
+                }
+            }
+            klass.setTag(new ClassTag(node, type));
+        }
+    }
+
+    public static void setMethodTag(Method method, /*unused*/Node node, List<TypeAnnotation> annotations) {
+        if (!annotations.isEmpty()) {
+            List<MethodType> types = new ArrayList<MethodType>();
+            for (TypeAnnotation annot : annotations) {
+                if (annot instanceof MethodType) {
+                    types.add((MethodType) annot);
+                }
+            }
+            method.setAnnotations(types);
+        }
+    }
+
+    public static ClassTag getEnclosingClassTag(RubyModule module) {
+        ClassTag tag;
+        while (module != null) {
+            tag = getClassTag(module);
+            if (tag != null) {
+                return tag;
+            }
+            module = module.getParent();
+        }
+        return null;
+    }
+
+    public static ClassType getEnclosingClassAnnotation(RubyModule module) {
+        ClassTag tag = getEnclosingClassTag(module);
+        return tag != null ? tag.getType() : null;
+    }
+
+    public static TypeVarMap getTypeVarMap(IRubyObject object) {
+        if (object.getTag() instanceof TypeVarMap) {
+            return (TypeVarMap) object.getTag();
+        } else {
+            return null;
+        }
+    }
+
+    public static Array createArray(Graph graph, Vertex[] elements) {
+        Array array = new Array(graph.getRuntime(), elements);
+        TypeVarVertex t = new TypeVarVertex(array);
+        array.setTypeVarVertex(t);
+        return array;
+    }
+
+    public static Vertex createArrayVertex(Graph graph, Node node, Vertex[] elements) {
+        Array array = createArray(graph, elements);
+        Vertex vertex = new PassThroughVertex(node);
+        vertex.addType(array);
+        array.getTypeVarVertex().addEdge(vertex);
+        return vertex;
+    }
+
+    public static Vertex createArrayVertex(Graph graph, Node node, Vertex[] elements, int offset, int length) {
+        Vertex[] newElements = new Vertex[length];
+        System.arraycopy(elements, offset, newElements, 0, length);
+        return createArrayVertex(graph, node, newElements);
+    }
+
+    public static Hash createHash(Graph graph, Vertex[] elements) {
+        Hash hash = new Hash(graph.getRuntime(), elements);
+        TypeVarVertex k = new TypeVarVertex(hash);
+        TypeVarVertex v = new TypeVarVertex(hash);
+        hash.setKeyTypeVarVertex(k);
+        hash.setValueTypeVarVertex(v);
+        return hash;
+    }
+
+
+    public static Vertex createHashVertex(Graph graph, Node node, Vertex[] elements) {
+        Hash hash = createHash(graph, elements);
+        Vertex vertex = new PassThroughVertex(node);
+        vertex.addType(hash);
+        hash.getKeyTypeVarVertex().addEdge(vertex);
+        hash.getValueTypeVarVertex().addEdge(vertex);
+        return vertex;
+    }
+
+    public static Vertex[] toVertices(Graph graph, ListNode node) {
+        Vertex[] vertices = new Vertex[node.size()];
+        for (int i = 0; i < vertices.length; i++) {
+            vertices[i] = graph.createVertex(node.get(i));
+        }
+        return vertices;
+    }
+
+    public static void setMethodsVisibility(Graph graph, TypeSet receivers, Vertex[] args, Visibility visibility) {
+        if (args == null || args.length == 0) {
+            // FIXME module check
+            graph.getRuntime().getContext().getCurrentFrame().setVisibility(visibility);
+        } else {
+            for (IRubyObject receiver : receivers) {
+                if (receiver.isKindOf(graph.getRuntime().getModule())) {
+                    RubyModule module = (RubyModule) receiver;
+                    for (Vertex arg : args) {
+                        String name = Vertex.getStringOrSymbol(arg);
+                        if (name != null) {
+                            DynamicMethod method = module.getMethod(name);
+                            if (method != null) {
+                                method.setVisibility(visibility);
+                                if (visibility == Visibility.MODULE_FUNCTION) {
+                                    module.getSingletonClass().addMethod(name, method);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public static void defineAttrs(Graph graph, TypeSet receivers, Vertex[] args, boolean reader, boolean writer) {
+        if (args != null && args.length > 0) {
+            for (IRubyObject receiver : receivers) {
+                if (receiver.isKindOf(graph.getRuntime().getModule())) {
+                    for (Vertex arg : args) {
+                        String name = Vertex.getStringOrSymbol(arg);
+                        if (name != null) {
+                            if (reader) {
+                                defineAttrReader(graph, name);
+                            }
+                            if (writer) {
+                                defineAttrWriter(graph, name);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public static void defineAttrReader(Graph graph, String name) {
+        SourcePosition pos = new SourcePosition("(generated)", 0, 0);
+        graph.createVertex(new DefnNode(pos,
+                                        new MethodNameNode(pos, name),
+                                        new ArgsNode(pos, null, null, null, null, null, null, null),
+                                        new LocalStaticScope(null),
+                                        new InstVarNode(pos, "@" + name)));
+    }
+
+    public static void defineAttrWriter(Graph graph, String name) {
+        SourcePosition pos = new SourcePosition("(generated)", 0, 0);
+        graph.createVertex(new DefnNode(pos,
+                                        new MethodNameNode(pos, name + "="),
+                                        new ArgsNode(pos, new ListNode(null, new ArgumentNode(null, name)), null, null, null, null, null, null),
+                                        new LocalStaticScope(null),
+                                        new InstAsgnNode(pos, "@" + name, new LocalVarNode(null, 0, name))));
+    }
+}