rsense-core 0.5.0

data/src/org/cx4a/rsense/typing/Propagation.java

@@ -0,0 +1,73 @@
+package org.cx4a.rsense.typing;
+
+import java.util.Set;
+import java.util.HashSet;
+
+import org.cx4a.rsense.typing.vertex.Vertex;
+
+public class Propagation {
+    public final static int MAX_DEPTH = 10;
+    
+    private Graph graph;
+    private Set<Object> visited;
+    private int depth;
+    private int refCount;
+
+    public Propagation(Graph graph) {
+        this.graph = graph;
+        this.depth = 0;
+        this.refCount = 0;
+    }
+
+    public Graph getGraph() {
+        return graph;
+    }
+
+    public boolean isVisited(Vertex vertex) {
+        return visited != null ? visited.contains(getVisitTag(vertex)) : false;
+    }
+
+    public void addVisited(Vertex vertex) {
+        if (visited == null) {
+            // lazy allocation
+            visited = new HashSet<Object>();
+        }
+        visited.add(getVisitTag(vertex));
+    }
+
+    public boolean checkVisited(Vertex vertex) {
+        if (isVisited(vertex)) {
+            return true;
+        } else {
+            addVisited(vertex);
+            return false;
+        }
+    }
+
+    public boolean visit(Vertex vertex, Vertex src) {
+        // Cut out deper branches.
+        // This makes results inprecise but also performace improved.
+        if (depth >= MAX_DEPTH) {
+            return false;
+        }
+
+        try {
+            depth++;
+            return vertex.accept(this, src);
+        } finally {
+            depth--;
+        }
+    }
+
+    public void retain() {
+        refCount++;
+    }
+
+    public boolean release() {
+        return --refCount == 0;
+    }
+
+    private Object getVisitTag(Vertex vertex) {
+        return vertex.getNode() != null ? vertex.getNode() : vertex;
+    }
+}

data/src/org/cx4a/rsense/typing/Template.java

@@ -0,0 +1,84 @@
+package org.cx4a.rsense.typing;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import org.cx4a.rsense.ruby.Frame;
+import org.cx4a.rsense.ruby.Scope;
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.typing.runtime.Method;
+import org.cx4a.rsense.typing.runtime.RuntimeHelper;
+import org.cx4a.rsense.typing.runtime.MonomorphicObject;
+import org.cx4a.rsense.typing.runtime.Proc;
+import org.cx4a.rsense.typing.vertex.Vertex;
+import org.cx4a.rsense.typing.vertex.YieldVertex;
+import org.cx4a.rsense.typing.annotation.TypeVariable;
+
+public class Template {
+    private Method method;
+    private TemplateAttribute attr;
+    private Vertex returnVertex;
+    private Frame frame;
+    private Scope scope;
+
+    public Template(Method method, Frame frame, Scope scope, TemplateAttribute attr) {
+        this.method = method;
+        this.attr = attr;
+        this.frame = frame;
+        this.scope = scope;
+        this.returnVertex = new Vertex();
+    }
+
+    public Method getMethod() {
+        return method;
+    }
+
+    public TemplateAttribute getAttribute() {
+        return attr;
+    }
+
+    public Vertex getReturnVertex() {
+        return returnVertex;
+    }
+
+    public Frame getFrame() {
+        return frame;
+    }
+
+    public Scope getScope() {
+        return scope;
+    }
+
+    public void reproduceSideEffect(Graph graph, IRubyObject receiver, IRubyObject[] args, Block block) {
+        reproduceSideEffect(graph, attr.getMutableReceiver(false), receiver);
+        for (int i = 0; i < attr.getArgs().length && i < args.length; i++) {
+            reproduceSideEffect(graph, attr.getMutableArg(i, false), args[i]);
+        }
+        reproduceYield(graph, receiver, args, block);
+    }
+
+    private void reproduceSideEffect(Graph graph, IRubyObject from, IRubyObject to) {
+        if (from instanceof MonomorphicObject && to instanceof MonomorphicObject) {
+            MonomorphicObject a = (MonomorphicObject) from;
+            MonomorphicObject b = (MonomorphicObject) to;
+            for (Map.Entry<TypeVariable, Vertex> entry : a.getTypeVarMap().entrySet()) {
+                Vertex src = entry.getValue();
+                Vertex dest = b.getTypeVarMap().get(entry.getKey());
+                if (dest != null) {
+                    graph.propagateEdge(src, dest);
+                }
+            }
+        }
+    }
+
+    private void reproduceYield(Graph graph, IRubyObject receiver, IRubyObject[] args, Block block) {
+        Proc templateProc = (Proc) attr.getBlock();
+        if (templateProc != null && block != null) {
+            // Yield records may change during loop
+            for (YieldVertex vertex : new ArrayList<YieldVertex>(templateProc.getYields())) {
+                RuntimeHelper.yield(graph, new YieldVertex(vertex.getNode(), this, block, vertex.getArgsVertex(), vertex.getExpandArguments()));
+            }
+        }
+    }
+}

