jruby · Feb 27, 2015 · Feb 27, 2015 · Feb 27, 2015 · Feb 27, 2015 · Feb 27, 2015
diff --git a/spec/truffle/tags/core/exception/exception_tags.txt b/spec/truffle/tags/core/exception/exception_tags.txt
@@ -2,9 +2,6 @@ fails:Exception.exception creates a new instance of Exception
 fails:Exception.exception sets the message of the Exception when passes a message
 fails:Exception.exception returns 'Exception' for message when no message given
 fails:Exception.exception returns the exception when it has a custom constructor
-fails:Exception is a superclass of SystemStackError
-fails:Exception is a superclass of SecurityError
-fails:Exception is a superclass of EncodingError
 fails:Exception#exception returns self when passed no argument
 fails:Exception#exception returns self when passed self as an argument
 fails:Exception#exception returns an exception of the same class as self with the message given as argument

diff --git a/spec/truffle/tags/core/exception/io_error_tags.txt b/spec/truffle/tags/core/exception/io_error_tags.txt
diff --git a/spec/truffle/tags/core/exception/script_error_tags.txt b/spec/truffle/tags/core/exception/script_error_tags.txt
diff --git a/spec/truffle/tags/core/exception/standard_error_tags.txt b/spec/truffle/tags/core/exception/standard_error_tags.txt
diff --git a/spec/truffle/tags/core/exception/system_stack_error_tags.txt b/spec/truffle/tags/core/exception/system_stack_error_tags.txt
diff --git a/spec/truffle/tags/core/module/gt_tags.txt b/spec/truffle/tags/core/module/gt_tags.txt
diff --git a/spec/truffle/tags/core/module/gte_tags.txt b/spec/truffle/tags/core/module/gte_tags.txt
diff --git a/spec/truffle/tags/core/module/lt_tags.txt b/spec/truffle/tags/core/module/lt_tags.txt
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java
@@ -17,7 +17,6 @@
 import com.oracle.truffle.api.dsl.NodeChildren;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.nodes.Node.Child;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.utilities.ConditionProfile;
@@ -29,11 +28,9 @@
 import org.jruby.truffle.nodes.cast.BooleanCastNode;
 import org.jruby.truffle.nodes.cast.BooleanCastNodeFactory;
 import org.jruby.truffle.nodes.coerce.SymbolOrToStrNodeFactory;
-import org.jruby.truffle.nodes.coerce.ToStrNode;
 import org.jruby.truffle.nodes.coerce.ToStrNodeFactory;
 import org.jruby.truffle.nodes.control.SequenceNode;
 import org.jruby.truffle.nodes.core.KernelNodes.BindingNode;
-import org.jruby.truffle.nodes.core.StringNodes.StringNodesHelper;
 import org.jruby.truffle.nodes.dispatch.*;
 import org.jruby.truffle.nodes.methods.SetMethodDeclarationContext;
 import org.jruby.truffle.nodes.methods.arguments.CheckArityNode;
@@ -86,7 +83,7 @@ public boolean containsInstance(RubyModule module, Object instance) {
         }
     }
 
