[GR-18163] Fix warnings for Enumerable#inject

PullRequest: truffleruby/3671

Author: eregon

spec/ruby/core/enumerable/shared/inject.rb

@@ -28,6 +28,15 @@
     }.should complain(/#{__FILE__}:#{__LINE__-1}: warning: given block not used/, verbose: true)
   end
 
+  it "does not warn when given a Symbol with $VERBOSE true" do
+    -> {
+      [1, 2].send(@method, 0, :+)
+      [1, 2].send(@method, :+)
+      EnumerableSpecs::Numerous.new(1, 2).send(@method, 0, :+)
+      EnumerableSpecs::Numerous.new(1, 2).send(@method, :+)
+    }.should_not complain(verbose: true)
+  end
+
   it "can take a symbol argument" do
     EnumerableSpecs::Numerous.new(10, 1, 2, 3).send(@method, :-).should == 4
   end

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

@@ -1350,7 +1350,7 @@ private static class State {
         @Child private DispatchNode dispatch = DispatchNode.create(PUBLIC);
         @Child private CallBlockNode yieldNode = CallBlockNode.create();
 
-        // Uses block
+        // Uses block and no Symbol
 
         @Specialization(guards = { "isEmptyArray(array)", "wasProvided(initialOrSymbol)" })
         protected Object injectEmptyArray(RubyArray array, Object initialOrSymbol, NotProvided symbol, RubyProc block) {
@@ -1380,7 +1380,7 @@ protected Object injectNoInitial(
             return injectBlockHelper(array, block, stores.read(store, 0), 1, iteratorNode);
         }
 
-        public Object injectBlockHelper(RubyArray array,
+        private Object injectBlockHelper(RubyArray array,
                 RubyProc block, Object initial, int start, ArrayEachIteratorNode iteratorNode) {
             Object accumulator = initial;
             State iterationState = new State(accumulator, block);
@@ -1397,7 +1397,7 @@ public void accept(RubyArray array, Object stateObject, Object element, int inde
             state.accumulator = accumulator;
         }
 
-        // Uses Symbol
+        // Uses Symbol and no block
 
         @Specialization(guards = { "isEmptyArray(array)" })
         protected Object injectSymbolEmptyArrayNoInitial(
@@ -1409,8 +1409,7 @@ protected Object injectSymbolEmptyArrayNoInitial(
                 guards = {
                         "isEmptyArray(array)",
                         "wasProvided(initialOrSymbol)" })
-        protected Object injectSymbolEmptyArray(
-                RubyArray array, Object initialOrSymbol, RubySymbol symbol, Object maybeBlock) {
+        protected Object injectSymbolEmptyArray(RubyArray array, Object initialOrSymbol, RubySymbol symbol, Nil block) {
             return initialOrSymbol;
         }
 
@@ -1442,17 +1441,12 @@ protected Object injectSymbolNoInitial(
                         "wasProvided(initialOrSymbol)" },
                 limit = "storageStrategyLimit()")
         protected Object injectSymbolWithInitial(
-                VirtualFrame frame, RubyArray array, Object initialOrSymbol, RubySymbol symbol, Object block,
+                VirtualFrame frame, RubyArray array, Object initialOrSymbol, RubySymbol symbol, Nil block,
                 @Bind("array.getStore()") Object store,
                 @CachedLibrary("store") ArrayStoreLibrary stores,
                 @Cached IntValueProfile arraySizeProfile,
                 @Cached LoopConditionProfile loopProfile,
-                @Cached ToJavaStringNode toJavaString,
-                @Cached("new()") WarningNode warningNode) {
-            if (warningNode.shouldWarn()) {
-                final SourceSection sourceSection = getContext().getCallStack().getTopMostUserSourceSection();
-                warningNode.warningMessage(sourceSection, "given block not used");
-            }
+                @Cached ToJavaStringNode toJavaString) {
             return injectSymbolHelper(
                     frame,
                     array,
@@ -1465,15 +1459,7 @@ protected Object injectSymbolWithInitial(
                     loopProfile);
         }
 
-        // No Symbol or Block
-
-        @Specialization
-        protected Object injectNoSymbolNonEmptyArrayNoInitial(
-                RubyArray array, NotProvided initialOrSymbol, NotProvided symbol, Nil block) {
-            throw new RaiseException(getContext(), coreExceptions().argumentError("no block or symbol given", this));
-        }
-
-        public Object injectSymbolHelper(VirtualFrame frame, RubyArray array, String symbol,
+        private Object injectSymbolHelper(VirtualFrame frame, RubyArray array, String symbol,
                 ArrayStoreLibrary stores, Object store, Object initial, int start,
                 IntValueProfile arraySizeProfile, LoopConditionProfile loopProfile) {
             Object accumulator = initial;

src/main/ruby/truffleruby/core/enumerable.rb

@@ -510,22 +510,23 @@ def sort_by
   #   inject(initial_operand, symbol) -> object
   #   inject {|memo, operand| ... } -> object
   #   inject(initial_operand) {|memo, operand| ... } -> object
-  def inject(initial=undefined, sym=undefined, &block)
-    if Array === self
-      return Primitive.array_inject(self, initial, sym, block)
-    end
-
+  def inject(initial = undefined, sym = undefined, &block)
     # inject()
-    if !block_given? && Primitive.undefined?(initial)
+    if !block && Primitive.undefined?(initial)
       raise ArgumentError, 'no block or symbol given'
     end
 
     # inject(initial_operand, symbol) { ... }
-    if block_given? && !Primitive.undefined?(sym)
+    if block && !Primitive.undefined?(sym)
       Primitive.warn_given_block_not_used
+      block = nil
+    end
+
+    if Primitive.object_kind_of?(self, ::Array)
+      return Primitive.array_inject(self, initial, sym, block)
     end
 
-    if Primitive.undefined?(sym) && block_given?
+    if Primitive.undefined?(sym) && block
       # Do the block version:
       #   inject {|memo, operand| ... } -> object
       #   inject(initial_operand) {|memo, operand| ... } -> object