refactor[next] error handling

src/gt4py/cartesian/frontend/node_util.py

@@ -147,4 +147,4 @@ def recurse(node: Node) -> Generator[Node, None, None]:
 def location_to_source_location(loc: Optional[Location]) -> Optional[eve.SourceLocation]:
     if loc is None or loc.line <= 0 or loc.column <= 0:
         return None
-    return eve.SourceLocation(line=loc.line, column=loc.column, source=loc.scope)
+    return eve.SourceLocation(line=loc.line, column=loc.column, filename=loc.scope)

src/gt4py/cartesian/gtc/dace/expansion/utils.py

@@ -35,7 +35,7 @@ def get_dace_debuginfo(node: common.LocNode):
             node.loc.column,
             node.loc.line,
             node.loc.column,
-            node.loc.source,
+            node.loc.filename,
         )
     else:
         return dace.dtypes.DebugInfo(0)

src/gt4py/eve/concepts.py

@@ -17,7 +17,6 @@
 
 from __future__ import annotations
 
-import ast
 import copy
 import re
 
@@ -58,58 +57,42 @@ class SymbolRef(ConstrainedStr, regex=_SYMBOL_NAME_RE):
 
 @datamodels.datamodel(slots=True, frozen=True)
 class SourceLocation:
-    """Source code location (line, column, source)."""
+    """File-line-column information for source code."""
 
+    filename: Optional[str]
     line: int = datamodels.field(validator=_validators.ge(1))
     column: int = datamodels.field(validator=_validators.ge(1))
-    source: str
     end_line: Optional[int] = datamodels.field(validator=_validators.optional(_validators.ge(1)))
     end_column: Optional[int] = datamodels.field(validator=_validators.optional(_validators.ge(1)))
 
-    @classmethod
-    def from_AST(cls, ast_node: ast.AST, source: Optional[str] = None) -> SourceLocation:
-        if (
-            not isinstance(ast_node, ast.AST)
-            or getattr(ast_node, "lineno", None) is None
-            or getattr(ast_node, "col_offset", None) is None
-        ):
-            raise ValueError(
-                f"Passed AST node '{ast_node}' does not contain a valid source location."
-            )
-        if source is None:
-            source = f"<ast.{type(ast_node).__name__} at 0x{id(ast_node):x}>"
-        return cls(
-            ast_node.lineno,
-            ast_node.col_offset + 1,
-            source,
-            end_line=ast_node.end_lineno,
-            end_column=ast_node.end_col_offset + 1 if ast_node.end_col_offset is not None else None,
-        )
-
     def __init__(
         self,
+        filename: Optional[str],
         line: int,
         column: int,
-        source: str,
-        *,
         end_line: Optional[int] = None,
         end_column: Optional[int] = None,
     ) -> None:
         assert end_column is None or end_line is not None
         self.__auto_init__(  # type: ignore[attr-defined]  # __auto_init__ added dynamically
-            line=line, column=column, source=source, end_line=end_line, end_column=end_column
+            filename=filename, line=line, column=column, end_line=end_line, end_column=end_column
         )
 
     def __str__(self) -> str:
-        src = self.source or ""
+        filename_str = self.filename or "-"
+
+        end_line_str = self.end_line if self.end_line is not None else "-"
+        end_column_str = self.end_column if self.end_column is not None else "-"
 
-        end_part = ""
-        if self.end_line is not None:
-            end_part += f" to {self.end_line}"
+        end_str: Optional[str] = None
         if self.end_column is not None:
-            end_part += f":{self.end_column}"
+            end_str = f"{end_line_str}:{end_column_str}"
+        elif self.end_line is not None:
+            end_str = f"{end_line_str}"
 
-        return f"<{src}:{self.line}:{self.column}{end_part}>"
+        if end_str is not None:
+            return f"<{filename_str}:{self.line}:{self.column} to {end_str}>"
+        return f"<{filename_str}:{self.line}:{self.column}>"
 
 
 @datamodels.datamodel(slots=True, frozen=True)

