jruby · Nov 10, 2014 · Nov 10, 2014 · Nov 10, 2014
Showing with 63 additions and 22 deletions.

+1 −1 core/src/main/java/org/jruby/truffle/nodes/WriteConstantNode.java

+62 −13 core/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java

+0 −8 core/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java
diff --git a/core/src/main/java/org/jruby/truffle/nodes/WriteConstantNode.java b/core/src/main/java/org/jruby/truffle/nodes/WriteConstantNode.java
@@ -53,7 +53,7 @@ public Object execute(VirtualFrame frame) {
 
         final RubyModule module = (RubyModule) receiverObject;
 
-        module.setModuleConstant(this, name, rhsValue);
+        module.setConstant(this, name, rhsValue);
 
         return rhsValue;
     }

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/core/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -400,7 +400,48 @@ public RubyClass getClass(RubyBasicObject self) {
 
     }
 
-    @CoreMethod(names = {"dup", "clone"})
+    @CoreMethod(names = "clone")
+    public abstract static class CloneNode extends CoreMethodNode {
+
+        @Child protected DispatchHeadNode initializeCloneNode;
+
+        public CloneNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+            // Calls private initialize_clone on the new copy.
+            initializeCloneNode = new DispatchHeadNode(context, true, Dispatch.MissingBehavior.CALL_METHOD_MISSING);
+        }
+
+        public CloneNode(CloneNode prev) {
+            super(prev);
+            initializeCloneNode = prev.initializeCloneNode;
+        }
+
+        @Specialization
+        public Object clone(VirtualFrame frame, RubyModule self) {
+            notDesignedForCompilation();
+
+            final RubyBasicObject newObject = self.getLogicalClass().newInstance(this);
+            clone(frame, self, newObject);
+            return newObject;
+        }
+
+        @Specialization
+        public Object clone(VirtualFrame frame, RubyBasicObject self) {
+            notDesignedForCompilation();
+
+            final RubyBasicObject newObject = new RubyBasicObject(self.getLogicalClass());
+            clone(frame, self, newObject);
+            return newObject;
+        }
+
+        private void clone(VirtualFrame frame, RubyBasicObject self, RubyBasicObject newObject) {
+            newObject.setInstanceVariables(self.getFields());
+            initializeCloneNode.call(frame, newObject, "initialize_clone", null, self);
+        }
+
+    }
+
+    @CoreMethod(names = "dup")
     public abstract static class DupNode extends CoreMethodNode {
 
         @Child protected DispatchHeadNode initializeDupNode;
@@ -421,19 +462,22 @@ public Object dup(VirtualFrame frame, RubyModule self) {
             notDesignedForCompilation();
 
             final RubyBasicObject newObject = self.getLogicalClass().newInstance(this);
-            newObject.setInstanceVariables(self.getFields());
-            initializeDupNode.call(frame, newObject, "initialize_dup", null, self);
+            dup(frame, self, newObject);
             return newObject;
         }
 
         @Specialization
-        public Object dup(VirtualFrame frame, RubyObject self) {
+        public Object dup(VirtualFrame frame, RubyBasicObject self) {
             notDesignedForCompilation();
 
-            final RubyObject newObject = new RubyObject(self.getLogicalClass());
+            final RubyBasicObject newObject = new RubyObject(self.getLogicalClass());
+            dup(frame, self, newObject);
+            return newObject;
+        }
+
+        private void dup(VirtualFrame frame, RubyBasicObject self, RubyBasicObject newObject) {
             newObject.setInstanceVariables(self.getFields());
             initializeDupNode.call(frame, newObject, "initialize_dup", null, self);
-            return newObject;
         }
 
     }
@@ -786,31 +830,36 @@ public InitializeCopyNode(InitializeCopyNode prev) {
         }
 
         @Specialization
-        public Object initializeCopy(RubyObject self, RubyObject other) {
+        public Object initializeCopy(RubyBasicObject self, RubyBasicObject other) {
             notDesignedForCompilation();
 
-            return getContext().getCoreLibrary().getNilObject();
+            if (self.getLogicalClass() != other.getLogicalClass()) {
+                CompilerDirectives.transferToInterpreter();
+                throw new RaiseException(getContext().getCoreLibrary().typeError("initialize_copy should take same class object", this));
+            }
+
+            return self;
         }
 
     }
 
-    @CoreMethod(names = "initialize_dup", visibility = Visibility.PRIVATE, required = 1)
-    public abstract static class InitializeDupNode extends CoreMethodNode {
+    @CoreMethod(names = {"initialize_dup", "initialize_clone"}, visibility = Visibility.PRIVATE, required = 1)
+    public abstract static class InitializeDupCloneNode extends CoreMethodNode {
 
         @Child protected DispatchHeadNode initializeCopyNode;
 
-        public InitializeDupNode(RubyContext context, SourceSection sourceSection) {
+        public InitializeDupCloneNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
             initializeCopyNode = DispatchHeadNode.onSelf(context);
         }
 
-        public InitializeDupNode(InitializeDupNode prev) {
+        public InitializeDupCloneNode(InitializeDupCloneNode prev) {
             super(prev);
             initializeCopyNode = prev.initializeCopyNode;
         }
 
         @Specialization
-        public Object initializeDup(VirtualFrame frame, RubyObject self, RubyObject other) {
+        public Object initializeDup(VirtualFrame frame, RubyBasicObject self, RubyBasicObject other) {
             notDesignedForCompilation();
             return initializeCopyNode.call(frame, self, "initialize_copy", null, other);
         }

diff --git a/core/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java b/core/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java
@@ -232,14 +232,6 @@ public void removeClassVariable(RubyNode currentNode, String variableName) {
         classVariables.remove(variableName);
     }
 
-    public void setModuleConstant(RubyNode currentNode, String constantName, Object value) {
-        RubyNode.notDesignedForCompilation();
-
-        checkFrozen(currentNode);
-
-        setConstant(currentNode, constantName, value);
-    }
-
     public void addMethod(RubyNode currentNode, RubyMethod method) {
         RubyNode.notDesignedForCompilation();