data/src/org/cx4a/rsense/typing/TemplateAttribute.java

@@ -0,0 +1,158 @@
+package org.cx4a.rsense.typing;
+
+import java.util.Arrays;
+
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.typing.runtime.PolymorphicObject;
+
+public class TemplateAttribute {
+    private IRubyObject receiver;
+    private IRubyObject[] args;
+    private Block block;
+    private int hashCode = 0;
+
+    // For to keep original state of receiver and args
+    // See AnnotationResolver
+    private IRubyObject mutableReceiver;
+    private IRubyObject[] mutableArgs;
+
+    public TemplateAttribute(IRubyObject[] args) {
+        this.args = args;
+    }
+
+    public IRubyObject getReceiver() {
+        return receiver;
+    }
+
+    public void setReceiver(IRubyObject receiver) {
+        this.receiver = receiver;
+    }
+
+    public IRubyObject getArg(int i) {
+        return args[i];
+    }
+
+    public void setArg(int i, IRubyObject arg) {
+        args[i] = arg;
+    }
+
+    public IRubyObject[] getArgs() {
+        return args;
+    }
+
+    public Block getBlock() {
+        return block;
+    }
+
+    public void setBlock(Block block) {
+        this.block = block;
+    }
+
+    public IRubyObject getMutableReceiver() {
+        return getMutableReceiver(true);
+    }
+    
+    public IRubyObject getMutableReceiver(boolean create) {
+        if (mutableReceiver == null && create) {
+            mutableReceiver = cloneObject(receiver);
+        }
+        return mutableReceiver;
+    }
+
+    public IRubyObject[] getMutableArgs() {
+        return getMutableArgs(true);
+    }
+
+    public IRubyObject[] getMutableArgs(boolean create) {
+        if (mutableArgs == null && create) {
+            mutableArgs = new IRubyObject[args.length];
+            for (int i = 0; i < args.length; i++) {
+                mutableArgs[i] = cloneObject(args[i]);
+            }
+        }
+        return mutableArgs;
+    }
+
+    public IRubyObject getMutableArg(int i) {
+        return getMutableArg(i, true);
+    }
+
+    public IRubyObject getMutableArg(int i, boolean create) {
+        IRubyObject[] args = getMutableArgs(create);
+        return args != null ? args[i] : null;
+    }
+
+    public TemplateAttribute clone() {
+        IRubyObject[] newargs = new IRubyObject[args.length];
+        System.arraycopy(args, 0, newargs, 0, args.length);
+        TemplateAttribute clone = new TemplateAttribute(newargs);
+        clone.receiver = receiver;
+        clone.block = block;
+        return clone;
+    }
+
+    private IRubyObject cloneObject(IRubyObject object) {
+        if (object instanceof PolymorphicObject) {
+            return ((PolymorphicObject) object).clone();
+        } else {
+            // immutable
+            return object;
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        if (hashCode != 0)
+            return hashCode;
+        
+        if (receiver != null)
+            hashCode = (hashCode ^ receiver.hashCode()) * 13;
+        for (IRubyObject arg : args) {
+            if (arg != null)
+                hashCode = (hashCode ^ arg.hashCode()) * 13;
+        }
+        if (block != null)
+            hashCode ^= (hashCode ^ block.hashCode()) * 13;
+        return hashCode;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other == this) {
+            return true;
+        }
+
+        if (!(other instanceof TemplateAttribute)) {
+            return false;
+        }
+
+        TemplateAttribute o = (TemplateAttribute) other;
+
+        if (hashCode() != other.hashCode()
+            || ((receiver == null) ^ (o.receiver == null))
+            || (receiver != null && !receiver.equals(o.receiver))
+            || args.length != o.args.length
+            || (block != null
+                ? !block.equals(o.block)
+                : o.block != null
+                ? !o.block.equals(block)
+                : false)) {
+            return false;
+        }
+
+        for (int i = 0; i < args.length; i++) {
+            if (((args[i] == null) ^ (o.args[i] == null))
+                || (args[i] != null && !args[i].equals(o.args[i]))) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "<TemplAttr " + receiver.toString() + " " + Arrays.asList(args).toString() + (block != null ? (" " + block.toString() + ">") : ">");
+    }
+}

data/src/org/cx4a/rsense/typing/TypeSet.java

@@ -0,0 +1,48 @@
+package org.cx4a.rsense.typing;
+
+import java.util.Collection;
+import java.util.HashSet;
+
+import org.cx4a.rsense.ruby.IRubyObject;
+
+public class TypeSet extends HashSet<IRubyObject> {
+    private static final long serialVersionUID = 0L;
+
+    public static final TypeSet EMPTY = new TypeSet() {
+            private static final long serialVersionUID = 0L;
+            @Override
+            public boolean add(IRubyObject type) {
+                throw new UnsupportedOperationException();
+            }
+            @Override
+            public boolean addAll(Collection<? extends IRubyObject> types) {
+                throw new UnsupportedOperationException();
+            }
+        };
+
+    public TypeSet() {
+        super();
+    }
+
+    public TypeSet(TypeSet other) {
+        super(other);
+    }
+
+    public TypeSet(int capacity) {
+        super(capacity);
+    }
+
+    @Override
+    public int hashCode() {
+        return hashCode(1);
+    }
+
+    public int hashCode(int depth) {
+        int code = 0;
+        for (IRubyObject type : this) {
+            code ^= type.hashCode(depth);
+            code *= 13;
+        }
+        return code;
+    }
+}

data/src/org/cx4a/rsense/typing/annotation/ClassType.java

@@ -0,0 +1,57 @@
+package org.cx4a.rsense.typing.annotation;
+
+import java.util.List;
+
+public class ClassType implements TypeAnnotation {
+    private String name;
+    private List<TypeVariable> types;
+    private List<TypeConstraint> constraints;
+    private List<TypePragma> pragmas;
+    
+    public ClassType(String name, List<TypeVariable> types, List<TypeConstraint> constraints, List<TypePragma> pragmas) {
+        this.name = name;
+        this.types = types;
+        this.constraints = constraints;
+        this.pragmas = pragmas;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<TypeVariable> getTypes() {
+        return types;
+    }
+
+    public List<TypeConstraint> getConstraints() {
+        return constraints;
+    }
+
+    public List<TypePragma> getPragmas() {
+        return pragmas;
+    }
+
+    public boolean containsType(TypeVariable type) {
+        return types != null && types.indexOf(type) != -1;
+    }
+
+    public boolean isNoBody() {
+        if (pragmas != null) {
+            for (TypePragma pragma : pragmas) {
+                if (pragma.getType() == TypeExpression.Type.NOBODY_PRAGMA) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public boolean isPolymorphic() {
+        return types != null;
+    }
+
+    @Override
+    public String toString() {
+        return "<ClassType " + name + " " + types + " " + constraints + " " + pragmas + ">";
+    }
+}

data/src/org/cx4a/rsense/typing/annotation/MethodType.java

@@ -0,0 +1,79 @@
+package org.cx4a.rsense.typing.annotation;
+
+import java.util.List;
+
+public class MethodType implements TypeAnnotation {
+    private String name;
+    private List<TypeVariable> types;
+    private List<TypeConstraint> consList;
+    private Signature sig;
+
+    public MethodType(String name, List<TypeVariable> types, List<TypeConstraint> consList, Signature sig) {
+        this.name = name;
+        this.types = types;
+        this.consList = consList;
+        this.sig = sig;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<TypeVariable> getTypes() {
+        return types;
+    }
+
+    public List<TypeConstraint> getConstraints() {
+        return consList;
+    }
+
+    public Signature getSignature() {
+        return sig;
+    }
+
+    public static class Block {
+        private Signature sig;
+
+        public Block(Signature sig) {
+            this.sig = sig;
+        }
+
+        public Signature getSignature() {
+            return sig;
+        }
+    }
+
+    public static class Signature {
+        private TypeExpression argType;
+        private Block block;
+        private TypeExpression returnType;
+
+        public Signature(TypeExpression argType, Block block, TypeExpression returnType) {
+            this.argType = argType;
+            this.block = block;
+            this.returnType = returnType;
+        }
+
+        public TypeExpression getArgType() {
+            return argType;
+        }
+
+        public Block getBlock() {
+            return block;
+        }
+
+        public TypeExpression getReturnType() {
+            return returnType;
+        }
+
+        @Override
+        public String toString() {
+            return "<Signature " + argType + " " + block + " " + returnType + ">";
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "<MethodType " + name + " " + sig + ">";
+    }
+}