Make all overloads of ArrayLiteral#[] return nil on out of bounds (#16453)

The single-index overload in the macro language has always behaved like `#[]?` in non-macro code, so I don't think there is any particular benefit in making both the range overload and the start + count overload both raise on out-of-bounds start indices.

This actually applies to `TupleLiteral` as well.

Author: HertzDevil

spec/compiler/macro/macro_methods_spec.cr

@@ -1043,10 +1043,20 @@ module Crystal
         assert_macro %({{ [1, 2, 3, 4][nil..nil] }}), %([1, 2, 3, 4])
       end
 
+      it "executes [] with range, start is out of bounds" do
+        assert_macro %({{ [1, 2, 3, 4][5..] }}), %(nil)
+        assert_macro %({{ [1, 2, 3, 4][-5..] }}), %(nil)
+      end
+
       it "executes [] with two numbers" do
         assert_macro %({{ [1, 2, 3, 4, 5][1, 3] }}), %([2, 3, 4])
       end
 
+      it "executes [] with two numbers, start is out of bounds" do
+        assert_macro %({{ [1, 2, 3, 4][5, 1] }}), %(nil)
+        assert_macro %({{ [1, 2, 3, 4][-5, 4] }}), %(nil)
+      end
+
       it "executes []=" do
         assert_macro %({% a = [0]; a[0] = 2 %}{{a[0]}}), "2"
       end
@@ -1341,6 +1351,20 @@ module Crystal
         assert_macro %({{ {1, 2, 3, 4}[nil..nil] }}), %({1, 2, 3, 4})
       end
 
+      it "executes [] with range, start is out of bounds" do
+        assert_macro %({{ {1, 2, 3, 4}[5..] }}), %(nil)
+        assert_macro %({{ {1, 2, 3, 4}[-5..] }}), %(nil)
+      end
+
+      it "executes [] with two numbers" do
+        assert_macro %({{ {1, 2, 3, 4, 5}[1, 3] }}), %({2, 3, 4})
+      end
+
+      it "executes [] with two numbers, start is out of bounds" do
+        assert_macro %({{ {1, 2, 3, 4}[5, 1] }}), %(nil)
+        assert_macro %({{ {1, 2, 3, 4}[-5, 4] }}), %(nil)
+      end
+
       it "executes size" do
         assert_macro %({{ {1, 2, 3}.size }}), "3"
       end

src/compiler/crystal/macros.cr

@@ -804,12 +804,16 @@ module Crystal::Macros
     def uniq : ArrayLiteral
     end
 
-    # Similar to `Array#[]`, but returns `NilLiteral` on out of bounds.
+    # Similar to `Array#[]?(Int)`.
     def [](index : NumberLiteral) : ASTNode
     end
 
-    # Similar to `Array#[]`.
-    def [](index : RangeLiteral) : ArrayLiteral(ASTNode)
+    # Similar to `Array#[]?(Range)`.
+    def [](index : RangeLiteral) : ArrayLiteral(ASTNode) | NilLiteral
+    end
+
+    # Similar to `Array#[]?(Int, Int)`.
+    def [](start : NumberLiteral, count : NumberLiteral) : ArrayLiteral(ASTNode) | NilLiteral
     end
 
     # Similar to `Array#[]=`.
@@ -1118,12 +1122,17 @@ module Crystal::Macros
     def uniq : TupleLiteral
     end
 
-    # Similar to `Tuple#[]`, but returns `NilLiteral` on out of bounds.
+    # Similar to `Tuple#[]?(Int)`.
     def [](index : NumberLiteral) : ASTNode
     end
 
-    # Similar to `Tuple#[]`.
-    def [](index : RangeLiteral) : TupleLiteral(ASTNode)
+    # Similar to `Tuple#[]?(Range)`.
+    def [](index : RangeLiteral) : TupleLiteral | NilLiteral
+    end
+
+    # Similar to `Array#[]?(Int, Int)`, but returns another `TupleLiteral`
+    # instead of an `ArrayLiteral`.
+    def [](start : NumberLiteral, count : NumberLiteral) : TupleLiteral | NilLiteral
     end
 
     # Similar to `Array#[]=`.

src/compiler/crystal/macros/methods.cr

@@ -3135,24 +3135,17 @@ private def interpret_array_or_tuple_method(object, klass, method, args, named_a
 
         from = from.to_number.to_i
         to = to.to_number.to_i
-
-        begin
-          klass.new(object.elements[from, to])
-        rescue ex
-          object.raise ex.message
-        end
+        values = object.elements[from, to]?
+        values ? klass.new(values) : Crystal::NilLiteral.new
       else
         case arg = from
         when Crystal::NumberLiteral
           index = arg.to_number.to_i
           object.elements[index]? || Crystal::NilLiteral.new
         when Crystal::RangeLiteral
           range = arg.interpret_to_nilable_range(interpreter)
-          begin
-            klass.new(object.elements[range])
-          rescue ex
-            object.raise ex.message
-          end
+          values = object.elements[range]?
+          values ? klass.new(values) : Crystal::NilLiteral.new
         else
           arg.raise "argument to [] must be a number or range, not #{arg.class_desc}:\n\n#{arg}"
         end