Convert Location to be a normal class

Also use a constructor that is compatible with the original.

Replicates graphql/graphql-js@ec5fbb0

Author: Cito

src/graphql/language/ast.py

@@ -1,6 +1,6 @@
 from copy import copy, deepcopy
 from enum import Enum
-from typing import List, NamedTuple, Optional, Union
+from typing import List, Optional, Union
 
 from .source import Source
 from .token_kind import TokenKind
@@ -138,19 +138,28 @@ def desc(self) -> str:
         return f"{kind} {value!r}" if value else kind
 
 
-class Location(NamedTuple):
+class Location:
     """AST Location
 
     Contains a range of UTF-8 character offsets and token references that identify the
     region of the source from which the AST derived.
     """
 
+    __slots__ = ("start", "end", "start_token", "end_token", "source")
+
     start: int  # character offset at which this Node begins
     end: int  # character offset at which this Node ends
     start_token: Token  # Token at which this Node begins
     end_token: Token  # Token at which this Node ends.
     source: Source  # Source document the AST represents
 
+    def __init__(self, start_token: Token, end_token: Token, source: Source):
+        self.start = start_token.start
+        self.end = end_token.end
+        self.start_token = start_token
+        self.end_token = end_token
+        self.source = source
+
     def __str__(self):
         return f"{self.start}:{self.end}"
 

src/graphql/language/parser.py

@@ -959,9 +959,7 @@ def loc(self, start_token: Token) -> Optional[Location]:
         if not self._no_location:
             end_token = self._lexer.last_token
             source = self._lexer.source
-            return Location(
-                start_token.start, end_token.end, start_token, end_token, source
-            )
+            return Location(start_token, end_token, source)
         return None
 
     def peek(self, kind: TokenKind) -> bool:

tests/language/test_ast.py

@@ -80,48 +80,53 @@ def describe_location_class():
     source = Source("source")
 
     def initializes():
-        loc = Location(1, 2, token1, token2, source)
-        assert loc.start == 1
-        assert loc.end == 2
+        loc = Location(token1, token2, source)
+        assert loc.start == token1.start
+        assert loc.end == token2.end
         assert loc.start_token is token1
         assert loc.end_token is token2
         assert loc.source is source
 
     def can_stringify_with_start_and_end():
-        loc = Location(1, 2, token1, token2, source)
-        assert str(loc) == "1:2"
+        loc = Location(token1, token2, source)
+        assert str(loc) == "1:3"
 
     def has_representation_with_start_and_end():
-        loc = Location(1, 2, token1, token2, source)
-        assert repr(loc) == "<Location 1:2>"
+        loc = Location(token1, token2, source)
+        assert repr(loc) == "<Location 1:3>"
         assert inspect(loc) == repr(loc)
 
     def can_check_equality():
-        loc1 = Location(1, 2, token1, token2, source)
-        loc2 = Location(1, 2, token1, token2, source)
+        loc1 = Location(token1, token2, source)
+        loc2 = Location(token1, token2, source)
         assert loc2 == loc1
-        loc3 = Location(3, 2, token1, token2, source)
+        loc3 = Location(token1, token1, source)
         assert loc3 != loc1
-        loc4 = Location(1, 4, token1, token2, source)
+        loc4 = Location(token2, token2, source)
         assert loc4 != loc1
+        assert loc4 != loc3
 
     def can_check_equality_with_tuple_or_list():
-        loc = Location(1, 2, token1, token2, source)
-        assert loc == (1, 2)
-        assert loc == [1, 2]
-        assert not loc != (1, 2)
-        assert not loc != [1, 2]
-        assert loc != (3, 2)
-        assert loc != [1, 4]
+        loc = Location(token1, token2, source)
+        assert loc == (1, 3)
+        assert loc == [1, 3]
+        assert not loc != (1, 3)
+        assert not loc != [1, 3]
+        assert loc != (1, 2)
+        assert loc != [2, 3]
 
     def can_hash():
-        loc1 = Location(1, 2, token1, token2, source)
-        loc2 = Location(1, 2, token1, token2, source)
+        loc1 = Location(token1, token2, source)
+        loc2 = Location(token1, token2, source)
         assert loc2 == loc1
         assert hash(loc2) == hash(loc1)
-        loc3 = Location(1, 3, token1, token2, source)
+        loc3 = Location(token1, token1, source)
         assert loc3 != loc1
         assert hash(loc3) != hash(loc1)
+        loc4 = Location(token2, token2, source)
+        assert loc4 != loc1
+        assert hash(loc4) != hash(loc1)
+        assert hash(loc4) != hash(loc3)
 
 
 def describe_node_class():