Fix: set.is(super|sub)set must accept arbitrary iterables.

Author: fangerer

graalpython/com.oracle.graal.python.test/src/tests/test_set.py

@@ -187,13 +187,23 @@ def test_sub_and_super():
         assert not set('cbs').issuperset('a')
 
 
-def test_superset_list():
-    set = {1, 2, 3, 4}
-    list = [1, 2, 3, 4]
-    visited= False
-    if set.issuperset(list):
-        visited = True
-    assert visited
+def test_superset_subset():
+    l = [1, 2, 3, 4]
+    s = set(l)
+    t = tuple(l)
+    assert s.issuperset(s)
+    assert s.issuperset(l)
+    assert s.issuperset(t)
+    assert s >= s
+    assert_raises(TypeError, lambda: s >= l)
+    assert_raises(TypeError, lambda: s >= t)
+
+    assert s.issubset(s)
+    assert s.issubset(l)
+    assert s.issubset(t)
+    assert s <= s
+    assert_raises(TypeError, lambda: s <= l)
+    assert_raises(TypeError, lambda: s <= t)
 
 
 def test_intersection():

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/set/FrozenSetBuiltins.java

@@ -48,7 +48,6 @@
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.PNotImplemented;
 import com.oracle.graal.python.builtins.objects.common.EconomicMapStorage;
-import com.oracle.graal.python.builtins.objects.common.HashingCollectionNodes;
 import com.oracle.graal.python.builtins.objects.common.HashingStorage;
 import com.oracle.graal.python.builtins.objects.common.HashingStorage.Equivalence;
 import com.oracle.graal.python.builtins.objects.common.HashingStorageNodes;
@@ -72,7 +71,6 @@
 import com.oracle.graal.python.runtime.PythonContext;
 import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.graal.python.runtime.exception.PythonErrorType;
-import com.oracle.graal.python.runtime.sequence.PSequence;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.dsl.Cached;
@@ -140,29 +138,6 @@ PNotImplemented doGeneric(Object self, Object other) {
         }
     }
 