-    @CoreMethod(names = "<=", required = 1)
+    @CoreMethod(names = "<", required = 1)
     public abstract static class IsSubclassOfNode extends CoreMethodNode {
 
         public IsSubclassOfNode(RubyContext context, SourceSection sourceSection) {
@@ -103,7 +100,11 @@ public IsSubclassOfNode(IsSubclassOfNode prev) {
         public Object isSubclassOf(VirtualFrame frame, RubyModule self, RubyModule other) {
             notDesignedForCompilation();
 
-            if (self == other || ModuleOperations.includesModule(self, other)) {
+            if (self == other) {
+                return false;
+            }
+
+            if (ModuleOperations.includesModule(self, other)) {
                 return true;
             }
 
@@ -123,10 +124,125 @@ public Object isSubclassOf(VirtualFrame frame, RubyModule self, RubyBasicObject
 
     }
 
+    @CoreMethod(names = "<=", required = 1)
+    public abstract static class IsSubclassOfOrEqualToNode extends CoreMethodNode {
+
+        public IsSubclassOfOrEqualToNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public IsSubclassOfOrEqualToNode(IsSubclassOfOrEqualToNode prev) {
+            super(prev);
+        }
+
+        public abstract Object executeIsSubclassOfOrEqualTo(VirtualFrame frame, RubyModule self, RubyModule other);
+
+        @Specialization
+        public Object isSubclassOfOrEqualTo(VirtualFrame frame, RubyModule self, RubyModule other) {
+            notDesignedForCompilation();
+
+            if (self == other || ModuleOperations.includesModule(self, other)) {
+                return true;
+            }
+
+            if (ModuleOperations.includesModule(other, self)) {
+                return false;
+            }
+
+            return getContext().getCoreLibrary().getNilObject();
+        }
+
+        @Specialization
+        public Object isSubclassOfOrEqualTo(VirtualFrame frame, RubyModule self, RubyBasicObject other) {
+            notDesignedForCompilation();
+
+            throw new RaiseException(getContext().getCoreLibrary().typeError("compared with non class/module", this));
+        }
+
+    }
+
+    @CoreMethod(names = ">", required = 1)
+    public abstract static class IsSuperclassOfNode extends CoreMethodNode {
+
+        public IsSuperclassOfNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public IsSuperclassOfNode(IsSuperclassOfNode prev) {
+            super(prev);
+        }
+
+        public abstract Object executeIsSuperclassOf(VirtualFrame frame, RubyModule self, RubyModule other);
+
+        @Specialization
+        public Object isSuperclassOf(VirtualFrame frame, RubyModule self, RubyModule other) {
+            notDesignedForCompilation();
+
+            if (self == other) {
+                return false;
+            }
+
+            if (ModuleOperations.includesModule(other, self)) {
+                return true;
+            }
+
+            if (ModuleOperations.includesModule(self, other)) {
+                return false;
+            }
+
+            return getContext().getCoreLibrary().getNilObject();
+        }
+
+        @Specialization
+        public Object isSuperclassOf(VirtualFrame frame, RubyModule self, RubyBasicObject other) {
+            notDesignedForCompilation();
+
+            throw new RaiseException(getContext().getCoreLibrary().typeError("compared with non class/module", this));
+        }
+
+    }
+
+    @CoreMethod(names = ">=", required = 1)
+    public abstract static class IsSuperclassOfOrEqualToNode extends CoreMethodNode {
+
+        public IsSuperclassOfOrEqualToNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        public IsSuperclassOfOrEqualToNode(IsSuperclassOfOrEqualToNode prev) {
+            super(prev);
+        }
+
+        public abstract Object executeIsSuperclassOfOrEqualTo(VirtualFrame frame, RubyModule self, RubyModule other);
+
+        @Specialization
+        public Object isSuperclassOfOrEqualTo(VirtualFrame frame, RubyModule self, RubyModule other) {
+            notDesignedForCompilation();
+
+            if (self == other || ModuleOperations.includesModule(other, self)) {
+                return true;
+            }
+
+            if (ModuleOperations.includesModule(self, other)) {
+                return false;
+            }
+
+            return getContext().getCoreLibrary().getNilObject();
+        }
+
+        @Specialization
+        public Object isSuperclassOfOrEqualTo(VirtualFrame frame, RubyModule self, RubyBasicObject other) {
+            notDesignedForCompilation();
+
+            throw new RaiseException(getContext().getCoreLibrary().typeError("compared with non class/module", this));
+        }
+
+    }
+
     @CoreMethod(names = "<=>", required = 1)
     public abstract static class CompareNode extends CoreMethodNode {
 
-        @Child private IsSubclassOfNode subclassNode;
+        @Child private IsSubclassOfOrEqualToNode subclassNode;
         @Child private BooleanCastNode booleanCastNode;
 
         public CompareNode(RubyContext context, SourceSection sourceSection) {
@@ -140,9 +256,9 @@ public CompareNode(CompareNode prev) {
         private Object isSubclass(VirtualFrame frame, RubyModule self, RubyModule other) {
             if (subclassNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
-                subclassNode = insert(ModuleNodesFactory.IsSubclassOfNodeFactory.create(getContext(), getSourceSection(), new RubyNode[]{null, null}));
+                subclassNode = insert(ModuleNodesFactory.IsSubclassOfOrEqualToNodeFactory.create(getContext(), getSourceSection(), new RubyNode[]{null, null}));
             }
-            return subclassNode.executeIsSubclassOf(frame, self, other);
+            return subclassNode.executeIsSubclassOfOrEqualTo(frame, self, other);
         }
 
         private boolean booleanCast(VirtualFrame frame, Object value) {

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java
@@ -60,6 +60,8 @@ public class CoreLibrary {
     private final RubyClass complexClass;
     private final RubyClass dirClass;
     private final RubyClass encodingClass;
+    private final RubyClass encodingErrorClass;
+    private final RubyClass eofErrorClass;
     private final RubyClass exceptionClass;
     private final RubyClass falseClass;
     private final RubyClass fiberClass;
@@ -71,6 +73,7 @@ public class CoreLibrary {
     private final RubyClass integerClass;
     private final RubyClass indexErrorClass;
     private final RubyClass ioClass;
+    private final RubyClass ioErrorClass;
     private final RubyClass keyErrorClass;
     private final RubyClass loadErrorClass;
     private final RubyClass localJumpErrorClass;
@@ -80,6 +83,7 @@ public class CoreLibrary {
     private final RubyClass nilClass;
     private final RubyClass noMemoryErrorClass;
     private final RubyClass noMethodErrorClass;
+    private final RubyClass notImplementedErrorClass;
     private final RubyClass numericClass;
     private final RubyClass objectClass;
     private final RubyClass procClass;
@@ -91,13 +95,15 @@ public class CoreLibrary {
     private final RubyClass regexpErrorClass;
     private final RubyClass rubyTruffleErrorClass;
     private final RubyClass runtimeErrorClass;
+    private final RubyClass securityErrorClass;
     private final RubyClass standardErrorClass;
     private final RubyClass stringClass;
     private final RubyClass stringDataClass;
     private final RubyClass symbolClass;
     private final RubyClass syntaxErrorClass;
     private final RubyClass systemCallErrorClass;
     private final RubyClass systemExitClass;
+    private final RubyClass systemStackErrorClass;
     private final RubyClass threadClass;
     private final RubyClass timeClass;
     private final RubyClass trueClass;
@@ -177,6 +183,9 @@ public CoreLibrary(RubyContext context) {
         exceptionClass = defineClass("Exception");
         exceptionClass.setAllocator(new RubyException.ExceptionAllocator());
 
+        // EncodingError
+        encodingErrorClass = defineClass(exceptionClass, "EncodingError");
+
         // FiberError
         fiberErrorClass = defineClass(exceptionClass, "FiberError");
 
@@ -186,11 +195,12 @@ public CoreLibrary(RubyContext context) {
         // StandardError
         standardErrorClass = defineClass(exceptionClass, "StandardError");
         argumentErrorClass = defineClass(standardErrorClass, "ArgumentError");
-        loadErrorClass = defineClass(standardErrorClass, "LoadError");
+        ioErrorClass = defineClass(standardErrorClass, "IOError");
         localJumpErrorClass = defineClass(standardErrorClass, "LocalJumpError");
         regexpErrorClass = defineClass(standardErrorClass, "RegexpError");
         rubyTruffleErrorClass = defineClass(standardErrorClass, "RubyTruffleError");
         runtimeErrorClass = defineClass(standardErrorClass, "RuntimeError");
+        threadErrorClass = defineClass(standardErrorClass, "ThreadError");
         typeErrorClass = defineClass(standardErrorClass, "TypeError");
         zeroDivisionErrorClass = defineClass(standardErrorClass, "ZeroDivisionError");
 
@@ -202,6 +212,9 @@ public CoreLibrary(RubyContext context) {
         indexErrorClass = defineClass(standardErrorClass, "IndexError");
         keyErrorClass = defineClass(indexErrorClass, "KeyError");
 
+        // StandardError > IOError
+        eofErrorClass = defineClass(ioErrorClass, "EOFError");
+
         // StandardError > NameError
         nameErrorClass = defineClass(standardErrorClass, "NameError");
         noMethodErrorClass = defineClass(nameErrorClass, "NoMethodError");
@@ -219,17 +232,23 @@ public CoreLibrary(RubyContext context) {
 
         // ScriptError
         RubyClass scriptErrorClass = defineClass(exceptionClass, "ScriptError");
+        loadErrorClass = defineClass(scriptErrorClass, "LoadError");
+        notImplementedErrorClass = defineClass(scriptErrorClass, "NotImplementedError");
         syntaxErrorClass = defineClass(scriptErrorClass, "SyntaxError");
 
+        // SecurityError
+        securityErrorClass = defineClass(exceptionClass, "SecurityError");
+
         // SignalException
         RubyClass signalExceptionClass = defineClass(exceptionClass, "SignalException");
         defineClass(signalExceptionClass, "Interrupt");
 
         // SystemExit
         systemExitClass = defineClass(exceptionClass, "SystemExit");
 
-        // ThreadError
-        threadErrorClass = defineClass(exceptionClass, "ThreadError");
+        // SystemStackError
+        systemStackErrorClass = defineClass(exceptionClass, "SystemStackError");
+
 
         // Create core classes and modules