rsense-core 0.5.0

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

@@ -0,0 +1,119 @@
+package org.cx4a.rsense.typing.runtime;
+
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.typing.TypeSet;
+import org.cx4a.rsense.typing.vertex.Vertex;
+
+public abstract class SpecialMethod {
+    public static class Result {
+        private Result prev;
+        private TypeSet accumulator;
+        private TypeSet resultTypeSet;
+        private boolean noReturn;
+        private boolean callNextMethod;
+        private boolean nextMethodChange;
+        private String nextMethodName;
+        private TypeSet nextMethodReceivers;
+        private Block nextMethodBlock;
+        private boolean nextMethodNoReturn;
+        private boolean neverCallAgain;
+        private boolean privateVisibility;
+
+        public Result(Result prev, TypeSet accumulator) {
+            this.prev = prev;
+            this.accumulator = accumulator;
+        }
+
+        public Result setResultTypeSet(TypeSet resultTypeSet) {
+            this.resultTypeSet = resultTypeSet;
+            return this;
+        }
+
+        public Result setCallNextMethod(boolean flag) {
+            this.callNextMethod = flag;
+            return this;
+        }
+
+        public Result setNextMethodChange(boolean flag) {
+            this.nextMethodChange = flag;
+            return this;
+        }
+
+        public Result setNextMethodName(String name) {
+            this.nextMethodName = name;
+            return this;
+        }
+
+        public Result setNextMethodReceivers(TypeSet receivers) {
+            this.nextMethodReceivers = receivers;
+            return this;
+        }
+
+        public Result setNextMethodBlock(Block block) {
+            this.nextMethodBlock = block;
+            return this;
+        }
+
+        public Result setNextMethodNoReturn(boolean flag) {
+            this.nextMethodNoReturn = flag;
+            return this;
+        }
+
+        public Result setNeverCallAgain(boolean neverCallAgain) {
+            this.neverCallAgain = neverCallAgain;
+            return this;
+        }
+
+        public Result setPrivateVisibility(boolean privateVisibility) {
+            this.privateVisibility = privateVisibility;
+            return this;
+        }
+
+        public Result getPrevious() {
+            return prev;
+        }
+
+        public TypeSet getAccumulator() {
+            return accumulator;
+        }
+
+        public TypeSet getResultTypeSet() {
+            return resultTypeSet;
+        }
+
+        public boolean isCallNextMethod() {
+            return callNextMethod;
+        }
+
+        public boolean isNextMethodChange() {
+            return nextMethodChange;
+        }
+
+        public String getNextMethodName() {
+            return nextMethodName;
+        }
+
+        public TypeSet getNextMethodReceivers() {
+            return nextMethodReceivers;
+        }
+
+        public Block getNextMethodBlock() {
+            return nextMethodBlock;
+        }
+
+        public boolean isNextMethodNoReturn() {
+            return nextMethodNoReturn;
+        }
+
+        public boolean isNeverCallAgain() {
+            return neverCallAgain;
+        }
+
+        public boolean hasPrivateVisibility() {
+            return privateVisibility;
+        }
+    }
+
+    public abstract void call(Ruby runtime, TypeSet receivers, Vertex[] args, Block block, Result result);
+}

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