src/gt4py/next/common.py

@@ -108,41 +108,3 @@ class NeighborTable(Connectivity, Protocol):
 class GridType(StrEnum):
     CARTESIAN = "cartesian"
     UNSTRUCTURED = "unstructured"
-
-
-class GTError:
-    """Base class for GridTools exceptions.
-
-    Notes:
-        This base class has to be always inherited together with a standard
-        exception, and thus it should not be used as direct superclass
-        for custom exceptions. Inherit directly from :class:`GTTypeError`,
-        :class:`GTTypeError`, ...
-
-    """
-
-    ...
-
-
-class GTRuntimeError(GTError, RuntimeError):
-    """Base class for GridTools run-time errors."""
-
-    ...
-
-
-class GTSyntaxError(GTError, SyntaxError):
-    """Base class for GridTools syntax errors."""
-
-    ...
-
-
-class GTTypeError(GTError, TypeError):
-    """Base class for GridTools type errors."""
-
-    ...
-
-
-class GTValueError(GTError, ValueError):
-    """Base class for GridTools value errors."""
-
-    ...

src/gt4py/next/errors/__init__.py

@@ -0,0 +1,41 @@
+# GT4Py - GridTools Framework
+#
+# Copyright (c) 2014-2023, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from . import (  # noqa: module needs to be loaded for pretty printing of uncaught exceptions.
+    excepthook,
+)
+from .excepthook import set_developer_mode
+from .exceptions import (
+    ArgumentCountError,
+    CompilerError,
+    InvalidParameterAnnotationError,
+    KeywordArgumentError,
+    MissingAttributeError,
+    MissingParameterAnnotationError,
+    UndefinedSymbolError,
+    UnsupportedPythonFeatureError,
+)
+
+
+__all__ = [
+    "ArgumentCountError",
+    "CompilerError",
+    "InvalidParameterAnnotationError",
+    "KeywordArgumentError",
+    "MissingAttributeError",
+    "MissingParameterAnnotationError",
+    "UndefinedSymbolError",
+    "UnsupportedPythonFeatureError",
+    "set_developer_mode",
+]

src/gt4py/next/errors/excepthook.py

@@ -0,0 +1,94 @@
+# GT4Py - GridTools Framework
+#
+# Copyright (c) 2014-2023, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import os
+import sys
+from typing import Callable, Optional
+
+import importlib_metadata
+
+from . import exceptions, formatting
+
+
+def _get_developer_mode_python_env() -> bool:
+    """Guess if the Python environment is used to develop gt4py."""
+    # Import gt4py and use its __name__ because hard-coding "gt4py" would fail
+    # silently if the module's name changes for whatever reason.
+    import gt4py
+
+    package_name = gt4py.__name__
+
+    # Check if any package requires gt4py as a dependency. If not, we are
+    # probably developing gt4py itself rather than something else using gt4py.
+    dists = importlib_metadata.distributions()
+    for dist in dists:
+        for req in dist.requires or []:
+            if req.startswith(package_name):
+                return False
+    return True
+
+
+def _get_developer_mode_envvar() -> Optional[bool]:
+    """Detect if the user set developer mode in environment variables."""
+    env_var_name = "GT4PY_DEVELOPER_MODE"
+    if env_var_name in os.environ:
+        try:
+            return bool(os.environ[env_var_name])
+        except TypeError:
+            return False
+    return None
+
+
+def _guess_developer_mode() -> bool:
+    """Guess if gt4py is run by its developers or by third party users."""
+    env = _get_developer_mode_envvar()
+    if env is not None:
+        return env
+    return _get_developer_mode_python_env()
+
+
+_developer_mode = _guess_developer_mode()
+
+
+def set_developer_mode(enabled: bool = False) -> None:
+    """In developer mode, information useful for gt4py developers is also shown."""
+    global _developer_mode
+    _developer_mode = enabled
+
+
+def compilation_error_hook(fallback: Callable, type_: type, value: BaseException, tb) -> None:
+    """
+    Format `CompilationError`s in a neat way.
+
+    All other Python exceptions are formatted by the `fallback` hook.
+    """
+    if isinstance(value, exceptions.CompilerError):
+        if _developer_mode:
+            exc_strs = formatting.format_compilation_error(
+                type(value),
+                value.message,
+                value.location,
+                value.__traceback__,
+                value.__cause__,
+            )
+        else:
+            exc_strs = formatting.format_compilation_error(
+                type(value), value.message, value.location
+            )
+        print("".join(exc_strs), file=sys.stderr)
+    else:
+        fallback(type_, value, tb)
+
+
+_fallback = sys.excepthook
+sys.excepthook = lambda ty, val, tb: compilation_error_hook(_fallback, ty, val, tb)

