Add some more typings for function arguments and return values

Replicates graphql/graphql-js@bbd8429

Author: Cito

src/graphql/execution/execute.py

@@ -626,8 +626,9 @@ async def await_result() -> Any:
                         if self.is_awaitable(completed):
                             return await completed
                         return completed
-                    except Exception as error:
-                        self.handle_field_error(error, field_nodes, path, return_type)
+                    except Exception as raw_error:
+                        error = located_error(raw_error, field_nodes, path.as_list())
+                        self.handle_field_error(error, return_type)
                         return None
 
                 return await_result()
@@ -640,26 +641,24 @@ async def await_result() -> Any:
                 async def await_completed() -> Any:
                     try:
                         return await completed
-                    except Exception as error:
-                        self.handle_field_error(error, field_nodes, path, return_type)
+                    except Exception as raw_error:
+                        error = located_error(raw_error, field_nodes, path.as_list())
+                        self.handle_field_error(error, return_type)
                         return None
 
                 return await_completed()
 
             return completed
-        except Exception as error:
-            self.handle_field_error(error, field_nodes, path, return_type)
+        except Exception as raw_error:
+            error = located_error(raw_error, field_nodes, path.as_list())
+            self.handle_field_error(error, return_type)
             return None
 
     def handle_field_error(
         self,
-        raw_error: Exception,
-        field_nodes: List[FieldNode],
-        path: Path,
+        error: GraphQLError,
         return_type: GraphQLOutputType,
     ) -> None:
-        error = located_error(raw_error, field_nodes, path.as_list())
-
         # If the field type is non-nullable, then it is resolved without any protection
         # from errors, however it still properly locates the error.
         if is_non_null_type(return_type):
@@ -796,10 +795,11 @@ async def await_completed(item: Any, item_path: Path) -> Any:
                         if is_awaitable(completed):
                             return await completed
                         return completed