@@ -0,0 +1,112 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.typing.TypeSet;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.annotation.TypeVariable;
+
+public class TypeVarMap extends HashMap<TypeVariable, Vertex> {
+    private static final long serialVersionUID = 0L;
+
+    public TypeVarMap() {
+        super();
+    }
+
+    public TypeVarMap(int initialCapacity) {
+        super(initialCapacity);
+    }
+
+    public TypeVarMap(TypeVarMap other) {
+        super(other);
+    }
+
+    public TypeVarMap[] generateTuples() {
+        int size = 1;
+        for (Vertex vertex : values()) {
+            size *= vertex.getTypeSet().size();
+        }
+        if (size == 0) {
+            return new TypeVarMap[0];
+        }
+
+        int unit = size;
+        TypeVarMap[] result = new TypeVarMap[size];
+        for (int i = 0; i < size; i++) {
+            result[i] = new TypeVarMap(size());
+        }
+
+        for (Map.Entry<TypeVariable, Vertex> entry : entrySet()) {
+            TypeSet typeSet = entry.getValue().getTypeSet();
+            Iterator<IRubyObject> ite = typeSet.iterator();
+            int k = 0, n = typeSet.size();
+            int newUnit = unit / n;
+            IRubyObject v = ite.next();
+            for (int j = 0; j < size; j++) {
+                Vertex vertex = new Vertex(1);
+                vertex.addType(v);
+                result[j].put(entry.getKey(), vertex);
+                if (++k == newUnit) {
+                    k = 0;
+                    if (!ite.hasNext()) {
+                        ite = typeSet.iterator();
+                    }
+                    v = ite.next();
+                }
+            }
+            unit = newUnit;
+        }
+
+        return result;
+    }
+
+    public TypeVarMap clone() {
+        TypeVarMap clone = new TypeVarMap();
+        for (Map.Entry<TypeVariable, Vertex> entry : entrySet()) {
+            clone.put(entry.getKey(), new Vertex(null, new TypeSet(entry.getValue().getTypeSet())));
+        }
+        return clone;
+    }
+
+    @Override
+    public int hashCode() {
+        return hashCode(1);
+    }
+
+    public int hashCode(int depth) {
+        int code = 0;
+        for (Map.Entry<TypeVariable, Vertex> entry : entrySet()) {
+            code = (code ^ entry.getKey().hashCode()) * 13;
+            code = (code ^ entry.getValue().getTypeSet().hashCode(depth)) * 13;
+        }
+        return code;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other)
+            return true;
+
+        if (!(other instanceof TypeVarMap))
+            return false;
+
+        TypeVarMap o = (TypeVarMap) other;
+        if (size() != o.size())
+            return false;
+
+        Iterator<Map.Entry<TypeVariable, Vertex>> i = entrySet().iterator();
+        Iterator<Map.Entry<TypeVariable, Vertex>> j = o.entrySet().iterator();
+        while (i.hasNext() && j.hasNext()) {
+            Map.Entry<TypeVariable, Vertex> x = i.next();
+            Map.Entry<TypeVariable, Vertex> y = j.next();
+            if (!x.getKey().equals(y.getKey())
+                || !x.getValue().getTypeSet().equals(y.getValue().getTypeSet()))
+                return false;
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,48 @@
+package org.cx4a.rsense.typing.runtime;
+
+import org.cx4a.rsense.ruby.Ruby;
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.ruby.RubyObject;
+import org.cx4a.rsense.typing.vertex.Vertex;
+
+public class VertexHolder extends RubyObject {
+    private Vertex vertex;
+
+    public VertexHolder(Ruby runtime, Vertex vertex) {
+        super(runtime, runtime.getObject());
+        this.vertex = vertex;
+    }
+
+    public Vertex getVertex() {
+        return vertex;
+    }
+
+    @Override
+    public String toString() {
+        return vertex.toString();
+    }
+
+    @Override
+    public int hashCode() {
+        int code = 0;
+        for (IRubyObject type : vertex.getTypeSet()) {
+            code ^= type.hashCode();
+            code *= 13;
+        }
+        return code;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        }
+
+        if (!(object instanceof VertexHolder)) {
+            return false;
+        }
+
+        VertexHolder o = (VertexHolder) object;
+        return vertex.getTypeSet().equals(o.vertex.getTypeSet());
+    }
+}

data/src/org/cx4a/rsense/typing/vertex/CallVertex.java

@@ -0,0 +1,122 @@
+package org.cx4a.rsense.typing.vertex;
+
+import org.jrubyparser.ast.Node;
+import org.jrubyparser.ast.INameNode;
+
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.typing.Propagation;
+
+public class CallVertex extends Vertex {
+    private String name;
+    private Vertex receiverVertex;
+    private Vertex[] argVertices;
+    private Block block;
+    private boolean privateVisibility;
+
+    public CallVertex(Node node, Vertex receiverVertex, Vertex[] argVertices, Block block) {
+        this(node, null, receiverVertex, argVertices, block);
+    }
+
+    public CallVertex(Node node, String name, Vertex receiverVertex, Vertex[] argVertices, Block block) {
+        super(node);
+        this.name = name;
+        this.receiverVertex = receiverVertex;
+        this.argVertices = argVertices;
+        this.block = block;
+        this.privateVisibility = false;
+        receiverVertex.addEdge(this);
+        if (argVertices != null) {
+            for (Vertex v : argVertices) {
+                v.addEdge(this);
+            }
+        }
+    }
+
+    public void cutout() {
+        if (argVertices != null) {
+            for (Vertex v : argVertices) {
+                v.removeEdge(this);
+            }
+        }
+        receiverVertex.removeEdge(this);
+    }
+
+    public String getName() {
+        return name == null ? ((INameNode) node).getName() : name;
+    }
+
+    public Vertex getReceiverVertex() {
+        return receiverVertex;
+    }
+
+    public Vertex[] getArgVertices() {
+        return argVertices;
+    }
+
+    public Block getBlock() {
+        return block;
+    }
+
+    public boolean hasPrivateVisibility() {
+        return privateVisibility;
+    }
+
+    public void setPrivateVisibility(boolean privateVisibility) {
+        this.privateVisibility = privateVisibility;
+    }
+
+    public boolean isApplicable() {
+        if (receiverVertex == null || receiverVertex.isEmpty()) {
+            return false;
+        }
+
+        boolean applicable = true;
+        if (argVertices != null) {
+            for (Vertex v : argVertices) {
+                if (v.isEmpty()) {
+                    applicable = false;
+                    break;
+                }
+            }
+        }
+
+        return applicable;
+    }
+
+    @Override
+    public boolean isChanged() {
+        if (super.isChanged()
+            || (receiverVertex != null
+                && receiverVertex.isChanged())) {
+            return true;
+        }
+
+        if (argVertices != null) {
+            for (Vertex v : argVertices) {
+                if (v.isChanged()) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void markUnchanged() {
+        super.markUnchanged();
+        if (receiverVertex != null) {
+            receiverVertex.markUnchanged();
+        }
+        if (argVertices != null) {
+            for (Vertex v : argVertices) {
+                v.markUnchanged();
+            }
+        }
+    }
+
+    @Override
+    public boolean accept(Propagation propagation, Vertex src) {
+        return propagation.getGraph().propagateCallVertex(propagation, this, src);
+    }
+}

data/src/org/cx4a/rsense/typing/vertex/MultipleAsgnVertex.java

@@ -0,0 +1,23 @@
+package org.cx4a.rsense.typing.vertex;
+
+import org.jrubyparser.ast.MultipleAsgnNode;
+
+import org.cx4a.rsense.typing.Propagation;
+
+public class MultipleAsgnVertex extends Vertex {
+    private Vertex valueVertex;
+
+    public MultipleAsgnVertex(MultipleAsgnNode node, Vertex valueVertex) {
+        super(node);
+        this.valueVertex = valueVertex;
+    }
+
+    public Vertex getValueVertex() {
+        return valueVertex;
+    }
+
+    @Override
+    public boolean accept(Propagation propagation, Vertex src) {
+        return propagation.getGraph().propagateMultipleAsgnVertex(propagation, this, src);
+    }
+}

data/src/org/cx4a/rsense/typing/vertex/PassThroughVertex.java

@@ -0,0 +1,20 @@
+package org.cx4a.rsense.typing.vertex;
+
+import org.jrubyparser.ast.Node;
+
+import org.cx4a.rsense.typing.Propagation;
+
+public class PassThroughVertex extends Vertex {
+    public PassThroughVertex() {
+        super();
+    }
+
+    public PassThroughVertex(Node node) {
+        super(node);
+    }
+
+    @Override
+    public boolean accept(Propagation propagation, Vertex src) {
+        return propagation.getGraph().propagatePassThroughVertex(propagation, this, src);
+    }
+}