mark/expression: use SyntaxError instead of custom ParseError

If we are going to expose Expression, better to use a general exception,
this way we can avoid exposing an extra type.

Author: bluetech

src/_pytest/mark/__init__.py

@@ -10,7 +10,6 @@
 from typing import TYPE_CHECKING
 
 from .expression import Expression
-from .expression import ParseError
 from .structures import _HiddenParam
 from .structures import EMPTY_PARAMETERSET_OPTION
 from .structures import get_empty_parameterset_mark
@@ -274,8 +273,10 @@ def deselect_by_mark(items: list[Item], config: Config) -> None:
 def _parse_expression(expr: str, exc_message: str) -> Expression:
     try:
         return Expression.compile(expr)
-    except ParseError as e:
-        raise UsageError(f"{exc_message}: {expr}: {e}") from None
+    except SyntaxError as e:
+        raise UsageError(
+            f"{exc_message}: {e.text}: at column {e.offset}: {e.msg}"
+        ) from None
 
 
 def pytest_collection_modifyitems(items: list[Item], config: Config) -> None:

src/_pytest/mark/expression.py

@@ -31,6 +31,7 @@
 import keyword
 import re
 import types
+from typing import Final
 from typing import Literal
 from typing import NoReturn
 from typing import overload
@@ -39,10 +40,13 @@
 
 __all__ = [
     "Expression",
-    "ParseError",
+    "ExpressionMatcher",
 ]
 
 
+FILE_NAME: Final = "<pytest match expression>"
+
+
 class TokenType(enum.Enum):
     LPAREN = "left parenthesis"
     RPAREN = "right parenthesis"
@@ -64,25 +68,11 @@ class Token:
     pos: int
 
 
-class ParseError(Exception):
-    """The :class:`Expression` contains invalid syntax.
-
-    :param column: The column in the line where the error occurred (1-based).
-    :param message: A description of the error.
-    """
-
-    def __init__(self, column: int, message: str) -> None:
-        self.column = column
-        self.message = message
-
-    def __str__(self) -> str:
-        return f"at column {self.column}: {self.message}"
-
-
 class Scanner:
-    __slots__ = ("current", "tokens")
+    __slots__ = ("current", "input", "tokens")
 
     def __init__(self, input: str) -> None:
+        self.input = input
         self.tokens = self.lex(input)
         self.current = next(self.tokens)
 
@@ -106,15 +96,15 @@ def lex(self, input: str) -> Iterator[Token]:
             elif (quote_char := input[pos]) in ("'", '"'):
                 end_quote_pos = input.find(quote_char, pos + 1)
                 if end_quote_pos == -1:
