Extend type checks to functions without type annotations

Author: Cito

mypy.ini

@@ -1,6 +1,7 @@
 [mypy]
 python_version = 3.7
-warn_redundant_casts = true
+check_untyped_defs = True
+warn_redundant_casts = True
 warn_unused_ignores = True
 # https://github.com/python/mypy/issues/7203
 new_semantic_analyzer = False

src/graphql/execution/execute.py

@@ -306,7 +306,7 @@ def build_response(
         if isawaitable(data):
 
             async def build_response_async():
-                return self.build_response(await data)
+                return self.build_response(await data)  # type: ignore
 
             return build_response_async()
         data = cast(Optional[Dict[str, Any]], data)
@@ -353,7 +353,7 @@ def execute_operation(
                 # noinspection PyShadowingNames
                 async def await_result():
                     try:
-                        return await result
+                        return await result  # type: ignore
                     except GraphQLError as error:
                         self.errors.append(error)
                     except Exception as error:
@@ -872,15 +872,19 @@ def complete_abstract_value(
             async def await_complete_object_value():
                 value = self.complete_object_value(
                     self.ensure_valid_runtime_type(
-                        await runtime_type, return_type, field_nodes, info, result
+                        await runtime_type,  # type: ignore
+                        return_type,
+                        field_nodes,
+                        info,
+                        result,
                     ),
                     field_nodes,
                     info,
                     path,
                     result,
                 )
                 if isawaitable(value):
-                    return await value
+                    return await value  # type: ignore
                 return value
 
             return await_complete_object_value()
@@ -950,7 +954,7 @@ def complete_object_value(
             if isawaitable(is_type_of):
 
                 async def collect_and_execute_subfields_async():
-                    if not await is_type_of:
+                    if not await is_type_of:  # type: ignore
                         raise invalid_return_type_error(
                             return_type, result, field_nodes
                         )

src/graphql/language/ast.py

@@ -1,6 +1,6 @@
 from copy import copy, deepcopy
 from enum import Enum
-from typing import NamedTuple, Optional, Union
+from typing import List, NamedTuple, Optional, Union
 
 from .source import Source
 from .token_kind import TokenKind
@@ -230,13 +230,13 @@ def __deepcopy__(self, memo):
             **{key: deepcopy(getattr(self, key), memo) for key in self.keys}
         )
 
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
+    def __init_subclass__(cls):
+        super().__init_subclass__()
         name = cls.__name__
         if name.endswith("Node"):
             name = name[:-4]
         cls.kind = camel_to_snake(name)
-        keys = []
+        keys: List[str] = []
         for base in cls.__bases__:
             # noinspection PyUnresolvedReferences
             keys.extend(base.keys)

src/graphql/language/visitor.py

@@ -151,9 +151,9 @@ def enter(self, node, key, parent, path, ancestors):
     # Provide special return values as attributes
     BREAK, SKIP, REMOVE, IDLE = BREAK, SKIP, REMOVE, IDLE
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls):
         """Verify that all defined handlers are valid."""
-        super().__init_subclass__(**kwargs)
+        super().__init_subclass__()
         for attr, val in cls.__dict__.items():
             if attr.startswith("_"):
                 continue

src/graphql/pyutils/frozen_dict.py

@@ -18,9 +18,6 @@ def __delitem__(self, key):
     def __setitem__(self, key, value):
         raise FrozenError
 
-    def __add__(self, value):
-        return dict.__add__(self, value)
-
     def __iadd__(self, value):
         raise FrozenError
 

src/graphql/type/directives.py

@@ -108,7 +108,7 @@ def __repr__(self):
     def __eq__(self, other):
         return self is other or (
             isinstance(other, GraphQLDirective)
-            and self.type == other.type
+            and self.name == other.name
             and self.locations == other.locations
             and self.args == other.args
             and self.is_repeatable == other.is_repeatable

src/graphql/type/validate.py

@@ -152,7 +152,7 @@ def validate_directives(self):
             self.validate_name(directive)
 
             # Ensure the arguments are valid.
-            arg_names = set()
+            arg_names: Set[str] = set()
             for arg_name, arg in directive.args.items():
                 # Ensure they are named correctly.
                 self.validate_name(arg_name, arg)

tests/error/test_format_error.py

@@ -1,3 +1,5 @@
+from typing import List, Union
+
 from pytest import raises  # type: ignore
 
 from graphql.error import GraphQLError, format_error
@@ -8,7 +10,7 @@ def describe_format_error():
     def throw_if_not_an_error():
         with raises(TypeError):
             # noinspection PyTypeChecker
-            format_error(None)
+            format_error(None)  # type: ignore
 
     def format_graphql_error():
         source = Source(
@@ -17,7 +19,7 @@ def format_graphql_error():
               something
             }"""
         )
-        path = ["one", 2]
+        path: List[Union[int, str]] = ["one", 2]
         extensions = {"ext": None}
         error = GraphQLError(
             "test message",
@@ -37,5 +39,5 @@ def format_graphql_error():
 
     def add_default_message():
         # noinspection PyTypeChecker
-        error = format_error(GraphQLError(None))
+        error = format_error(GraphQLError(None))  # type: ignore
         assert error["message"] == "An unknown error occurred."

tests/error/test_graphql_error.py

@@ -1,4 +1,4 @@
-from typing import cast
+from typing import cast, List, Union
 
 from graphql.error import GraphQLError, format_error, print_error
 from graphql.language import (
@@ -109,13 +109,13 @@ def serializes_to_include_message_and_locations():
         )
 
     def serializes_to_include_path():
-        path = ["path", 3, "to", "field"]
+        path: List[Union[int, str]] = ["path", 3, "to", "field"]
         e = GraphQLError("msg", path=path)
         assert e.path is path
         assert repr(e) == "GraphQLError('msg', path=['path', 3, 'to', 'field'])"
 
     def default_error_formatter_includes_path():
-        path = ["path", 3, "to", "field"]
+        path: List[Union[int, str]] = ["path", 3, "to", "field"]
         e = GraphQLError("msg", path=path)
         formatted = format_error(e)
         assert formatted == e.formatted

tests/error/test_located_error.py

@@ -1,15 +1,17 @@
+from typing import cast, Any
+
 from graphql.error import GraphQLError, located_error
 
 
 def describe_located_error():
     def passes_graphql_error_through():
         path = ["path", 3, "to", "field"]
         # noinspection PyArgumentEqualDefault
-        e = GraphQLError("msg", None, None, None, path)
+        e = GraphQLError("msg", None, None, None, path)  # type: ignore
         assert located_error(e, [], []) == e
 
     def passes_graphql_error_ish_through():
-        e = Exception("I am an ordinary exception")
+        e = cast(GraphQLError, Exception("I am an ordinary exception"))
         e.locations = []
         e.path = []
         e.nodes = []
@@ -18,6 +20,6 @@ def passes_graphql_error_ish_through():
         assert located_error(e, [], []) == e
 
     def does_not_pass_through_elasticsearch_like_errors():
-        e = Exception("I am from elasticsearch")
+        e = cast(Any, Exception("I am from elasticsearch"))
         e.path = "/something/feed/_search"
         assert located_error(e, [], []) != e