Type checker, more tests, some fixes

Technologicat · Technologicat · commit 3c7af2dac550 · 2020-03-23T01:34:53.000+02:00
diff --git a/unpythonic/test/test_typecheck.py b/unpythonic/test/test_typecheck.py
@@ -2,6 +2,8 @@
 
 import collections
 import typing
+
+from ..collections import frozendict
 from ..typecheck import isoftype
 
 def test():
@@ -110,6 +112,58 @@ def test():
     assert isoftype(d, typing.Deque[int])
     assert not isoftype(d, typing.Deque[float])
 
+    # typing.Mapping, typing.MutableMapping
+    assert isoftype(frozendict({1: "foo", 2: "bar"}), typing.Mapping[int, str])
+    assert not isoftype(frozendict({1: "foo", 2: "bar"}), typing.MutableMapping[int, str])
+    assert not isoftype(frozendict({1: "foo", 2: "bar"}), typing.Mapping[str, str])
+    assert isoftype({1: "foo", 2: "bar"}, typing.MutableMapping[int, str])
+    assert not isoftype(42, typing.Mapping[int, str])
+    # empty mapping has no key/value types
+    assert not isoftype({}, typing.MutableMapping[int, str])
+    assert not isoftype({}, typing.Mapping[int, str])
+    assert not isoftype(frozendict(), typing.Mapping[int, str])
+
+    # typing.Sequence, typing.MutableSequence
+    assert not isoftype((), typing.Sequence[int])  # empty sequence has no element type
+    assert isoftype((1, 2, 3), typing.Sequence[int])
+    assert not isoftype((1, 2, 3), typing.Sequence[float])
+    assert not isoftype((1, 2, 3), typing.MutableSequence[int])
+    assert isoftype([1, 2, 3], typing.Sequence[int])
+    assert isoftype([1, 2, 3], typing.MutableSequence[int])
+    assert not isoftype([], typing.MutableSequence[int])  # empty mutable sequence has no element type
+    assert not isoftype([1, 2, 3], typing.MutableSequence[float])
+    assert not isoftype(42, typing.Sequence[int])
+    assert not isoftype(42, typing.MutableSequence[int])
+
+    # typing.AbstractSet, typing.MutableSet
+    assert isoftype({1, 2, 3}, typing.AbstractSet[int])
+    assert isoftype({1, 2, 3}, typing.MutableSet[int])
+    assert not isoftype({1, 2, 3}, typing.AbstractSet[float])
+    assert isoftype(frozenset({1, 2, 3}), typing.AbstractSet[int])
+    assert not isoftype(frozenset({1, 2, 3}), typing.MutableSet[int])
+    assert not isoftype(42, typing.AbstractSet[int])
+    assert not isoftype(42, typing.MutableSet[int])
+
+    # one-trick ponies
+    assert isoftype(3.14, typing.SupportsInt)
+    # assert isoftype(3.14, typing.SupportsComplex)  # ehm, WTF?
+    assert isoftype(3.14, typing.SupportsAbs)
+    assert isoftype(3.14, typing.SupportsRound)
+    assert isoftype(42, typing.SupportsFloat)
+    assert isoftype((1, 2, 3), typing.Sized)
+    assert isoftype((1, 2, 3), typing.Hashable)
+    assert isoftype([1, 2, 3], typing.Sized)
+    assert not isoftype([1, 2, 3], typing.Hashable)
+
+    # For these it's impossible, in general, to non-destructively check the
+    # element type, so this run-time type checker ignores making that check.
+    # It only checks that the value is an instance of the appropriate ABC.
+    assert isoftype(iter([1, 2, 3]), typing.Iterator)
+    assert isoftype([1, 2, 3], typing.Iterable)
+    assert isoftype([1, 2, 3], typing.Reversible)
+    assert isoftype([1, 2, 3], typing.Container)
+    assert isoftype([1, 2, 3], typing.Collection)  # Sized Iterable Container
+
     print("All tests PASSED")
 
 if __name__ == '__main__':
diff --git a/unpythonic/typecheck.py b/unpythonic/typecheck.py
@@ -143,17 +143,20 @@ def isoftype(value, T):
               typing.Reversible,  # can't non-destructively check element type
               typing.Container,   # can't check element type
               typing.Collection,  # Sized Iterable Container; can't check element type
-              typing.SupportsInt,
+              typing.Hashable,
+              typing.Sized):
+        if U is T:
+            return isinstance(value, U)
+    # "Protocols cannot be used with isinstance()", so:
+    for U in (typing.SupportsInt,
               typing.SupportsFloat,
               typing.SupportsComplex,
               typing.SupportsBytes,
               # typing.SupportsIndex,  # TODO: enable this once our minimum is Python 3.8
               typing.SupportsAbs,
-              typing.SupportsRound,
-              typing.Hashable,
-              typing.Sized):
+              typing.SupportsRound):
         if U is T:
-            return isinstance(value, U)
+            return issubclass(type(value), U)
 
     # We don't have a match yet, so T might still be one of those meta-utilities
     # that hate `issubclass` with a passion.
@@ -206,14 +209,16 @@ def iscollection(statictype, runtimetype):
                 U = typeargs[0]
                 return all(isoftype(elt, U) for elt in value)
             for statictype, runtimetype in ((typing.List, list),
-                                            (typing.Set, set),
                                             (typing.FrozenSet, frozenset),
+                                            (typing.Set, set),
                                             (typing.Deque, collections.deque),
                                             (typing.ByteString, collections.abc.ByteString),  # must check before Sequence
+                                            (typing.MutableSet, collections.abc.MutableSet),  # must check mutable first
+                                            # because a mutable value has *also* the interface of the immutable variant
+                                            # (e.g. MutableSet is a subtype of AbstractSet)
                                             (typing.AbstractSet, collections.abc.Set),
-                                            (typing.MutableSet, collections.abc.MutableSet),
-                                            (typing.Sequence, collections.abc.Sequence),
-                                            (typing.MutableSequence, collections.abc.MutableSequence)):
+                                            (typing.MutableSequence, collections.abc.MutableSequence),
+                                            (typing.Sequence, collections.abc.Sequence)):
                 if issubclass(T, statictype):
                     return iscollection(statictype, runtimetype)
 
@@ -229,8 +234,8 @@ def ismapping(statictype, runtimetype):
             K, V = T.__args__
             return all(isoftype(k, K) and isoftype(v, V) for k, v in value.items())
         for statictype, runtimetype in ((typing.Dict, dict),
-                                        (typing.Mapping, collections.abc.Mapping),
-                                        (typing.MutableMapping, collections.abc.MutableMapping)):
+                                        (typing.MutableMapping, collections.abc.MutableMapping),
+                                        (typing.Mapping, collections.abc.Mapping)):
             if issubclass(T, statictype):
                 return ismapping(statictype, runtimetype)
 
