[Truffle] Add a Hash check that keys are symbols when splatted

jruby · Nov 30, 2016 · 6bf398b · 6bf398b
1 parent 2eab42d
commit 6bf398b
Show file tree

Hide file tree

Showing 3 changed files with 22 additions and 3 deletions.
diff --git a/spec/truffle/tags/language/hash_tags.txt b/spec/truffle/tags/language/hash_tags.txt
diff --git a/truffle/src/main/java/org/jruby/truffle/core/hash/ConcatHashLiteralNode.java b/truffle/src/main/java/org/jruby/truffle/core/hash/ConcatHashLiteralNode.java
@@ -16,18 +16,23 @@
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.RubyContext;
+import org.jruby.truffle.language.RubyGuards;
 import org.jruby.truffle.language.RubyNode;
+import org.jruby.truffle.language.control.RaiseException;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class ConcatHashLiteralNode extends RubyNode {
 
     @Children private final RubyNode[] children;
+    private final boolean[] mergeChildren;
 
-    public ConcatHashLiteralNode(RubyContext context, SourceSection sourceSection, RubyNode[] children) {
+    public ConcatHashLiteralNode(RubyContext context, SourceSection sourceSection, RubyNode[] children, boolean[] mergeChildren) {
         super(context, sourceSection);
+        assert children.length == mergeChildren.length;
         this.children = children;
+        this.mergeChildren = mergeChildren;
     }
 
     @Override
@@ -54,6 +59,13 @@ protected DynamicObject[] executeChildren(VirtualFrame frame) {
         for (int i = 0; i < children.length; i++) {
             try {
                 DynamicObject hash = children[i].executeDynamicObject(frame);
+                if (mergeChildren[i]) {
+                    for (KeyValue keyValue : HashOperations.iterableKeyValues(hash)) {
+                        if (!RubyGuards.isRubySymbol(keyValue.getKey())) {
+                            throw new RaiseException(coreExceptions().typeErrorWrongArgumentType(keyValue.getKey(), "Symbol", this));
+                        }
+                    }
+                }
                 values[i] = hash;
             } catch (UnexpectedResultException e) {
                 throw new UnsupportedOperationException(children[i].getClass() + " " + e.getResult().getClass());

diff --git a/truffle/src/main/java/org/jruby/truffle/parser/BodyTranslator.java b/truffle/src/main/java/org/jruby/truffle/parser/BodyTranslator.java
@@ -1826,14 +1826,17 @@ public RubyNode visitHashNode(HashParseNode node) {
         final SourceSection fullSourceSection = sourceSection.toSourceSection(source);
 
         final List<RubyNode> hashConcats = new ArrayList<>();
+        final List<Boolean> hashConcatsIsMerge = new ArrayList<>();
 
         final List<RubyNode> keyValues = new ArrayList<>();
 
         for (KeyValuePair<ParseNode, ParseNode> pair: node.getPairs()) {
             if (pair.getKey() == null) {
                 final RubyNode hashLiteralSoFar = HashLiteralNode.create(context, fullSourceSection, keyValues.toArray(new RubyNode[keyValues.size()]));
                 hashConcats.add(hashLiteralSoFar);
+                hashConcatsIsMerge.add(false);
                 hashConcats.add(HashCastNodeGen.create(context, fullSourceSection, pair.getValue().accept(this)));
+                hashConcatsIsMerge.add(true);
                 keyValues.clear();
             } else {
                 keyValues.add(pair.getKey().accept(this));
@@ -1848,13 +1851,18 @@ public RubyNode visitHashNode(HashParseNode node) {
 
         final RubyNode hashLiteralSoFar = HashLiteralNode.create(context, fullSourceSection, keyValues.toArray(new RubyNode[keyValues.size()]));
         hashConcats.add(hashLiteralSoFar);
+        hashConcatsIsMerge.add(false);
 
         if (hashConcats.size() == 1) {
             final RubyNode ret = hashConcats.get(0);
             return addNewlineIfNeeded(node, ret);
         }
 
-        final RubyNode ret = new ConcatHashLiteralNode(context, fullSourceSection, hashConcats.toArray(new RubyNode[hashConcats.size()]));
+        boolean[] hashConcatsIsMergeArray = new boolean[hashConcatsIsMerge.size()];
+        for (int i = 0; i < hashConcatsIsMerge.size(); i++) {
+            hashConcatsIsMergeArray[i] = hashConcatsIsMerge.get(i);
+        }
+        final RubyNode ret = new ConcatHashLiteralNode(context, fullSourceSection, hashConcats.toArray(new RubyNode[hashConcats.size()]), hashConcatsIsMergeArray);
         return addNewlineIfNeeded(node, ret);
     }