-    @Builtin(name = __LE__, minNumOfPositionalArgs = 2)
-    @GenerateNodeFactory
-    abstract static class LeNode extends PythonBinaryBuiltinNode {
-        @Child private HashingStorageNodes.ContainsKeyNode containsKeyNode = HashingStorageNodes.ContainsKeyNode.create();
-
-        @Specialization
-        Object run(VirtualFrame frame, PBaseSet self, PBaseSet other,
-                        @Cached HashingCollectionNodes.LenNode selfLen,
-                        @Cached HashingCollectionNodes.LenNode otherLen) {
-            if (selfLen.execute(self) > otherLen.execute(other)) {
-                return false;
-            }
-
-            for (Object value : self.values()) {
-                if (!containsKeyNode.execute(frame, other.getDictStorage(), value)) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-    }
-
     @Builtin(name = __AND__, minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
     abstract static class AndNode extends PythonBinaryBuiltinNode {
@@ -467,14 +442,14 @@ public static BinaryUnionNode create() {
     abstract static class IsSubsetNode extends PythonBinaryBuiltinNode {
         @Specialization
         boolean isSubSet(VirtualFrame frame, PBaseSet self, PBaseSet other,
-                        @Cached("create()") HashingStorageNodes.KeysIsSubsetNode isSubsetNode) {
+                        @Cached HashingStorageNodes.KeysIsSubsetNode isSubsetNode) {
             return isSubsetNode.execute(frame, self.getDictStorage(), other.getDictStorage());
         }
 
-        @Specialization
-        boolean isSubSet(VirtualFrame frame, PBaseSet self, String other,
-                        @Cached("create()") SetNodes.ConstructSetNode constructSetNode,
-                        @Cached("create()") HashingStorageNodes.KeysIsSubsetNode isSubsetNode) {
+        @Specialization(replaces = "isSubSet")
+        boolean isSubSetGeneric(VirtualFrame frame, PBaseSet self, Object other,
+                        @Cached SetNodes.ConstructSetNode constructSetNode,
+                        @Cached HashingStorageNodes.KeysIsSubsetNode isSubsetNode) {
             PSet otherSet = constructSetNode.executeWith(frame, other);
             return isSubsetNode.execute(frame, self.getDictStorage(), otherSet.getDictStorage());
         }
@@ -485,52 +460,49 @@ boolean isSubSet(VirtualFrame frame, PBaseSet self, String other,
     abstract static class IsSupersetNode extends PythonBinaryBuiltinNode {
         @Specialization
         boolean isSuperSet(VirtualFrame frame, PBaseSet self, PBaseSet other,
-                        @Cached("create()") HashingStorageNodes.KeysIsSupersetNode isSupersetNode) {
+                        @Cached HashingStorageNodes.KeysIsSupersetNode isSupersetNode) {
             return isSupersetNode.execute(frame, self.getDictStorage(), other.getDictStorage());
         }
 
-        @Specialization
-        boolean isSuperSetPSequence(VirtualFrame frame, PBaseSet self, PSequence other,
-                        @Cached("create()") SetNodes.ConstructSetNode constructSetNode,
-                        @Cached("create()") HashingStorageNodes.KeysIsSupersetNode isSupersetNode) {
+        @Specialization(replaces = "isSuperSet")
+        boolean isSuperSetGeneric(VirtualFrame frame, PBaseSet self, Object other,
+                        @Cached SetNodes.ConstructSetNode constructSetNode,
+                        @Cached HashingStorageNodes.KeysIsSupersetNode isSupersetNode) {
             PSet otherSet = constructSetNode.executeWith(frame, other);
             return isSupersetNode.execute(frame, self.getDictStorage(), otherSet.getDictStorage());
         }
 
-        @Specialization
-        boolean isSuperSetString(VirtualFrame frame, PBaseSet self, String other,
-                        @Cached("create()") SetNodes.ConstructSetNode constructSetNode,
-                        @Cached("create()") HashingStorageNodes.KeysIsSupersetNode isSupersetNode) {
-            PSet otherSet = constructSetNode.executeWith(frame, other);
-            return isSupersetNode.execute(frame, self.getDictStorage(), otherSet.getDictStorage());
-        }
     }
 
     @Builtin(name = __LE__, minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
-    abstract static class LessEqualNode extends IsSubsetNode {
+    abstract static class LessEqualNode extends PythonBinaryBuiltinNode {
         @Specialization
-        Object isLessEqual(VirtualFrame frame, PBaseSet self, Object other,
-                        @Cached("create(__GE__)") LookupAndCallBinaryNode lookupAndCallBinaryNode) {
-            Object result = lookupAndCallBinaryNode.executeObject(frame, other, self);
-            if (result != PNone.NO_VALUE) {
-                return result;
-            }
-            throw raise(PythonErrorType.TypeError, "unorderable types: %p <= %p", self, other);
+        boolean doLE(VirtualFrame frame, PBaseSet self, PBaseSet other,
+                        @Cached HashingStorageNodes.KeysIsSubsetNode isSubsetNode) {
+            return isSubsetNode.execute(frame, self.getDictStorage(), other.getDictStorage());
+        }
+
+        @Fallback
+        @SuppressWarnings("unused")
+        PNotImplemented doNotImplemented(Object self, Object other) {
+            return PNotImplemented.NOT_IMPLEMENTED;
         }
     }
 
     @Builtin(name = __GE__, minNumOfPositionalArgs = 2)
     @GenerateNodeFactory
-    abstract static class GreaterEqualNode extends IsSupersetNode {
+    abstract static class GreaterEqualNode extends PythonBinaryBuiltinNode {
         @Specialization
-        Object isGreaterEqual(VirtualFrame frame, PBaseSet self, Object other,
-                        @Cached("create(__LE__)") LookupAndCallBinaryNode lookupAndCallBinaryNode) {
-            Object result = lookupAndCallBinaryNode.executeObject(frame, other, self);
-            if (result != PNone.NO_VALUE) {
-                return result;
-            }
-            throw raise(PythonErrorType.TypeError, "unorderable types: %p >= %p", self, other);
+        boolean doGE(VirtualFrame frame, PBaseSet self, PBaseSet other,
+                        @Cached HashingStorageNodes.KeysIsSupersetNode isSupersetNode) {
+            return isSupersetNode.execute(frame, self.getDictStorage(), other.getDictStorage());
+        }
+
+        @Fallback
+        @SuppressWarnings("unused")
+        PNotImplemented doNotImplemented(Object self, Object other) {
+            return PNotImplemented.NOT_IMPLEMENTED;
         }
     }