-                    except Exception as error:
-                        self.handle_field_error(
-                            error, field_nodes, item_path, item_type
+                    except Exception as raw_error:
+                        error = located_error(
+                            raw_error, field_nodes, item_path.as_list()
                         )
+                        self.handle_field_error(error, item_type)
                         return None
 
                 completed_item = await_completed(item, item_path)
@@ -813,15 +813,17 @@ async def await_completed(item: Any, item_path: Path) -> Any:
                         async def await_completed(item: Any, item_path: Path) -> Any:
                             try:
                                 return await item
-                            except Exception as error:
-                                self.handle_field_error(
-                                    error, field_nodes, item_path, item_type
+                            except Exception as raw_error:
+                                error = located_error(
+                                    raw_error, field_nodes, item_path.as_list()
                                 )
+                                self.handle_field_error(error, item_type)
                                 return None
 
                         completed_item = await_completed(completed_item, item_path)
-                except Exception as error:
-                    self.handle_field_error(error, field_nodes, item_path, item_type)
+                except Exception as raw_error:
+                    error = located_error(raw_error, field_nodes, item_path.as_list())
+                    self.handle_field_error(error, item_type)
                     completed_item = None
 
             if is_awaitable(completed_item):

src/graphql/language/lexer.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 
 from ..error import GraphQLSyntaxError
 from .ast import Token
@@ -154,7 +154,9 @@ def read_token(self, prev: Token) -> Token:
         col = 1 + pos - self.line_start
         return Token(TokenKind.EOF, body_length, body_length, line, col, prev)
 
-    def read_comment(self, start: int, line: int, col: int, prev: Token) -> Token:
+    def read_comment(
+        self, start: int, line: int, col: int, prev: Optional[Token]
+    ) -> Token:
         """Read a comment token from the source file."""
         body = self.source.body
         body_length = len(body)
@@ -178,7 +180,7 @@ def read_comment(self, start: int, line: int, col: int, prev: Token) -> Token:
         )
 
     def read_number(
-        self, start: int, char: str, line: int, col: int, prev: Token
+        self, start: int, char: str, line: int, col: int, prev: Optional[Token]
     ) -> Token:
         """Reads a number token from the source file.
 
@@ -253,7 +255,9 @@ def read_digits(self, start: int, char: str) -> int:
             )
         return position
 
-    def read_string(self, start: int, line: int, col: int, prev: Token) -> Token:
+    def read_string(
+        self, start: int, line: int, col: int, prev: Optional[Token]
+    ) -> Token:
         """Read a string token from the source file."""
         source = self.source
         body = source.body
@@ -316,7 +320,9 @@ def read_string(self, start: int, line: int, col: int, prev: Token) -> Token:
 
         raise GraphQLSyntaxError(source, position, "Unterminated string.")
 
-    def read_block_string(self, start: int, line: int, col: int, prev: Token) -> Token:
+    def read_block_string(
+        self, start: int, line: int, col: int, prev: Optional[Token]
+    ) -> Token:
         source = self.source
         body = source.body
         body_length = len(body)
@@ -364,7 +370,9 @@ def read_block_string(self, start: int, line: int, col: int, prev: Token) -> Tok
 
         raise GraphQLSyntaxError(source, position, "Unterminated string.")
 
-    def read_name(self, start: int, line: int, col: int, prev: Token) -> Token:
+    def read_name(
+        self, start: int, line: int, col: int, prev: Optional[Token]
+    ) -> Token:
         """Read an alphanumeric + underscore name from the source."""
         body = self.source.body
         body_length = len(body)

src/graphql/language/printer.py

@@ -393,7 +393,7 @@ def join(strings: Optional[Strings], separator: str = "") -> str:
     return separator.join(s for s in strings if s) if strings else ""
 
 
-def block(strings: Strings) -> str:
+def block(strings: Optional[Strings]) -> str:
     """Return strings inside a block.
 
     Given a collection of strings, return a string with each item on its own line,
@@ -402,7 +402,7 @@ def block(strings: Strings) -> str:
     return "{\n" + indent(join(strings, "\n")) + "\n}" if strings else ""
 
 
-def wrap(start: str, string: str, end: str = "") -> str:
+def wrap(start: str, string: Optional[str], end: str = "") -> str:
     """Wrap string inside other strings at start and end.
 
     If the string is not None or empty, then wrap with start and end, otherwise return
@@ -425,6 +425,6 @@ def is_multiline(string: str) -> bool:
     return "\n" in string
 
 
-def has_multiline_items(maybe_list: Optional[Strings]) -> bool:
+def has_multiline_items(strings: Optional[Strings]) -> bool:
     """Check whether one of the items in the list has multiple lines."""
-    return any(is_multiline(item) for item in maybe_list) if maybe_list else False
+    return any(is_multiline(item) for item in strings) if strings else False

src/graphql/type/validate.py

@@ -108,7 +108,6 @@ def add_error(self, error: GraphQLError) -> None:
 
     def validate_root_types(self) -> None:
         schema = self.schema
-
         query_type = schema.query_type
         if not query_type:
             self.report_error("Query root type must be provided.", schema.ast_node)

tests/execution/test_lists.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from pytest import mark  # type: ignore
 
 from graphql.execution import execute, execute_sync, ExecutionResult
@@ -66,11 +68,11 @@ def does_not_accept_iterable_string_literal_as_a_list_value():
 
 
 def describe_execute_handles_list_nullability():
-    async def _complete(list_field, as_type):
+    async def _complete(list_field: Any, as_type: str) -> ExecutionResult:
         schema = build_schema(f"type Query {{ listField: {as_type} }}")
         document = parse("{ listField }")
 
-        def execute_query(list_value):
+        def execute_query(list_value: Any) -> Any:
             return execute(schema, document, Data(list_value))
 
         result = execute_query(list_field)

tests/execution/test_variables.py

@@ -980,7 +980,7 @@ def describe_get_variable_values_limit_maximum_number_of_coercion_errors():
 
         input_value = {"input": [0, 1, 2]}
 
-        def _invalid_value_error(value, index):
+        def _invalid_value_error(value: int, index: int) -> Dict[str, Any]:
             return {
                 "message": "Variable '$input' got invalid value"
                 f" {value} at 'input[{index}]';"

tests/language/test_block_string.py

@@ -5,7 +5,7 @@
 )
 
 
-def join_lines(*args):
+def join_lines(*args: str) -> str:
     return "\n".join(args)
 
 

tests/language/test_lexer.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
 from pytest import raises  # type: ignore
 
@@ -9,6 +9,8 @@
 
 from ..utils import dedent
 
+Location = Optional[Tuple[int, int]]
+
 
 def lex_one(s: str) -> Token:
     lexer = Lexer(Source(s))
@@ -21,7 +23,7 @@ def lex_second(s: str) -> Token:
     return lexer.advance()
 
 
-def assert_syntax_error(text, message, location):
+def assert_syntax_error(text: str, message: str, location: Location) -> None:
     with raises(GraphQLSyntaxError) as exc_info:
         lex_second(text)
     error = exc_info.value

tests/language/test_parser.py

@@ -1,4 +1,4 @@
-from typing import cast
+from typing import cast, Optional, Tuple
 
 from pytest import raises  # type: ignore
 
@@ -32,8 +32,10 @@
 from ..fixtures import kitchen_sink_query  # noqa: F401
 from ..utils import dedent
 
+Location = Optional[Tuple[int, int]]
 
-def assert_syntax_error(text, message, location):
+
+def assert_syntax_error(text: str, message: str, location: Location) -> None:
     with raises(GraphQLSyntaxError) as exc_info:
         parse(text)
     error = exc_info.value

tests/language/test_schema_parser.py

@@ -1,9 +1,11 @@
 from textwrap import dedent
+from typing import List, Optional, Tuple
 
 from pytest import raises  # type: ignore
 
 from graphql.error import GraphQLSyntaxError
 from graphql.language import (
+    ArgumentNode,
     BooleanValueNode,
     DirectiveDefinitionNode,
     DirectiveNode,
@@ -27,14 +29,18 @@
     SchemaDefinitionNode,
     SchemaExtensionNode,
     StringValueNode,
+    TypeNode,
     UnionTypeDefinitionNode,
+    ValueNode,
     parse,
 )
 
 from ..fixtures import kitchen_sink_sdl  # noqa: F401
 
+Location = Optional[Tuple[int, int]]
 
-def assert_syntax_error(text, message, location):
+
+def assert_syntax_error(text: str, message: str, location: Location) -> None:
     with raises(GraphQLSyntaxError) as exc_info:
         parse(text)
     error = exc_info.value
@@ -43,7 +49,7 @@ def assert_syntax_error(text, message, location):
     assert error.locations == [location]
 
 
-def assert_definitions(body, loc, num=1):
+def assert_definitions(body: str, loc: Location, num=1):
     doc = parse(body)
     assert isinstance(doc, DocumentNode)
     assert doc.loc == loc
@@ -53,35 +59,37 @@ def assert_definitions(body, loc, num=1):
     return definitions[0] if num == 1 else definitions
 
 
-def type_node(name, loc):
+def type_node(name: str, loc: Location):
     return NamedTypeNode(name=name_node(name, loc), loc=loc)
 
 
-def name_node(name, loc):
+def name_node(name: str, loc: Location):
     return NameNode(value=name, loc=loc)
 
 
-def field_node(name, type_, loc):
+def field_node(name: NameNode, type_: TypeNode, loc: Location):
     return field_node_with_args(name, type_, [], loc)
 
 
-def field_node_with_args(name, type_, args, loc):
+def field_node_with_args(name: NameNode, type_: TypeNode, args: List, loc: Location):
     return FieldDefinitionNode(
         name=name, arguments=args, type=type_, directives=[], loc=loc, description=None
     )
 
 
-def non_null_type(type_, loc):
+def non_null_type(type_: TypeNode, loc: Location):
     return NonNullTypeNode(type=type_, loc=loc)
 
 
-def enum_value_node(name, loc):
+def enum_value_node(name: str, loc: Location):
     return EnumValueDefinitionNode(
         name=name_node(name, loc), directives=[], loc=loc, description=None
     )
 
 
-def input_value_node(name, type_, default_value, loc):
+def input_value_node(
+    name: NameNode, type_: TypeNode, default_value: Optional[ValueNode], loc: Location
+):
     return InputValueDefinitionNode(
         name=name,
         type=type_,
@@ -92,29 +100,33 @@ def input_value_node(name, type_, default_value, loc):
     )
 
 
-def boolean_value_node(value, loc):
+def boolean_value_node(value: bool, loc: Location):
     return BooleanValueNode(value=value, loc=loc)
 
 
-def string_value_node(value, block, loc):
+def string_value_node(value: str, block: Optional[bool], loc: Location):
     return StringValueNode(value=value, block=block, loc=loc)
 
 
-def list_type_node(type_, loc):
+def list_type_node(type_: TypeNode, loc: Location):
     return ListTypeNode(type=type_, loc=loc)
 
 
-def schema_extension_node(directives, operation_types, loc):
+def schema_extension_node(
+    directives: List[DirectiveNode],
+    operation_types: List[OperationTypeDefinitionNode],
+    loc: Location,
+):
     return SchemaExtensionNode(
         directives=directives, operation_types=operation_types, loc=loc
     )
 
 
-def operation_type_definition(operation, type_, loc):
+def operation_type_definition(operation: OperationType, type_: TypeNode, loc: Location):
     return OperationTypeDefinitionNode(operation=operation, type=type_, loc=loc)
 
 
-def directive_node(name, arguments, loc):
+def directive_node(name: NameNode, arguments: List[ArgumentNode], loc: Location):
     return DirectiveNode(name=name, arguments=arguments, loc=loc)