src/gt4py/next/errors/exceptions.py

@@ -0,0 +1,115 @@
+# GT4Py - GridTools Framework
+#
+# Copyright (c) 2014-2023, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import textwrap
+from typing import Any, Optional
+
+from gt4py.eve import SourceLocation
+
+from . import formatting
+
+
+class CompilerError(Exception):
+    location: Optional[SourceLocation]
+
+    def __init__(self, location: Optional[SourceLocation], message: str) -> None:
+        self.location = location
+        super().__init__(message)
+
+    @property
+    def message(self) -> str:
+        return self.args[0]
+
+    def with_location(self, location: Optional[SourceLocation]) -> CompilerError:
+        self.location = location
+        return self
+
+    def __str__(self) -> str:
+        if self.location:
+            loc_str = formatting.format_location(self.location, show_caret=True)
+            return f"{self.message}\n{textwrap.indent(loc_str, '  ')}"
+        return self.message
+
+
+class UnsupportedPythonFeatureError(CompilerError):
+    feature: str
+
+    def __init__(self, location: Optional[SourceLocation], feature: str) -> None:
+        super().__init__(location, f"unsupported Python syntax: '{feature}'")
+        self.feature = feature
+
+
+class UndefinedSymbolError(CompilerError):
+    sym_name: str
+
+    def __init__(self, location: Optional[SourceLocation], name: str) -> None:
+        super().__init__(location, f"name '{name}' is not defined")
+        self.sym_name = name
+
+
+class MissingAttributeError(CompilerError):
+    attr_name: str
+
+    def __init__(self, location: Optional[SourceLocation], attr_name: str) -> None:
+        super().__init__(location, f"object does not have attribute '{attr_name}'")
+        self.attr_name = attr_name
+
+
+class CompilerTypeError(CompilerError):
+    def __init__(self, location: Optional[SourceLocation], message: str) -> None:
+        super().__init__(location, message)
+
+
+class MissingParameterAnnotationError(CompilerTypeError):
+    param_name: str
+
+    def __init__(self, location: Optional[SourceLocation], param_name: str) -> None:
+        super().__init__(location, f"parameter '{param_name}' is missing type annotations")
+        self.param_name = param_name
+
+
+class InvalidParameterAnnotationError(CompilerTypeError):
+    param_name: str
+    annotated_type: Any
+
+    def __init__(self, location: Optional[SourceLocation], param_name: str, type_: Any) -> None:
+        super().__init__(
+            location, f"parameter '{param_name}' has invalid type annotation '{type_}'"
+        )
+        self.param_name = param_name
+        self.annotated_type = type_
+
+
+class ArgumentCountError(CompilerTypeError):
+    expected_count: int
+    provided_count: int
+
+    def __init__(
+        self, location: Optional[SourceLocation], expected_count: int, provided_count: int
+    ) -> None:
+        super().__init__(
+            location, f"expected {expected_count} arguments but {provided_count} were provided"
+        )
+        self.num_expected = expected_count
+        self.provided_count = provided_count
+
+
+class KeywordArgumentError(CompilerTypeError):
+    provided_names: str
+
+    def __init__(self, location: Optional[SourceLocation], provided_names: str) -> None:
+        super().__init__(location, f"unexpected keyword argument(s) '{provided_names}' provided")
+        self.provided_names = provided_names