[GR-20462] Implement endless ranges.

PullRequest: truffleruby/1272

Author: eregon

CHANGELOG.md

@@ -108,6 +108,9 @@ Compatibility:
 * Implemented `Kernel#system` `exception: true` option.
 * Implemented `Random.bytes`.
 * Implemented `Random.random_number`.
+* Added the ability to parse endless ranges.
+* Made `Range#to_a` compatible with endless ranges.
+* Made `Array#[]` and `Array#[]= ` compatible with endless ranges.
 
 Performance:
 

spec/ruby/core/array/element_set_spec.rb

@@ -396,6 +396,14 @@ def obj.to_ary() [1, 2, 3] end
     a.should == [1, 2, 3, 8, 4, 5]
   end
 
+  it "inserts at the end if m > the array size" do
+    a = [1, 2, 3]
+    a[3..3] = [4]
+    a.should == [1, 2, 3, 4]
+    a[5..7] = [6]
+    a.should == [1, 2, 3, 4, nil, 6]
+  end
+
   describe "Range subclasses" do
     before :each do
       @range_incl = ArraySpecs::MyRange.new(1, 2)
@@ -425,6 +433,43 @@ def obj.to_ary() [1, 2, 3] end
   end
 end
 
+describe "Array#[]= with [m..]" do
+
+  it "just sets the section defined by range to nil even if the rhs is nil" do
+    a = [1, 2, 3, 4, 5]
+    a[2..] = nil
+    a.should == [1, 2, nil]
+  end
+
+  it "just sets the section defined by range to nil if m and n < 0 and the rhs is nil" do
+    a = [1, 2, 3, 4, 5]
+    a[-3..] = nil
+    a.should == [1, 2, nil]
+  end
+
+  it "replaces the section defined by range" do
+    a = [6, 5, 4, 3, 2, 1]
+    a[3...] = 9
+    a.should == [6, 5, 4, 9]
+    a[2..] = [7, 7, 7]
+    a.should == [6, 5, 7, 7, 7]
+  end
+
+  it "replaces the section if m and n < 0" do
+    a = [1, 2, 3, 4, 5]
+    a[-3..] = [7, 8, 9]
+    a.should == [1, 2, 7, 8, 9]
+  end
+
+  it "inserts at the end if m > the array size" do
+    a = [1, 2, 3]
+    a[3..] = [4]
+    a.should == [1, 2, 3, 4]
+    a[5..] = [6]
+    a.should == [1, 2, 3, 4, nil, 6]
+  end
+end
+
 describe "Array#[] after a shift" do
   it "works for insertion" do
     a = [1,2]

spec/ruby/core/array/to_a_spec.rb

@@ -21,4 +21,8 @@
     array = ArraySpecs.recursive_array
     array.to_a.should == array
   end
+
+  it "throws an exception for endless ranges" do
+    -> { (1..).to_a }.should raise_error(RangeError)
+  end
 end

spec/tags/core/range/new_tags.txt

