rsense-core 0.5.0

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

@@ -0,0 +1,4 @@
+package org.cx4a.rsense.typing.annotation;
+
+public interface TypeAnnotation {
+}

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

@@ -0,0 +1,7 @@
+package org.cx4a.rsense.typing.annotation;
+
+public class TypeAny implements TypeExpression {
+    public Type getType() {
+        return Type.ANY;
+    }
+}

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

@@ -0,0 +1,37 @@
+package org.cx4a.rsense.typing.annotation;
+
+import java.util.List;
+
+public class TypeApplication implements TypeExpression {
+    private TypeIdentity ident;
+    private List<TypeExpression> types;
+
+    public TypeApplication(TypeIdentity ident, List<TypeExpression> types) {
+        this.ident = ident;
+        this.types = types;
+    }
+
+    public TypeIdentity getIdentity() {
+        return ident;
+    }
+
+    public List<TypeExpression> getTypes() {
+        return types;
+    }
+
+    public Type getType() {
+        return Type.APPLICATION;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(ident.toString());
+        sb.append('<');
+        for (TypeExpression type : types) {
+            sb.append(type.toString());
+        }
+        sb.append('>');
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,29 @@
+package org.cx4a.rsense.typing.annotation;
+
+public class TypeConstraint implements TypeExpression {
+    private Type type;
+    private TypeExpression lhs, rhs;
+
+    public TypeConstraint(Type type, TypeExpression lhs, TypeExpression rhs) {
+        this.type = type;
+        this.lhs = lhs;
+        this.rhs = rhs;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public TypeExpression lhs() {
+        return lhs;
+    }
+
+    public TypeExpression rhs() {
+        return rhs;
+    }
+
+    @Override
+    public String toString() {
+        return lhs + " <= " + rhs;
+    }
+}

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

@@ -0,0 +1,11 @@
+package org.cx4a.rsense.typing.annotation;
+
+public interface TypeExpression {
+    public enum Type { RELATIVE_IDENTITY, SCOPED_IDENTITY, ABSOLUTE_IDENTITY,
+            UNION, VARIABLE, ANY, OPTIONAL,
+            TUPLE, SPLAT, APPLICATION, SUBTYPE_CONS,
+            NOBODY_PRAGMA,
+            }
+
+    public Type getType();
+}

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

@@ -0,0 +1,59 @@
+package org.cx4a.rsense.typing.annotation;
+
+public class TypeIdentity implements TypeExpression {
+    private Type type;
+    private String name;
+    private TypeIdentity path;
+
+    private TypeIdentity(Type type) {
+        this.type = type;
+    }
+
+    private TypeIdentity(Type type, String name) {
+        this(type, name, null);
+    }
+
+    private TypeIdentity(Type type, TypeIdentity path) {
+        this(type, null, path);
+    }
+
+    private TypeIdentity(Type type, String name, TypeIdentity path) {
+        this.type = type;
+        this.name = name;
+        this.path = path;
+    }
+    
+    public Type getType() {
+        return type;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public TypeIdentity getPath() {
+        return path;
+    }
+
+    public static TypeIdentity newRelativeIdentity(String name) {
+        return new TypeIdentity(Type.RELATIVE_IDENTITY, name);
+    }
+
+    public static TypeIdentity newScopedIdentity(String name, TypeIdentity path) {
+        return new TypeIdentity(Type.SCOPED_IDENTITY, name, path);
+    }
+
+    public static TypeIdentity newAbsoluteIdentity(TypeIdentity path) {
+        return new TypeIdentity(Type.ABSOLUTE_IDENTITY, path);
+    }
+
+    @Override
+    public String toString() {
+        switch (type) {
+        case RELATIVE_IDENTITY:
+            return "$" + name;
+        default:
+            return "?" + name;
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+package org.cx4a.rsense.typing.annotation;
+
+public class TypeOptional implements TypeExpression {
+    private TypeExpression expr;
+
+    public TypeOptional(TypeExpression expr) {
+        this.expr = expr;
+    }
+
+    public TypeExpression getExpression() {
+        return expr;
+    }
+
+    public Type getType() {
+        return Type.OPTIONAL;
+    }
+
+    @Override
+    public String toString() {
+        return "?" + expr;
+    }
+}

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

@@ -0,0 +1,22 @@
+package org.cx4a.rsense.typing.annotation;
+
+public class TypePragma implements TypeExpression {
+    private Type type;
+
+    public TypePragma(Type type) {
+        this.type = type;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    @Override
+    public String toString() {
+        switch (type) {
+        case NOBODY_PRAGMA:
+            return "!nobody";
+        }
+        return "unknown-pragma";
+    }
+}

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

@@ -0,0 +1,22 @@
+package org.cx4a.rsense.typing.annotation;
+
+public class TypeSplat implements TypeExpression {
+    private TypeExpression expr;
+
+    public TypeSplat(TypeExpression expr) {
+        this.expr = expr;
+    }
+
+    public TypeExpression getExpression() {
+        return expr;
+    }
+
+    public Type getType() {
+        return Type.SPLAT;
+    }
+
+    @Override
+    public String toString() {
+        return expr != null ? "*" + expr.toString() : "*";
+    }
+}

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

@@ -0,0 +1,35 @@
+package org.cx4a.rsense.typing.annotation;
+
+import java.util.List;
+
+public class TypeTuple implements TypeExpression {
+    private List<TypeExpression> elements;
+
+    public TypeTuple(List<TypeExpression> elements) {
+        this.elements = elements;
+    }
+
+    public List<TypeExpression> getList() {
+        return elements;
+    }
+
+    public Type getType() {
+        return Type.TUPLE;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        String delim = "";
+        sb.append("(");
+        if (elements != null) {
+            for (TypeExpression expr : elements) {
+                sb.append(delim);
+                delim = ", ";
+                sb.append(expr.toString());
+            }
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,23 @@
+package org.cx4a.rsense.typing.annotation;
+
+import java.util.ArrayList;
+
+public class TypeUnion extends ArrayList<TypeExpression> implements TypeExpression {
+    private static final long serialVersionUID = 0L;
+
+    public Type getType() {
+        return Type.UNION;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        String delim = "";
+        for (TypeExpression expr : this) {
+            sb.append(delim);
+            delim = " or ";
+            sb.append(expr);
+        }
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,44 @@
+package org.cx4a.rsense.typing.annotation;
+
+public class TypeVariable implements TypeExpression {
+    private String name;
+
+    public TypeVariable(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Type getType() {
+        return Type.VARIABLE;
+    }
+
+    @Override
+    public String toString() {
+        return "@" + name;
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+
+        if (!(other instanceof TypeVariable)) {
+            return false;
+        }
+
+        return name.equals(((TypeVariable) other).name);
+    }
+
+    public static TypeVariable valueOf(String name) {
+        return new TypeVariable(name);
+    }
+}

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

@@ -0,0 +1,94 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.lang.ref.SoftReference;
+
+import java.util.List;
+import java.util.Map;
+
+import org.jrubyparser.ast.Node;
+
+import org.cx4a.rsense.ruby.IRubyObject;
+import org.cx4a.rsense.ruby.RubyModule;
+import org.cx4a.rsense.ruby.Block;
+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.vertex.Vertex;
+import org.cx4a.rsense.typing.annotation.MethodType;
+import org.cx4a.rsense.util.SourceLocation;
+
+public class AliasMethod implements Method {
+    private String newName;
+    private Method method;
+
+    public AliasMethod(String newName, Method method) {
+        this.newName = newName;
+        this.method = method;
+    }
+
+    public RubyModule getModule() {
+        return method.getModule();
+    }
+
+    public Visibility getVisibility() {
+        return method.getVisibility();
+    }
+
+    public void setVisibility(Visibility visibility) {
+        method.setVisibility(visibility);
+    }
+
+    public SourceLocation getLocation() {
+        return method.getLocation();
+    }
+
+    public String getName() {
+        return newName;
+    }
+
+    public Node getBodyNode() {
+        return method.getBodyNode();
+    }
+
+    public Node getArgsNode() {
+        return method.getArgsNode();
+    }
+
+    public void shareTemplates(Method with) {
+        method.shareTemplates(with);
+    }
+
+    public Map<TemplateAttribute, SoftReference<Template>> getTemplates() {
+        return method.getTemplates();
+    }
+
+    public Template getTemplate(TemplateAttribute key) {
+        return method.getTemplate(key);
+    }
+
+    public void addTemplate(TemplateAttribute key, Template template) {
+        method.addTemplate(key, template);
+    }
+
+    public boolean isTemplatesShared() {
+        return method.isTemplatesShared();
+    }
+
+    public List<MethodType> getAnnotations() {
+        return method.getAnnotations();
+    }
+
+    public void setAnnotations(List<MethodType> annotations) {
+        method.setAnnotations(annotations);
+    }
+
+    public Vertex call(Graph graph, Template template, IRubyObject receiver, IRubyObject[] args, Vertex[] argVertices, Block block) {
+        return method.call(graph, template, receiver, args, argVertices, block);
+    }
+
+    @Override
+    public String toString() {
+        return getModule().getMethodPath(getName());
+    }
+}

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

@@ -0,0 +1,69 @@
+package org.cx4a.rsense.typing.runtime;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.jrubyparser.ast.CommentNode;
+
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
+
+import org.cx4a.rsense.parser.TypeAnnotationLexer;
+import org.cx4a.rsense.parser.TypeAnnotationParser;
+import org.cx4a.rsense.typing.Graph;
+import org.cx4a.rsense.typing.Template;
+import org.cx4a.rsense.typing.annotation.TypeAnnotation;
+
+public class AnnotationHelper {
+    private AnnotationHelper() {}
+
+    public static TypeAnnotation parseAnnotation(String annot, int lineno) {
+        if (annot.startsWith("##%")) {
+            ANTLRStringStream in = new ANTLRStringStream(annot.substring(3));
+            in.setLine(lineno);
+            TypeAnnotationLexer lex = new TypeAnnotationLexer(in);
+            CommonTokenStream tokens = new CommonTokenStream(lex);
+            TypeAnnotationParser parser = new TypeAnnotationParser(tokens);
+            try {
+                return parser.type();
+            } catch (RecognitionException e)  {}
+        }
+        return null;
+    }
+
+            // Collection<CommentNode> comments = node.getComments();
+
+
+
+    public static List<TypeAnnotation> parseAnnotations(Collection<CommentNode> comments, int lineno) {
+        List<TypeAnnotation> annots = new ArrayList<TypeAnnotation>();
+        for (Iterator<CommentNode> iterator = comments.iterator(); iterator.hasNext(); )
+        {
+            CommentNode next = iterator.next();
+            String nodeComment = next.getContent();
+            TypeAnnotation annot = parseAnnotation(nodeComment, lineno);
+            if (annot != null) {
+                annots.add(annot);
+            }
+        }
+        return annots;
+    }
+
+    public static List<TypeAnnotation> parseAnnotations(List<String> commentList, int lineno) {
+        List<TypeAnnotation> annots = new ArrayList<TypeAnnotation>();
+        for (String comment : commentList) {
+            TypeAnnotation annot = parseAnnotation(comment.toString(), lineno);
+            if (annot != null) {
+                annots.add(annot);
+            }
+        }
+        return annots;
+    }
+
+    public static AnnotationResolver.Result resolveMethodAnnotation(Graph graph, Template template) {
+        return new AnnotationResolver(graph).resolveMethodAnnotation(template);
+    }
+}