rsense-core 0.5.0

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+package org.cx4a.rsense.typing.vertex;
+
+import org.cx4a.rsense.typing.runtime.PolymorphicObject;
+import org.cx4a.rsense.typing.Propagation;
+
+public class TypeVarVertex extends Vertex {
+    private PolymorphicObject object;
+
+    public TypeVarVertex(PolymorphicObject object) {
+        super();
+        this.object = object;
+    }
+
+    public PolymorphicObject getObject() {
+        return object;
+    }
+
+    @Override
+    public boolean accept(Propagation propagation, Vertex src) {
+        return propagation.getGraph().propagateTypeVarVertex(propagation, this, src);
+    }
+}

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

@@ -0,0 +1,221 @@
+package org.cx4a.rsense.typing.vertex;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+
+import org.jrubyparser.ast.Node;
+import org.jrubyparser.ast.FixnumNode;
+import org.jrubyparser.ast.StrNode;
+import org.jrubyparser.ast.SymbolNode;
+import org.jrubyparser.ast.INameNode;
+
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.typing.TypeSet;
+import org.cx4a.rsense.typing.Propagation;
+import org.cx4a.rsense.typing.runtime.PolymorphicObject;
+import org.cx4a.rsense.util.Logger;
+
+public class Vertex {
+    public static final int MEGAMORPHIC_THRESHOLD = 5;
+    public static final Vertex EMPTY = new Vertex(null, TypeSet.EMPTY) {
+            @Override
+            public void addEdge(Vertex dest) {}
+            @Override
+            public void removeEdge(Vertex dest) {}
+        };
+
+    static {
+        EMPTY.edges = Collections.<Vertex>emptyList();
+    }
+
+    protected Node node;
+    protected int capacity = MEGAMORPHIC_THRESHOLD + 1;
+    protected TypeSet typeSet;
+    protected IRubyObject singleType;
+    protected boolean megamorphic;
+    protected List<Vertex> edges;
+    protected boolean changed = true;
+    protected long changedTime;
+
+    public Vertex() {}
+
+    public Vertex(int capacity) {
+        this.capacity = capacity;
+    }
+
+    public Vertex(Node node) {
+        this.node = node;
+    }
+
+    public Vertex(Node node, int capacity) {
+        this.node = node;
+        this.capacity = capacity;
+    }
+
+    public Vertex(Node node, TypeSet typeSet) {
+        this.node = node;
+        this.typeSet = typeSet;
+    }
+
+    public Node getNode() {
+        return node;
+    }
+
+    public TypeSet getTypeSet() {
+        return typeSet != null ? typeSet : TypeSet.EMPTY;
+    }
+
+    public List<Vertex> getEdges() {
+        return edges != null ? edges : Collections.<Vertex>emptyList();
+    }
+
+    public boolean isEmpty() {
+        return typeSet == null || typeSet.isEmpty();
+    }
+
+    public boolean addType(IRubyObject type) {
+        if (type == null)
+            throw new NullPointerException("type is null");
+
+        if (megamorphic)
+            return false;
+
+        if (typeSet().size() >= MEGAMORPHIC_THRESHOLD) {
+            Logger.info("megamorphic detected");
+            megamorphic = true;
+
+            // FIXME generalize
+            singleType = type.getRuntime().newInstance(type.getRuntime().getObject());
+            typeSet = new TypeSet(1);
+            typeSet.add(singleType);
+
+            return false;
+        } else {
+            if (singleType == null)
+                singleType = type;
+            if (typeSet().add(type))
+                return changed = true;
+            else
+                return false;
+        }
+    }
+
+    public boolean addTypes(Collection<IRubyObject> types) {
+        boolean added = false;
+        for (IRubyObject type : types) {
+            if (addType(type))
+                added = true;
+        }
+        return added;
+    }
+
+    public boolean update(Vertex other) {
+        return addTypes(other.getTypeSet());
+    }
+
+    public boolean isChanged() {
+        if (changed)
+            return true;
+
+        // Check to see if polymorphic objects are changed
+        if (typeSet != null && !megamorphic) {
+            for (IRubyObject obj : typeSet) {
+                if (obj instanceof PolymorphicObject) {
+                    PolymorphicObject pobj = (PolymorphicObject) obj;
+                    if (changedTime <= pobj.getModifiedTime())
+                        return changed = true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public void markUnchanged() {
+        if (changed)
+            changedTime = System.currentTimeMillis();
+        changed = false;
+    }
+
+    public IRubyObject singleType() {
+        if (typeSet == null || typeSet.size() != 1)
+            return null;
+        else if (singleType != null)
+            return singleType;
+        else
+            return singleType = typeSet.iterator().next();
+    }
+
+    public void addEdge(Vertex dest) {
+        if (edges == null)
+            edges = new ArrayList<Vertex>(2);
+        edges.add(dest);
+    }
+
+    public void removeEdge(Vertex dest) {
+        if (edges != null)
+            edges.remove(dest);
+    }
+
+    public boolean accept(Propagation propagation, Vertex src) {
+        return propagation.getGraph().propagateVertex(propagation, this, src);
+    }
+
+    public boolean isFree() {
+        return node == null;
+    }
+
+    @Override
+    public String toString() {
+        return getTypeSet().toString();
+    }
+
+    private TypeSet typeSet() {
+        if (typeSet == null)
+            typeSet = new TypeSet(capacity);
+        return typeSet;
+    }
+
+    public static String getName(Vertex vertex) {
+        Node node = vertex.getNode();
+        if (node instanceof INameNode) {
+            return ((INameNode) node).getName();
+        } else {
+            return null;
+        }
+    }
+
+    public static Integer getFixnum(Vertex vertex) {
+        Node node = vertex.getNode();
+        if (node instanceof FixnumNode) {
+            return Integer.valueOf((int) ((FixnumNode) node).getValue());
+        } else {
+            return null;
+        }
+    }
+
+    public static String getString(Vertex vertex) {
+        Node node = vertex.getNode();
+        if (node instanceof StrNode) {
+            return ((StrNode) node).getValue().toString();
+        } else {
+            return null;
+        }
+    }
+
+    public static String getSymbol(Vertex vertex) {
+        Node node = vertex.getNode();
+        if (node instanceof SymbolNode) {
+            return ((SymbolNode) node).getName();
+        } else {
+            return null;
+        }
+    }
+
+    public static String getStringOrSymbol(Vertex vertex) {
+        String value = getString(vertex);
+        return value != null ? value : getSymbol(vertex);
+    }
+}

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

@@ -0,0 +1,70 @@
+package org.cx4a.rsense.typing.vertex;
+
+import org.jrubyparser.ast.Node;
+
+import org.cx4a.rsense.ruby.Block;
+import org.cx4a.rsense.typing.Propagation;
+import org.cx4a.rsense.typing.Template;
+
+public class YieldVertex extends Vertex {
+    private Template template;
+    private Block block;
+    private Vertex argsVertex;
+    private boolean expandArguments;
+
+    public YieldVertex(Node node, Template template, Block block, Vertex argsVertex, boolean expandArguments) {
+        super(node);
+        this.template = template;
+        this.block = block;
+        this.argsVertex = argsVertex;
+        this.expandArguments = expandArguments;
+        if (argsVertex != null) {
+            argsVertex.addEdge(this);
+        }
+    }
+
+    public Template getTemplate() {
+        return template;
+    }
+
+    public Block getBlock() {
+        return block;
+    }
+
+    public Vertex getArgsVertex() {
+        return argsVertex;
+    }
+
+    public boolean getExpandArguments() {
+        return expandArguments;
+    }
+
+    @Override
+    public boolean accept(Propagation propagation, Vertex src) {
+        return propagation.getGraph().propagateYieldVertex(propagation, this, src);
+    }
+
+    @Override
+    public int hashCode() {
+        return template == null ? block.hashCode() : template.getAttribute().hashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+
+        if (!(other instanceof YieldVertex)) {
+            return false;
+        }
+
+        YieldVertex o = (YieldVertex) other;
+        return (template == null
+                && o.template == null
+                && block.equals(o.block))
+            || (template != null
+                && o.template != null
+                && template.getAttribute().equals(o.template.getAttribute()));
+    }
+}

data/src/org/cx4a/rsense/util/HereDocReader.java

@@ -0,0 +1,48 @@
+package org.cx4a.rsense.util;
+
+import java.io.Reader;
+import java.io.IOException;
+
+public class HereDocReader extends Reader {
+    private Reader reader;
+    private char[] end;
+    private int checked = 0;
+
+    public HereDocReader(Reader reader, String end) {
+        this.reader = reader;
+        this.end = end.toCharArray();
+    }
+
+    public void close() throws IOException {
+        reader.close();
+    }
+
+    public boolean markSupported() {
+        return false;
+    }
+
+    public int read(char[] cbuf, int off, int len) throws IOException {
+        if (checked == end.length) {
+            return -1;
+        }
+        
+        int read = 0;
+        int c;
+        while ((c = reader.read()) != -1) {
+            if (end[checked] == c) {
+                if (++checked == end.length) {
+                    // here doc end detected
+                    return read - checked;
+                }
+            } else {
+                checked = 0;
+            }
+            read++;
+            cbuf[off++] = (char) c;
+            if (read == len) {
+                return read - checked;
+            }
+        }
+        return -1;
+    }
+}

data/src/org/cx4a/rsense/util/Logger.java

@@ -0,0 +1,111 @@
+package org.cx4a.rsense.util;
+
+import java.io.PrintStream;
+
+public class Logger {
+    public enum Level {
+        FIXME, ERROR, WARN, MESSAGE, INFO, DEBUG
+    }
+
+    private PrintStream out;
+    private Level level = Level.MESSAGE;
+
+    private Logger() {
+        out = System.err;
+    }
+
+    public PrintStream getOut() {
+        return out;
+    }
+
+    public void setOut(PrintStream out) {
+        this.out = out;
+    }
+
+    public Level getLevel() {
+        return level;
+    }
+    
+    public void setLevel(Level level) {
+        this.level = level;
+    }
+
+    public void log(Level level, String format, Object... args) {
+        log(null, level, format, args);
+    }
+
+    public void log(SourceLocation loc, Level level, String format, Object... args) {
+        if (needsToPrint(level)) {
+            printLocation(loc);
+            printLevel(level);
+            out.println(String.format(format, args));
+        }
+    }
+    
+    private void printLocation(SourceLocation loc) {
+        if (loc != null) {
+            out.print(loc.toString() + ": ");
+        }
+    }
+
+    private void printLevel(Level level) {
+        out.print(level.toString().toLowerCase() + ": ");
+    }
+
+    private boolean needsToPrint(Level level) {
+        return this.level.ordinal() >= level.ordinal();
+    }
+
+    private static Logger instance = new Logger();
+    public static Logger getInstance() {
+        return instance;
+    }
+
+    public static void error(String format, Object... args) {
+        error(null, format, args);
+    }
+
+    public static void error(SourceLocation loc, String format, Object... args) {
+        getInstance().log(loc, Level.ERROR, format, args);
+    }
+
+    public static void warn(String format, Object... args) {
+        warn(null, format, args);
+    }
+
+    public static void warn(SourceLocation loc, String format, Object... args) {
+        getInstance().log(loc, Level.WARN, format, args);
+    }
+
+    public static void message(String format, Object... args) {
+        message(null, format, args);
+    }
+
+    public static void message(SourceLocation loc, String format, Object... args) {
+        getInstance().log(loc, Level.MESSAGE, format, args);
+    }
+
+    public static void info(String format, Object... args) {
+        info(null, format, args);
+    }
+
+    public static void info(SourceLocation loc, String format, Object... args) {
+        getInstance().log(loc, Level.INFO, format, args);
+    }
+
+    public static void debug(String format, Object... args) {
+        debug(null, format, args);
+    }
+
+    public static void debug(SourceLocation loc, String format, Object... args) {
+        getInstance().log(loc, Level.DEBUG, format, args);
+    }
+
+    public static void fixme(String format, Object... args) {
+        fixme(null, format, args);
+    }
+
+    public static void fixme(SourceLocation loc, String format, Object... args) {
+        getInstance().log(loc, Level.FIXME, format, args);
+    }
+}