@@ -25,7 +25,6 @@ public abstract class ArrayIndexNode extends ArrayCoreMethodNode {
 
     @Child private ArrayReadDenormalizedNode readNode;
     @Child private ArrayReadSliceDenormalizedNode readSliceNode;
-    @Child private ArrayReadSliceNormalizedNode readNormalizedSliceNode;
     @Child private AllocateObjectNode allocateObjectNode = AllocateObjectNode.create();
 
     @Specialization
@@ -54,32 +53,26 @@ protected DynamicObject slice(DynamicObject array, int start, int length) {
     @Specialization(guards = "isIntRange(range)")
     protected DynamicObject slice(DynamicObject array, DynamicObject range, NotProvided len,
             @Cached("createBinaryProfile()") ConditionProfile negativeBeginProfile,
-            @Cached("createBinaryProfile()") ConditionProfile negativeEndProfile) {
+            @Cached("createBinaryProfile()") ConditionProfile negativeEndProfile,
+            @Cached ArrayReadSliceNormalizedNode readNormalizedSliceNode) {
         final int size = getSize(array);
-        final int normalizedIndex = ArrayOperations
+        final int normalizedBegin = ArrayOperations
                 .normalizeIndex(size, Layouts.INT_RANGE.getBegin(range), negativeBeginProfile);
 
-        if (normalizedIndex < 0 || normalizedIndex > size) {
+        if (normalizedBegin < 0 || normalizedBegin > size) {
             return nil();
         } else {
             final int end = ArrayOperations
                     .normalizeIndex(size, Layouts.INT_RANGE.getEnd(range), negativeEndProfile);
             final int exclusiveEnd = ArrayOperations
                     .clampExclusiveIndex(size, Layouts.INT_RANGE.getExcludedEnd(range) ? end : end + 1);
 
-            if (exclusiveEnd <= normalizedIndex) {
+            if (exclusiveEnd <= normalizedBegin) {
                 return allocateObjectNode
                         .allocate(Layouts.BASIC_OBJECT.getLogicalClass(array), ArrayStrategy.NULL_ARRAY_STORE, 0);
             }
 
-            final int length = exclusiveEnd - normalizedIndex;
-
-            if (readNormalizedSliceNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                readNormalizedSliceNode = insert(ArrayReadSliceNormalizedNodeGen.create());
-            }
-
-            return readNormalizedSliceNode.executeReadSlice(array, normalizedIndex, length);
+            return readNormalizedSliceNode.executeReadSlice(array, normalizedBegin, exclusiveEnd - normalizedBegin);
         }
     }
 

spec/tags/language/range_tags.txt

@@ -219,13 +219,15 @@ protected Object setRange(DynamicObject array, DynamicObject range, Object value
     @Specialization(guards = { "isIntRange(range)", "!isRubyArray(value)" })
     protected Object setRangeWithNonArray(DynamicObject array, DynamicObject range, Object value,
             NotProvided unused) {
+        // the fallback will recurse after converting the object to an array
         return fallback(array, range, value, unused);
     }
 
     // array[start..end] = object_or_array (non-int range)
 
     @Specialization(guards = { "!isIntRange(range)", "isRubyRange(range)" })
     protected Object setOtherRange(DynamicObject array, DynamicObject range, Object value, NotProvided unused) {
+        // the fallback will recurse after converting the range to an int range
         return fallback(array, range, value, unused);
     }
 

src/main/java/org/truffleruby/core/array/ArrayIndexNode.java

@@ -278,6 +278,9 @@ protected Object fallback(DynamicObject array, Object index, Object length, Obje
             argumentNames = { "index_start_or_range", "length_or_value", "value" })
     public abstract static class IndexSetPrimitiveNode extends ArrayIndexSetNode {
 
+        // This primitive inherits from the same base as IndexSetNode and is called in its fallback.
+        // Hence we need to avoid infinite recursion on fallback.
+
         protected abstract RubyNode[] getArguments();
 
         @Override

src/main/java/org/truffleruby/core/array/ArrayIndexSetNode.java

@@ -386,8 +386,8 @@ protected DynamicObject toA(DynamicObject range) {
             }
         }
 
-        @Specialization(guards = "isObjectRange(range)")
-        protected Object toA(VirtualFrame frame, DynamicObject range) {
+        @Specialization(guards = { "isObjectRange(range)", "!isEndlessRange(getContext(), range)" })
+        protected Object boundedToA(VirtualFrame frame, DynamicObject range) {
             if (toAInternalCall == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 toAInternalCall = insert(CallDispatchHeadNode.createPrivate());
@@ -396,34 +396,53 @@ protected Object toA(VirtualFrame frame, DynamicObject range) {
             return toAInternalCall.call(range, "to_a_internal");
         }
 
+        @Specialization(guards = { "isObjectRange(range)", "isEndlessRange(getContext(), range)" })
+        protected Object endlessToA(VirtualFrame frame, DynamicObject range) {
+            throw new RaiseException(getContext(), coreExceptions().rangeError(
+                    "cannot convert endless range to an array",
+                    this));
+        }
+
     }
 
+    /**
+     * Returns a conversion of the range into an int range, with regard to the supplied array
+     * (the array is necessary to handle endless ranges).
+     */
     @Primitive(name = "range_to_int_range")
     public abstract static class ToIntRangeNode extends PrimitiveArrayArgumentsNode {
 
         @Child private ToIntNode toIntNode;
 
         @Specialization(guards = "isIntRange(range)")
-        protected DynamicObject intRange(DynamicObject range) {
+        protected DynamicObject intRange(DynamicObject range, DynamicObject array) {
             return range;
         }
 
         @Specialization(guards = "isLongRange(range)")
-        protected DynamicObject longRange(DynamicObject range) {
+        protected DynamicObject longRange(DynamicObject range, DynamicObject array) {
             int begin = toInt(Layouts.LONG_RANGE.getBegin(range));
             int end = toInt(Layouts.LONG_RANGE.getEnd(range));
             boolean excludedEnd = Layouts.LONG_RANGE.getExcludedEnd(range);
             return Layouts.INT_RANGE.createIntRange(coreLibrary().intRangeFactory, excludedEnd, begin, end);
         }
 
-        @Specialization(guards = "isObjectRange(range)")
-        protected DynamicObject objectRange(DynamicObject range) {
+        @Specialization(guards = { "isObjectRange(range)", "!isEndlessRange(getContext(), range)" })
+        protected DynamicObject boundedObjectRange(DynamicObject range, DynamicObject array) {
             int begin = toInt(Layouts.OBJECT_RANGE.getBegin(range));
             int end = toInt(Layouts.OBJECT_RANGE.getEnd(range));
             boolean excludedEnd = Layouts.OBJECT_RANGE.getExcludedEnd(range);
             return Layouts.INT_RANGE.createIntRange(coreLibrary().intRangeFactory, excludedEnd, begin, end);
         }
 
+        @Specialization(guards = { "isObjectRange(range)", "isEndlessRange(getContext(), range)" })
+        protected DynamicObject endlessObjectRange(DynamicObject range, DynamicObject array) {
+            int begin = toInt(Layouts.OBJECT_RANGE.getBegin(range));
+            int end = Layouts.ARRAY.getSize(array);
+            boolean excludedEnd = true;
+            return Layouts.INT_RANGE.createIntRange(coreLibrary().intRangeFactory, excludedEnd, begin, end);
+        }
+
         private int toInt(Object indexObject) {
             if (toIntNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
@@ -495,14 +514,7 @@ protected Object objectRange(
                 allocateNode = insert(AllocateObjectNode.create());
             }
 
-            final Object cmpResult;
-            try {
-                cmpResult = cmpNode.call(begin, "<=>", end);
-            } catch (RaiseException e) {
-                throw new RaiseException(getContext(), coreExceptions().argumentError("bad value for range", this));
-            }
-
-            if (cmpResult == nil()) {
+            if (cmpNode.call(begin, "<=>", end) == nil() && end != nil()) {
                 throw new RaiseException(getContext(), coreExceptions().argumentError("bad value for range", this));
             }
 

src/main/java/org/truffleruby/core/array/ArrayNodes.java

@@ -127,6 +127,11 @@ public static boolean isObjectRange(DynamicObject object) {
         return Layouts.OBJECT_RANGE.isObjectRange(object);
     }
 
+    public static boolean isEndlessRange(RubyContext context, DynamicObject object) {
+        assert isObjectRange(object);
+        return isNil(context, Layouts.OBJECT_RANGE.getEnd(object));
+    }
+
     public static boolean isRubyRange(Object value) {
         return isIntRange(value) || isLongRange(value) || isObjectRange(value);
     }