-                    raise ParseError(
-                        pos + 1,
+                    raise SyntaxError(
                         f'closing quote "{quote_char}" is missing',
+                        (FILE_NAME, 1, pos + 1, input),
                     )
                 value = input[pos : end_quote_pos + 1]
                 if (backslash_pos := input.find("\\")) != -1:
-                    raise ParseError(
-                        backslash_pos + 1,
+                    raise SyntaxError(
                         r'escaping with "\" not supported in marker expression',
+                        (FILE_NAME, 1, backslash_pos + 1, input),
                     )
                 yield Token(TokenType.STRING, value, pos)
                 pos += len(value)
@@ -132,9 +122,9 @@ def lex(self, input: str) -> Iterator[Token]:
                         yield Token(TokenType.IDENT, value, pos)
                     pos += len(value)
                 else:
-                    raise ParseError(
-                        pos + 1,
+                    raise SyntaxError(
                         f'unexpected character "{input[pos]}"',
+                        (FILE_NAME, 1, pos + 1, input),
                     )
         yield Token(TokenType.EOF, "", pos)
 
@@ -157,12 +147,12 @@ def accept(self, type: TokenType, *, reject: bool = False) -> Token | None:
         return None
 
     def reject(self, expected: Sequence[TokenType]) -> NoReturn:
-        raise ParseError(
-            self.current.pos + 1,
+        raise SyntaxError(
             "expected {}; got {}".format(
                 " OR ".join(type.value for type in expected),
                 self.current.type.value,
             ),
+            (FILE_NAME, 1, self.current.pos + 1, self.input),
         )
 
 
@@ -223,14 +213,14 @@ def not_expr(s: Scanner) -> ast.expr:
 def single_kwarg(s: Scanner) -> ast.keyword:
     keyword_name = s.accept(TokenType.IDENT, reject=True)
     if not keyword_name.value.isidentifier():
-        raise ParseError(
-            keyword_name.pos + 1,
+        raise SyntaxError(
             f"not a valid python identifier {keyword_name.value}",
+            (FILE_NAME, 1, keyword_name.pos + 1, s.input),
         )
     if keyword.iskeyword(keyword_name.value):
-        raise ParseError(
-            keyword_name.pos + 1,
+        raise SyntaxError(
             f"unexpected reserved python keyword `{keyword_name.value}`",
+            (FILE_NAME, 1, keyword_name.pos + 1, s.input),
         )
     s.accept(TokenType.EQUAL, reject=True)
 
@@ -245,9 +235,9 @@ def single_kwarg(s: Scanner) -> ast.keyword:
         elif value_token.value in BUILTIN_MATCHERS:
             value = BUILTIN_MATCHERS[value_token.value]
         else:
-            raise ParseError(
-                value_token.pos + 1,
+            raise SyntaxError(
                 f'unexpected character/s "{value_token.value}"',
+                (FILE_NAME, 1, value_token.pos + 1, s.input),
             )
 
     ret = ast.keyword(keyword_name.value, ast.Constant(value))
@@ -333,7 +323,7 @@ def compile(cls, input: str) -> Expression:
 
         :param input: The input expression - one line.
 
-        :raises ParseError: If the expression is malformed.
+        :raises SyntaxError: If the expression is malformed.
         """
         astexpr = expression(Scanner(input))
         code = compile(

testing/test_mark_expression.py

@@ -3,7 +3,6 @@
 from _pytest.mark import MarkMatcher
 from _pytest.mark.expression import Expression
 from _pytest.mark.expression import ExpressionMatcher
-from _pytest.mark.expression import ParseError
 import pytest
 
 
@@ -84,7 +83,7 @@ def matcher(name: str, /, **kwargs: str | int | bool | None) -> bool:
 
     assert evaluate(r"\nfoo\n", matcher)
     assert not evaluate(r"foo", matcher)
-    with pytest.raises(ParseError):
+    with pytest.raises(SyntaxError):
         evaluate("\nfoo\n", matcher)
 
 
@@ -137,10 +136,10 @@ def matcher(name: str, /, **kwargs: str | int | bool | None) -> bool:
     ),
 )
 def test_syntax_errors(expr: str, column: int, message: str) -> None:
-    with pytest.raises(ParseError) as excinfo:
+    with pytest.raises(SyntaxError) as excinfo:
         evaluate(expr, lambda ident, /, **kwargs: True)
-    assert excinfo.value.column == column
-    assert excinfo.value.message == message
+    assert excinfo.value.offset == column
+    assert excinfo.value.msg == message
 
 
 @pytest.mark.parametrize(
@@ -204,7 +203,7 @@ def matcher(name: str, /, **kwargs: str | int | bool | None) -> bool:
     ),
 )
 def test_invalid_idents(ident: str) -> None:
-    with pytest.raises(ParseError):
+    with pytest.raises(SyntaxError):
         evaluate(ident, lambda ident, /, **kwargs: True)
 
 
@@ -240,7 +239,7 @@ def test_invalid_idents(ident: str) -> None:
 def test_invalid_kwarg_name_or_value(
     expr: str, expected_error_msg: str, mark_matcher: MarkMatcher
 ) -> None:
-    with pytest.raises(ParseError, match=expected_error_msg):
+    with pytest.raises(SyntaxError, match=expected_error_msg):
         assert evaluate(expr, mark_matcher)