Type checker: add mapping view types

Technologicat · Technologicat · commit 12a9392c268e · 2020-03-23T01:52:45.000+02:00
diff --git a/unpythonic/test/test_typecheck.py b/unpythonic/test/test_typecheck.py
@@ -154,6 +154,7 @@ def test():
     assert isoftype((1, 2, 3), typing.Hashable)
     assert isoftype([1, 2, 3], typing.Sized)
     assert not isoftype([1, 2, 3], typing.Hashable)
+    # TODO: test SupportsComplex, SupportsBytes
 
     # For these it's impossible, in general, to non-destructively check the
     # element type, so this run-time type checker ignores making that check.
@@ -164,6 +165,21 @@ def test():
     assert isoftype([1, 2, 3], typing.Container)
     assert isoftype([1, 2, 3], typing.Collection)  # Sized Iterable Container
 
+    # KeysView, ValuesView, MappingView, ItemsView
+    d = {17: "cat", 23: "fox", 42: "python"}
+    assert isoftype(d.keys(), typing.KeysView[int])
+    assert isoftype(d.values(), typing.ValuesView[str])
+    assert isoftype(d.items(), typing.ItemsView[int, str])
+
+    # TODO: test MappingView
+    # The language docs don't exactly make it clear what MappingView is for.
+    # All these documentation pages only talk about `.keys()`, `.values()`
+    # and `.items()`, which correspond to the other three view types.
+    #  https://docs.python.org/3/library/typing.html#typing.MappingView
+    #  https://docs.python.org/3/library/collections.abc.html#collections.abc.MappingView
+    #  https://docs.python.org/3/glossary.html#term-dictionary-view
+    #  https://docs.python.org/3/library/stdtypes.html#dict-views
+
     print("All tests PASSED")
 
 if __name__ == '__main__':
diff --git a/unpythonic/typecheck.py b/unpythonic/typecheck.py
@@ -49,6 +49,7 @@ def isoftype(value, T):
                  - `FrozenSet[T]`, `AbstractSet[T]`
                  - `Set[T]`, `MutableSet[T]`
                  - `Dict[K, V]`, `MutableMapping[K, V]`, `Mapping[K, V]`
+                 - `ItemsView[K, V]`, `KeysView[K]`, `ValuesView[V]`
                  - `Callable` (argument and return value types currently NOT checked)
                  - `Text`
 
@@ -101,20 +102,23 @@ def isoftype(value, T):
     # TODO: If you add a feature to the type checker, please update this list.
     #
     # Python 3.6+:
-    #   Generic, NamedTuple, DefaultDict, Counter, ChainMap, Type,
-    #   KeysView, ItemsView, ValuesView,
+    #   NamedTuple, DefaultDict, Counter, ChainMap,
+    #   IO, TextIO, BinaryIO,
+    #   Pattern, Match, (regular expressions)
+    #   Generic, Type,
     #   Awaitable, Coroutine, AsyncIterable, AsyncIterator,
     #   ContextManager, AsyncContextManager,
     #   Generator, AsyncGenerator,
-    #   IO, TextIO, BinaryIO,
-    #   Pattern, Match, (regular expressions)
     #   NoReturn (callable return value only),
     #   ClassVar, Final
     #
     # Python 3.7+: OrderedDict
     # Python 3.8+: Protocol, SupportsIndex, TypedDict, Literal
     #
     # TODO: Do we need to support `typing.ForwardRef`?
+    # No, if `get_type_hints` already resolves that. Consider our main use case,
+    # in `unpythonic.dispatch`. And see:
+    # https://docs.python.org/3/library/typing.html#typing.get_type_hints
 
     # TODO: Python 3.8 adds `typing.get_origin` and `typing.get_args`, which may be useful
     # TODO: to analyze generics once we bump our minimum Python to that.
@@ -183,6 +187,36 @@ def isoftype(value, T):
                 return False
             return all(isoftype(elt, U) for elt, U in zip(value, T.__args__))
 
+        # Check mapping types that allow non-destructive iteration.
+        def ismapping(statictype, runtimetype):
+            if not isinstance(value, runtimetype):
+                return False
+            if T.__args__ is None:
+                raise TypeError("Missing mandatory key, value type arguments of `{}`".format(statictype))
+            assert len(T.__args__) == 2
+            if not value:  # An empty dict has no key and value types.
+                return False
+            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.MutableMapping, collections.abc.MutableMapping),
+                                        (typing.Mapping, collections.abc.Mapping)):
+            if issubclass(T, statictype):
+                return ismapping(statictype, runtimetype)
+
+        # ItemsView is a special-case mapping in that we must not call
+        # `.items()` on `value`.
+        if issubclass(T, typing.ItemsView):
+            if not isinstance(value, collections.abc.ItemsView):
+                return False
+            if T.__args__ is None:
+                raise TypeError("Missing mandatory key, value type arguments of `{}`".format(statictype))
+            assert len(T.__args__) == 2
+            if not value:  # An empty dict has no key and value types.
+                return False
+            K, V = T.__args__
+            return all(isoftype(k, K) and isoftype(v, V) for k, v in value)
+
         # Check iterable types that allow non-destructive iteration.
         #
         # Special-case strings; they match typing.Sequence, but they're not
@@ -216,29 +250,16 @@ def iscollection(statictype, runtimetype):
                                             (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.KeysView, collections.abc.KeysView),
+                                            (typing.ValuesView, collections.abc.ValuesView),
+                                            (typing.MappingView, collections.abc.MappingView),  # MappingView has one type argument so it goes here?
                                             (typing.AbstractSet, collections.abc.Set),
                                             (typing.MutableSequence, collections.abc.MutableSequence),
+                                            (typing.MappingView, collections.abc.MappingView),
                                             (typing.Sequence, collections.abc.Sequence)):
                 if issubclass(T, statictype):
                     return iscollection(statictype, runtimetype)
 
-        # Check mapping types that allow non-destructive iteration.
-        def ismapping(statictype, runtimetype):
-            if not isinstance(value, runtimetype):
-                return False
-            if T.__args__ is None:
-                raise TypeError("Missing mandatory key, value type arguments of `{}`".format(statictype))
-            assert len(T.__args__) == 2
-            if not value:  # An empty dict has no key and value types.
-                return False
-            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.MutableMapping, collections.abc.MutableMapping),
-                                        (typing.Mapping, collections.abc.Mapping)):
-            if issubclass(T, statictype):
-                return ismapping(statictype, runtimetype)
-
         if issubclass(T, typing.Callable):
             if not callable(value):
                 return False
