Fix Position's printed representation, include the source in ANTLR parse errors

Author: alessiostalla

pylasu/model/position.py

@@ -99,7 +99,8 @@ def __contains__(self, pos):
 
     def __repr__(self):
         return f"Position(start={self.start}, end={self.end}"\
-               + (f", source={self.source}" if self.source is not None else "")
+               + (f", source={self.source}" if self.source is not None else "")\
+               + ")"
 
     def __str__(self):
         str_rep = (f"{self.source}:" if self.source is not None else "") + str(self.start)

pylasu/parsing/antlr.py

@@ -36,7 +36,7 @@ def parse(self, input_stream: Union[InputStream, str], consider_range: bool = Tr
         start = time.time_ns()
         if type(input_stream) is str:
             input_stream = InputStream(input_stream)
-        first_stage = self.parse_first_stage(input_stream, measure_lexing_time)
+        first_stage = self.parse_first_stage(input_stream, measure_lexing_time, source)
         issues = first_stage.issues
         ast = self.parse_tree_to_ast(first_stage.root, consider_range, issues, source)
         self.assign_parents(ast)
@@ -63,7 +63,7 @@ def parse_first_stage(
         issues = []
         lexing_time: Optional[int] = None
         total_time: int = time.time_ns()
-        parser = self.create_parser(input_stream, issues)
+        parser = self.create_parser(input_stream, issues, source)
         if measure_lexing_time:
             token_stream = parser.getInputStream()
             if isinstance(token_stream, CommonTokenStream):
@@ -77,16 +77,16 @@ def parse_first_stage(
         total_time = (time.time_ns() - total_time) // 1_000_000
         return FirstStageParsingResult(issues, root, None, total_time, lexing_time, source)
 
-    def create_parser(self, input_stream: InputStream, issues: List[Issue]) -> Parser:
+    def create_parser(self, input_stream: InputStream, issues: List[Issue], source: Optional[Source]) -> Parser:
         """Creates the first-stage parser."""
         lexer = self.create_antlr_lexer(input_stream)
-        self.attach_listeners(lexer, issues)
+        self.attach_listeners(lexer, issues, source)
         token_stream = self.create_token_stream(lexer)
         parser = self.create_antlr_parser(token_stream)
         # Assign interpreter to avoid caching DFA states indefinitely across executions
         parser._interp = \
             ParserATNSimulator(parser, parser.atn, parser._interp.decisionToDFA, self.prediction_context_cache)
-        self.attach_listeners(parser, issues)
+        self.attach_listeners(parser, issues, source)
         return parser
 
     def invoke_root_rule(self, parser: Parser):
@@ -135,19 +135,20 @@ def create_antlr_parser(self, token_stream: TokenStream) -> Parser:
     def parse_tree_to_ast(self, root, consider_range: bool, issues: List[Issue], source: Source) -> Optional[Node]:
         pass
 
-    def attach_listeners(self, recognizer: Recognizer, issues: List[Issue]):
+    def attach_listeners(self, recognizer: Recognizer, issues: List[Issue], source: Source):
         recognizer.removeErrorListeners()
-        recognizer.addErrorListener(ParserErrorListener(issues))
+        recognizer.addErrorListener(ParserErrorListener(issues, source))
 
 
 class ParserErrorListener(ErrorListener):
-    def __init__(self, issues: List[Issue]):
+    def __init__(self, issues: List[Issue], source: Source):
         self.issues = issues
+        self.source = source
 
     def syntaxError(self, recognizer, offending_symbol, line, column, msg, e):
         start_point = Point(line, column)
         end_point = start_point
         if isinstance(offending_symbol, Token):
             end_point = token_end_point(offending_symbol)
         msg = (msg or "unspecified").capitalize()
-        self.issues.append(Issue(IssueType.SYNTACTIC, msg, position=Position(start_point, end_point)))
+        self.issues.append(Issue(IssueType.SYNTACTIC, msg, position=Position(start_point, end_point, self.source)))