rsense-core 0.5.0

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

@@ -0,0 +1,84 @@
+package org.cx4a.rsense.typing.runtime;
+
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.RubyClass;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.annotation.TypeVariable;
+
+public class Array extends PolymorphicObject {
+    protected Vertex[] elements;
+
+    public Array(Ruby runtime, Vertex[] elements) {
+        this(runtime, runtime.getArray(), elements);
+    }
+
+    public Array(Ruby runtime, RubyClass metaClass, Vertex[] elements) {
+        super(runtime, metaClass);
+        this.elements = elements;
+    }
+
+    public Array(Ruby runtime, RubyClass metaClass, Vertex[] elements, TypeVarMap tvmap) {
+        super(runtime, metaClass, tvmap);
+        this.elements = elements;
+    }
+
+    public Vertex getTypeVarVertex() {
+        return getTypeVarMap().get(TypeVariable.valueOf("t"));
+    }
+
+    public void setTypeVarVertex(Vertex vertex) {
+        getTypeVarMap().put(TypeVariable.valueOf("t"), vertex);
+        if (elements != null) {
+            for (Vertex e : elements) {
+                vertex.update(e);
+            }
+        }
+    }
+
+    public Vertex getElement(int i) {
+        if (elements == null) {
+            return null;
+        }
+        if (i < 0) {
+            i += elements.length;
+        }
+        if (0 <= i && i < elements.length) {
+            return elements[i];
+        }
+        return null;
+    }
+
+    public Vertex[] getElements() {
+        return elements;
+    }
+
+    public int length() {
+        return elements != null ? elements.length : 0;
+    }
+
+    @Override
+    public PolymorphicObject clone() {
+        return new Array(runtime, metaClass, elements, getTypeVarMap().clone());
+    }
+
+    @Override
+    public String toString() {
+        if (isModified()) {
+            // no longer static array
+            return super.toString();
+        }
+
+        StringBuffer sb = new StringBuffer();
+        String delim = "";
+        sb.append('(');
+        if (elements != null) {
+            for (Vertex e : elements) {
+                sb.append(delim);
+                sb.append(e.toString());
+                delim = ", ";
+            }
+        }
+        sb.append(')');
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,27 @@
+package org.cx4a.rsense.typing.runtime;
+
+import org.jrubyparser.ast.Node;
+
+import org.cx4a.rsense.typing.annotation.ClassType;
+
+public class ClassTag {
+    private Node bodyNode;
+    private ClassType type;
+
+    public ClassTag(Node node) {
+        this(node, null);
+    }
+
+    public ClassTag(Node bodyNode, ClassType type) {
+        this.bodyNode = bodyNode;
+        this.type = type;
+    }
+
+    public Node getBodyNode() {
+        return bodyNode;
+    }
+
+    public ClassType getType() {
+        return type;
+    }
+}

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

@@ -0,0 +1,115 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.lang.ref.SoftReference;
+
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.jrubyparser.ast.Node;
+import org.jrubyparser.ast.ArgsNode;
+
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.ruby.RubyModule;
+import org.cx4a.rsense.ruby.Visibility;
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.typing.Graph;
+import org.cx4a.rsense.typing.Template;
+import org.cx4a.rsense.typing.TemplateAttribute;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.annotation.MethodType;
+import org.cx4a.rsense.util.SourceLocation;
+
+public class DefaultMethod implements Method {
+    private RubyModule cbase;
+    private String name;
+    private Node bodyNode, argsNode;
+    private Visibility visibility;
+    private SourceLocation location;
+    private boolean templatesShared;
+    private Map<TemplateAttribute, SoftReference<Template>> templates;
+    private List<MethodType> annotations;
+
+    public DefaultMethod(RubyModule cbase, String name, Node bodyNode, Node argsNode, Visibility visibility, SourceLocation location) {
+        this.cbase = cbase;
+        this.name = name;
+        this.bodyNode = bodyNode;
+        this.argsNode = argsNode;
+        this.visibility = visibility;
+        this.location = location;
+        this.templates = new HashMap<TemplateAttribute, SoftReference<Template>>();
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Node getBodyNode() {
+        return bodyNode;
+    }
+
+    public Node getArgsNode() {
+        return argsNode;
+    }
+
+    public RubyModule getModule() {
+        return cbase;
+    }
+
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
+    public void setVisibility(Visibility visibility) {
+        this.visibility = visibility;
+    }
+
+    public SourceLocation getLocation() {
+        return location;
+    }
+
+    public void shareTemplates(Method with) {
+        this.templates = with.getTemplates();
+        this.templatesShared = true;
+    }
+
+    public Map<TemplateAttribute, SoftReference<Template>> getTemplates() {
+        return templates;
+    }
+
+    public Template getTemplate(TemplateAttribute key) {
+        SoftReference<Template> ref = templates.get(key);
+        return ref != null ? ref.get() : null;
+    }
+
+    public void addTemplate(TemplateAttribute key, Template template) {
+        templates.put(key, new SoftReference<Template>(template));
+    }
+
+    public boolean isTemplatesShared() {
+        return templatesShared;
+    }
+
+    public List<MethodType> getAnnotations() {
+        return annotations;
+    }
+
+    public void setAnnotations(List<MethodType> annotations) {
+        this.annotations = annotations;
+    }
+
+    public Vertex call(Graph graph, Template template, IRubyObject receiver, IRubyObject[] args, Vertex[] argVertices, Block block) {
+        // FIXME more efficient way
+        RuntimeHelper.argsAssign(graph, (ArgsNode) argsNode, argVertices, block);
+        if (bodyNode != null) {
+            return graph.createVertex(bodyNode);
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getModule().getMethodPath(getName());
+    }
+}

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

@@ -0,0 +1,131 @@
+package org.cx4a.rsense.typing.runtime;
+
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.RubyClass;
+import org.cx4a.rsense.typing.TypeSet;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.annotation.TypeVariable;
+
+import org.jrubyparser.ast.Node;
+import org.jrubyparser.ast.StrNode;
+import org.jrubyparser.ast.FixnumNode;
+import org.jrubyparser.ast.SymbolNode;
+
+public class Hash extends Array {
+    public static class Key {
+        private Object realKey;
+        private TypeSet typeSet;
+
+        public Key(Object realKey, TypeSet typeSet) {
+            this.realKey = realKey;
+            this.typeSet = typeSet;
+        }
+
+        public Object getRealKey() {
+            return realKey;
+        }
+
+        public TypeSet getTypeSet() {
+            return typeSet;
+        }
+    }
+
+    protected Key[] keys;
+
+    public Hash(Ruby runtime, Vertex[] elements) {
+        this(runtime, runtime.getHash(), elements);
+    }
+
+    public Hash(Ruby runtime, RubyClass metaClass, Vertex[] elements) {
+        this(runtime, runtime.getHash(), elements, new TypeVarMap());
+    }
+
+    public Hash(Ruby runtime, RubyClass metaClass, Vertex[] elements, TypeVarMap tvmap) {
+        super(runtime, metaClass, elements, tvmap);
+        if (elements != null) {
+            keys = new Key[elements.length / 2];
+            for (int i = 0, j = 0; i < elements.length; i += 2, j++) {
+                keys[j] = createVertexKey(elements[i]);
+            }
+        }
+    }
+
+    public Vertex get(Object key) {
+        if (elements != null) {
+            for (int i = 1, j = 0; i < elements.length; i += 2, j++) {
+                if (key != null && key.equals(keys[j].getRealKey())) {
+                    return elements[i];
+                }
+            }
+        }
+        return null;
+    }
+
+    public Vertex getKeyTypeVarVertex() {
+        return getTypeVarMap().get(TypeVariable.valueOf("k"));
+    }
+
+    public void setKeyTypeVarVertex(Vertex vertex) {
+        getTypeVarMap().put(TypeVariable.valueOf("k"), vertex);
+        for (Key key : keys) {
+            vertex.addTypes(key.getTypeSet());
+        }
+    }
+
+    public Vertex getValueTypeVarVertex() {
+        return getTypeVarMap().get(TypeVariable.valueOf("v"));
+    }
+
+    public void setValueTypeVarVertex(Vertex vertex) {
+        getTypeVarMap().put(TypeVariable.valueOf("v"), vertex);
+        if (elements != null) {
+            for (int i = 1; i < elements.length; i += 2) {
+                vertex.update(elements[i]);
+            }
+        }
+    }
+
+    @Override
+    public PolymorphicObject clone() {
+        return new Hash(runtime, metaClass, elements, getTypeVarMap().clone());
+    }
+
+    @Override
+    public String toString() {
+        if (isModified()) {
+            // no longer static hash
+            return super.toString();
+        }
+
+        StringBuffer sb = new StringBuffer();
+        String delim = "";
+        sb.append('{');
+        if (elements != null) {
+            for (int i = 0; i < elements.length; i++) {
+                sb.append(delim);
+                sb.append(keys[i].getRealKey());
+                sb.append(" => ");
+                sb.append(elements[i]);
+                delim = ", ";
+            }
+        }
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public static Object getRealKey(Node node) {
+        Object realKey = null;
+        if (node instanceof StrNode) {
+            realKey = ((StrNode) node).getValue();
+        } else if (node instanceof FixnumNode) {
+            realKey = ((FixnumNode) node).getValue();
+        } else if (node instanceof SymbolNode) {
+            realKey = ":" + ((SymbolNode) node).getName();
+        }
+        return realKey;
+    }
+
+    public static Key createVertexKey(Vertex vertex) {
+        return new Key(getRealKey(vertex.getNode()), vertex.getTypeSet());
+    }
+}

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

@@ -0,0 +1,21 @@
+package org.cx4a.rsense.typing.runtime;
+
+import org.cx4a.rsense.typing.vertex.Vertex;
+
+public class LoopTag {
+    private Vertex returnVertex;
+    private Vertex yieldVertex;
+
+    public LoopTag(Vertex returnVertex, Vertex yieldVertex) {
+        this.returnVertex = returnVertex;
+        this.yieldVertex = yieldVertex;
+    }
+
+    public Vertex getReturnVertex() {
+        return returnVertex;
+    }
+
+    public Vertex getYieldVertex() {
+        return yieldVertex;
+    }
+}

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

@@ -0,0 +1,32 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.lang.ref.SoftReference;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.jrubyparser.ast.Node;
+
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.ruby.DynamicMethod;
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.typing.Graph;
+import org.cx4a.rsense.typing.Template;
+import org.cx4a.rsense.typing.TemplateAttribute;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.annotation.MethodType;
+
+public interface Method extends DynamicMethod {
+    public String getName();
+    public Node getBodyNode();
+    public Node getArgsNode();
+    public void shareTemplates(Method with);
+    public Map<TemplateAttribute, SoftReference<Template>> getTemplates();
+    public Template getTemplate(TemplateAttribute key);
+    public void addTemplate(TemplateAttribute key, Template template);
+    public boolean isTemplatesShared();
+    public List<MethodType> getAnnotations();
+    public void setAnnotations(List<MethodType> annotations);
+    public Vertex call(Graph graph, Template template, IRubyObject receiver, IRubyObject[] args, Vertex[] argVertices, Block block);
+}

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

@@ -0,0 +1,77 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.util.Map;
+
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.annotation.TypeVariable;
+
+public class MonomorphicObject extends PolymorphicObject {
+    private PolymorphicObject entity;
+    
+    // keep initial state of monomorphic
+    private TypeVarMap fixedTypeVarMap;
+    private int hashCode = 0;
+
+    public MonomorphicObject(PolymorphicObject entity, TypeVarMap tvmap) {
+        super(entity.getRuntime(), entity.getMetaClass(), tvmap);
+        this.entity = entity;
+
+        fixedTypeVarMap = new TypeVarMap();
+        TypeVarMap etvmap = entity.getTypeVarMap();
+        for (Map.Entry<TypeVariable, Vertex> entry : tvmap.entrySet()) {
+            entry.getValue().addEdge(etvmap.get(entry.getKey()));
+            
+            IRubyObject value = entry.getValue().singleType();
+            if (value != null) {
+                Vertex v = new Vertex();
+                v.addType(value);
+                fixedTypeVarMap.put(entry.getKey(), v);
+            }
+        }
+    }
+
+    @Override
+    public PolymorphicObject clone() {
+        return new MonomorphicObject(entity, getTypeVarMap().clone());
+    }
+
+    @Override
+    public int hashCode() {
+        if (hashCode != 0)
+            return hashCode;
+
+        for (Vertex v : fixedTypeVarMap.values())
+            hashCode = (hashCode ^ v.singleType().getMetaClass().hashCode()) * 13;
+        return hashCode;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+
+        if (!(other instanceof MonomorphicObject)) {
+            return false;
+        }
+
+        MonomorphicObject o = (MonomorphicObject) other;
+        for (TypeVariable var : fixedTypeVarMap.keySet()) {
+            IRubyObject a = fixedTypeVarMap.get(var).singleType();
+            IRubyObject b = o.fixedTypeVarMap.get(var) != null ? o.fixedTypeVarMap.get(var).singleType() : null;
+            if (a == null
+                || b == null
+                || !a.getMetaClass().equals(b.getMetaClass())) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "<mobj:" + getMetaClass().toString() + getTypeVarMap() + ">";
+    }
+}