Use Locations when adding spans

Prior to this change, we were passing around integers when creating
span information.

This change uses locations instead. This has no functional change, but
will make it easier to start passing through source position
information in the following commit.

Author: leamingrad

fluent.syntax/fluent/syntax/ast.py

@@ -3,6 +3,8 @@
 import sys
 from typing import Any, Callable, Dict, List, TypeVar, Union, cast
 
+from .stream import Location
+
 Node = TypeVar("Node", bound="BaseNode")
 ToJsonFn = Callable[[Dict[str, Any]], Any]
 
@@ -121,7 +123,7 @@ def __init__(self, span: Union["Span", None] = None, **kwargs: Any):
         super().__init__(**kwargs)
         self.span = span
 
-    def add_span(self, start: int, end: int) -> None:
+    def add_span(self, start: Location, end: Location) -> None:
         self.span = Span(start, end)
 
 
@@ -378,11 +380,19 @@ def add_annotation(self, annot: "Annotation") -> None:
 
 
 class Span(BaseNode):
-    def __init__(self, start: int, end: int, **kwargs: Any):
+    def __init__(self, start: Location, end: Location, **kwargs: Any):
         super().__init__(**kwargs)
         self.start = start
         self.end = end
 
+    @property
+    def start_location(self) -> Location:
+        return self.start
+
+    @property
+    def end_location(self) -> Location:
+        return self.end
+
 
 class Annotation(SyntaxNode):
     def __init__(

fluent.syntax/fluent/syntax/parser.py

@@ -3,7 +3,7 @@
 
 from . import ast
 from .errors import ParseError
-from .stream import EOL, FluentParserStream
+from .stream import EOL, FluentParserStream, Location
 
 R = TypeVar("R", bound=ast.SyntaxNode)
 
@@ -15,15 +15,15 @@ def decorated(
         if not self.with_spans:
             return fn(self, ps, *args, **kwargs)
 
-        start = ps.index
+        start = ps.current_location
         node = fn(self, ps, *args, **kwargs)
 
         # Don't re-add the span if the node already has it. This may happen
         # when one decorated function calls another decorated function.
         if node.span is not None:
             return node
 
-        end = ps.index
+        end = ps.current_location
         node.add_span(start, end)
         return node
 
@@ -85,7 +85,7 @@ def parse(self, source: str) -> ast.Resource:
         res = ast.Resource(entries)
 
         if self.with_spans:
-            res.add_span(0, ps.index)
+            res.add_span(0, ps.current_location)
 
         return res
 
@@ -112,29 +112,31 @@ def parse_entry(self, source: str) -> ast.EntryType:
 
     def get_entry_or_junk(self, ps: FluentParserStream) -> ast.EntryType:
         entry_start_index = ps.index
+        entry_start_location = ps.current_location
 
         try:
             entry = self.get_entry(ps)
             ps.expect_line_end()
             return entry
         except ParseError as err:
             error_index = ps.index
+            error_location = ps.current_location
 
             ps.skip_to_next_entry_start(entry_start_index)
             next_entry_start_index = ps.index
             if next_entry_start_index < error_index:
                 # The position of the error must be inside of the Junk's span.
-                error_index = next_entry_start_index
+                error_location = ps.current_location
 
             # Create a Junk instance
             slice = ps.string[entry_start_index:next_entry_start_index]
             junk = ast.Junk(slice)
             if self.with_spans:
-                junk.add_span(entry_start_index, next_entry_start_index)
+                junk.add_span(entry_start_location, ps.current_location)
             annot = ast.Annotation(
                 err.code, list(err.args) if err.args else None, err.message
             )
-            annot.add_span(error_index, error_index)
+            annot.add_span(error_location, error_location)
             junk.add_annotation(annot)
             return junk
 
@@ -380,24 +382,24 @@ def get_pattern(self, ps: FluentParserStream, is_block: bool) -> ast.Pattern:
         if is_block:
             # A block pattern is a pattern which starts on a new line. Measure
             # the indent of this first line for the dedentation logic.
-            blank_start = ps.index
+            blank_start = ps.current_location
             first_indent = ps.skip_blank_inline()
-            elements.append(self.Indent(first_indent, blank_start, ps.index))
+            elements.append(self.Indent(first_indent, blank_start, ps.current_location))
             common_indent_length = len(first_indent)
         else:
             # Should get fixed by the subsequent min() operation
             common_indent_length = cast(int, float("infinity"))
 
         while ps.current_char:
             if ps.current_char == EOL:
-                blank_start = ps.index
+                blank_start = ps.current_location
                 blank_lines = ps.peek_blank_block()
                 if ps.is_value_continuation():
                     ps.skip_to_peek()
                     indent = ps.skip_blank_inline()
                     common_indent_length = min(common_indent_length, len(indent))
                     elements.append(
-                        self.Indent(blank_lines + indent, blank_start, ps.index)
+                        self.Indent(blank_lines + indent, blank_start, ps.current_location)
                     )
                     continue
 
@@ -421,7 +423,7 @@ def get_pattern(self, ps: FluentParserStream, is_block: bool) -> ast.Pattern:
         return ast.Pattern(dedented)
 
     class Indent(ast.SyntaxNode):
-        def __init__(self, value: str, start: int, end: int):
+        def __init__(self, value: str, start: Location, end: Location):
             super(FluentParser.Indent, self).__init__()
             self.value = value
             self.add_span(start, end)
@@ -454,8 +456,8 @@ def dedent(
                 sum = ast.TextElement(prev.value + element.value)
                 if self.with_spans:
                     sum.add_span(
-                        cast(ast.Span, prev.span).start,
-                        cast(ast.Span, element.span).end,
+                        cast(ast.Span, prev.span).start_location,
+                        cast(ast.Span, element.span).end_location,
                     )
                 trimmed[-1] = sum
                 continue
@@ -466,8 +468,8 @@ def dedent(
                 text_element = ast.TextElement(element.value)
                 if self.with_spans:
                     text_element.add_span(
-                        cast(ast.Span, element.span).start,
-                        cast(ast.Span, element.span).end,
+                        cast(ast.Span, element.span).start_location,
+                        cast(ast.Span, element.span).end_location,
                     )
                 element = text_element