Fix error message when there are extra keyword arguments

List all the extra keyword argument instead of the first one.

Author: andrykonchin

spec/ruby/language/keyword_arguments_spec.rb

@@ -58,6 +58,7 @@ def m(*a, kw:)
       m(kw: 1).should == []
       -> { m(kw: 1, kw2: 2) }.should raise_error(ArgumentError, 'unknown keyword: :kw2')
       -> { m(kw: 1, true => false) }.should raise_error(ArgumentError, 'unknown keyword: true')
+      -> { m(kw: 1, a: 1, b: 2, c: 3) }.should raise_error(ArgumentError, 'unknown keywords: :a, :b, :c')
     end
 
     it "handle * and ** at the same call site" do

src/main/java/org/truffleruby/core/exception/CoreExceptions.java

@@ -181,8 +181,18 @@ public RubyException argumentErrorCantOmitPrecision(Node currentNode) {
     }
 
     @TruffleBoundary
-    public RubyException argumentErrorUnknownKeyword(Object key, Node currentNode) {
-        return argumentError("unknown keyword: " + inspect(key), currentNode);
+    public RubyException argumentErrorUnknownKeywords(Object[] keys, Node currentNode) {
+        if (keys.length == 1) {
+            return argumentError("unknown keyword: " + inspect(keys[0]), currentNode);
+        }
+
+        final String[] names = new String[keys.length];
+
+        for (int i = 0; i < keys.length; i++) {
+            names[i] = inspect(keys[i]);
+        }
+
+        return argumentError("unknown keywords: " + String.join(", ", names), currentNode);
     }
 
     @TruffleBoundary

src/main/java/org/truffleruby/language/arguments/CheckKeywordArityNode.java

@@ -11,6 +11,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives;
 import org.truffleruby.RubyLanguage;
+import org.truffleruby.core.exception.RubyException;
 import org.truffleruby.core.hash.RubyHash;
 import org.truffleruby.core.hash.library.HashStoreLibrary;
 import org.truffleruby.core.hash.library.HashStoreLibrary.EachEntryCallback;
@@ -20,16 +21,22 @@
 import org.truffleruby.language.methods.Arity;
 
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 import com.oracle.truffle.api.profiles.BranchProfile;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
 /** Check that no extra keyword arguments are given, when there is no **kwrest */
 public class CheckKeywordArityNode extends RubyBaseNode {
 
     public final Arity arity;
     @Child private ReadUserKeywordsHashNode readUserKeywordsHashNode;
-    @Child private CheckKeywordArgumentsNode checkKeywordArgumentsNode;
+    @Child private CheckExtraKeywordArgumentsNode checkExtraKeywordArgumentsNode;
 
     public CheckKeywordArityNode(Arity arity) {
         assert !arity.hasKeywordsRest() : "no need to create this node";
@@ -45,37 +52,37 @@ public void checkArity(VirtualFrame frame) {
     }
 
     private void checkKeywordArguments(RubyHash keywordArguments) {
-        if (checkKeywordArgumentsNode == null) {
+        if (checkExtraKeywordArgumentsNode == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            checkKeywordArgumentsNode = insert(new CheckKeywordArgumentsNode(getLanguage(), arity));
+            checkExtraKeywordArgumentsNode = insert(new CheckExtraKeywordArgumentsNode(getLanguage(), arity));
         }
-        checkKeywordArgumentsNode.check(keywordArguments);
+
+        checkExtraKeywordArgumentsNode.check(keywordArguments);
     }
 
-    private static class CheckKeywordArgumentsNode extends RubyBaseNode implements EachEntryCallback {
+    private static class CheckExtraKeywordArgumentsNode extends RubyBaseNode implements EachEntryCallback {
 
         @CompilationFinal(dimensions = 1) private final RubySymbol[] allowedKeywords;
 
         private final BranchProfile unknownKeywordProfile = BranchProfile.create();
         @Child private HashStoreLibrary hashes;
 
-        public CheckKeywordArgumentsNode(RubyLanguage language, Arity arity) {
+        public CheckExtraKeywordArgumentsNode(RubyLanguage language, Arity arity) {
             assert !arity.hasKeywordsRest();
             hashes = HashStoreLibrary.createDispatched();
             allowedKeywords = keywordsAsSymbols(language, arity);
         }
 
         public void check(RubyHash keywordArguments) {
-            hashes.eachEntry(keywordArguments.store, keywordArguments, this, null);
+            hashes.eachEntry(keywordArguments.store, keywordArguments, this, keywordArguments);
         }
 
         @Override
         public void accept(int index, Object key, Object value, Object state) {
             if (!keywordAllowed(key)) {
                 unknownKeywordProfile.enter();
-                throw new RaiseException(
-                        getContext(),
-                        coreExceptions().argumentErrorUnknownKeyword(key, this));
+                RubyHash keywordArguments = (RubyHash) state;
+                throw new RaiseException(getContext(), unknownKeywordsError(keywordArguments));
             }
         }
 
@@ -89,6 +96,30 @@ private boolean keywordAllowed(Object keyword) {
 
             return false;
         }
+
+        @TruffleBoundary
+        private RubyException unknownKeywordsError(RubyHash keywordArguments) {
+            Object[] keys = findExtraKeywordArguments(keywordArguments);
+            return coreExceptions().argumentErrorUnknownKeywords(keys, this);
+        }
+
+        @TruffleBoundary
+        @SuppressWarnings("unchecked")
+        private Object[] findExtraKeywordArguments(RubyHash keywordArguments) {
+            final ArrayList<Object> actualKeywordsAsList = new ArrayList<>();
+            hashes.eachEntry(
+                    keywordArguments.store,
+                    keywordArguments,
+                    (index, key, value, state) -> ((ArrayList<Object>) state).add(key),
+                    actualKeywordsAsList);
+
+            final List<RubySymbol> allowedKeywordsAsList = Arrays.asList(allowedKeywords);
+            final List<Object> extraKeywords = actualKeywordsAsList.stream()
+                    .filter(k -> !allowedKeywordsAsList.contains(k))
+                    .collect(Collectors.toList());
+
+            return extraKeywords.toArray();
+        }
     }
 
     static RubySymbol[] keywordsAsSymbols(RubyLanguage language, Arity arity) {