guppylang-internals 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

guppylang_internals/diagnostic.py

@@ -208,7 +208,8 @@ class DiagnosticsRenderer:
     MAX_MESSAGE_LINE_LEN: Final[int] = 80
 
     #: Number of preceding source lines we show to give additional context
-    PREFIX_CONTEXT_LINES: Final[int] = 2
+    PREFIX_ERROR_CONTEXT_LINES: Final[int] = 2
+    PREFIX_NOTE_CONTEXT_LINES: Final[int] = 1
 
     def __init__(self, source: SourceMap) -> None:
         self.buffer = []
@@ -243,31 +244,84 @@ class DiagnosticsRenderer:
         else:
             span = to_span(diag.span)
             level = self.level_str(diag.level)
-            all_spans = [span] + [
-                to_span(child.span) for child in diag.children if child.span
+
+            children_with_span = [
+                (child, to_span(child.span)) for child in diag.children if child.span
             ]
+            all_spans = [span] + [span for _, span in children_with_span]
             max_lineno = max(s.end.line for s in all_spans)
+
             self.buffer.append(f"{level}: {diag.rendered_title} (at {span.start})")
+
+            # Render main error span first
             self.render_snippet(
                 span,
                 diag.rendered_span_label,
                 max_lineno,
                 is_primary=True,
-                prefix_lines=self.PREFIX_CONTEXT_LINES,
+                prefix_lines=self.PREFIX_ERROR_CONTEXT_LINES,
             )
-            # First render all sub-diagnostics that come with a span
-            for sub_diag in diag.children:
-                if sub_diag.span:
+
+            match children_with_span:
+                case []:
+                    pass
+                case [(only_child, span)]:
+                    self.buffer.append("\nNote:")
+                    self.render_snippet(
+                        span,
+                        only_child.rendered_span_label,
+                        max_lineno,
+                        prefix_lines=self.PREFIX_NOTE_CONTEXT_LINES,
+                        print_pad_line=True,
+                    )
+                case [(first_child, first_span), *children_with_span]:
+                    self.buffer.append("\nNotes:")
                     self.render_snippet(
-                        to_span(sub_diag.span),
-                        sub_diag.rendered_span_label,
+                        first_span,
+                        first_child.rendered_span_label,
                         max_lineno,
-                        is_primary=False,
+                        prefix_lines=self.PREFIX_NOTE_CONTEXT_LINES,
+                        print_pad_line=True,
                     )
+
+                    prev_span_end_lineno = first_span.end.line
+
+                    for sub_diag, span in children_with_span:
+                        span_start_lineno = span.start.line
+                        span_end_lineno = span.end.line
+
+                        # If notes are on the same line, render them together
+                        if span_start_lineno == prev_span_end_lineno:
+                            prefix_lines = 0
+                            print_pad_line = True
+                        # if notes are close enough, render them adjacently
+                        elif (
+                            span_start_lineno - self.PREFIX_NOTE_CONTEXT_LINES
+                            <= prev_span_end_lineno + 1
+                        ):
+                            prefix_lines = span_start_lineno - prev_span_end_lineno - 1
+                            print_pad_line = False
+                        # otherwise we render a separator between notes
+                        else:
+                            self.buffer.append("")
+                            prefix_lines = self.PREFIX_NOTE_CONTEXT_LINES
+                            print_pad_line = False
+
+                        self.render_snippet(
+                            span,
+                            sub_diag.rendered_span_label,
+                            max_lineno,
+                            prefix_lines=prefix_lines,
+                            print_pad_line=print_pad_line,
+                        )
+                        prev_span_end_lineno = span_end_lineno
+
+            # Render the main diagnostic message if present
             if diag.rendered_message:
                 self.buffer.append("")
                 self.buffer += wrap(diag.rendered_message, self.MAX_MESSAGE_LINE_LEN)
-        # Finally, render all sub-diagnostics that have a non-span message
+
+        # Render all sub-diagnostics that have a non-span message
         for sub_diag in diag.children:
             if sub_diag.rendered_message:
                 self.buffer.append("")
@@ -281,8 +335,9 @@ class DiagnosticsRenderer:
         span: Span,
         label: str | None,
         max_lineno: int,
-        is_primary: bool,
+        is_primary: bool = False,
         prefix_lines: int = 0,
+        print_pad_line: bool = False,
     ) -> None:
         """Renders the source associated with a span together with an optional label.
 
@@ -315,7 +370,8 @@ class DiagnosticsRenderer:
         Optionally includes up to `prefix_lines` preceding source lines to give
         additional context.
         """
-        # Check how much space we need to reserve for the leading line numbers
+        # Check how much horizontal space we need to reserve for the leading
+        # line numbers
         ll_length = len(str(max_lineno))
         highlight_char = "^" if is_primary else "-"
 
@@ -324,12 +380,29 @@ class DiagnosticsRenderer:
             ll = "" if line_number is None else str(line_number)
             self.buffer.append(" " * (ll_length - len(ll)) + ll + " | " + line)
 
-        # One line of padding
-        render_line("")
+        # One line of padding (primary span, first note or between same line notes)
+        if is_primary or print_pad_line:
+            render_line("")
 
-        # Grab all lines we want to display and remove excessive leading whitespace
+        # Grab all lines we want to display
         prefix_lines = min(prefix_lines, span.start.line - 1)
         all_lines = self.source.span_lines(span, prefix_lines)
+
+        # Convert leading tab characters into four whitespaces each (see PEP 8)
+        for i, line in enumerate(all_lines):
+            line_no_tabs = line.lstrip("\t")
+            num_tabs = len(line) - len(line_no_tabs)
+            all_lines[i] = " " * (num_tabs * 4) + line_no_tabs
+            # Shift span locations, accounting for incorporated \t
+            new_start = span.start
+            new_end = span.end
+            if i == prefix_lines:  # Line is the first line in the span
+                new_start = span.start.shift_right(num_tabs * 3)
+            if i == len(all_lines) - 1:  # Line is the last line in the span
+                new_end = span.end.shift_right(num_tabs * 3)
+            span = Span(new_start or span.start, new_end)
+
+        # Remove excessive leading whitespace
         leading_whitespace = min(len(line) - len(line.lstrip()) for line in all_lines)
         if leading_whitespace > self.MAX_LEADING_WHITESPACE:
             remove = leading_whitespace - self.OPTIMAL_LEADING_WHITESPACE

guppylang_internals/engine.py

@@ -3,14 +3,10 @@ from enum import Enum
 from types import FrameType
 from typing import TYPE_CHECKING
 
+import hugr
 import hugr.build.function as hf
-import hugr.std.collections.array
-import hugr.std.float
-import hugr.std.int
-import hugr.std.logic
-import hugr.std.prelude
 from hugr import ops
-from hugr.ext import Extension
+from hugr.ext import Extension, ExtensionRegistry
 from hugr.package import ModulePointer, Package
 
 import guppylang_internals
@@ -150,11 +146,52 @@ class CompilationEngine:
     types_to_check_worklist: dict[DefId, ParsedDef]
     to_check_worklist: dict[DefId, ParsedDef]
 
+    # Cached compilation infrastructure (lazy-initialized, program-independent)
+    _base_packaged_extensions: list[Extension] | None = None
+    _base_resolve_registry: ExtensionRegistry | None = None
+
     def __init__(self) -> None:
         """Resets the compilation cache."""
         self.reset()
         self.additional_extensions = []
 
+    @staticmethod
+    def _get_base_packaged_extensions() -> list[Extension]:
+        """Get the base list of packaged extensions (cached at class level)."""
+        if CompilationEngine._base_packaged_extensions is None:
+            from guppylang_internals.std._internal.compiler.tket_exts import (
+                TKET_EXTENSIONS,
+            )
+
+            CompilationEngine._base_packaged_extensions = [
+                *TKET_EXTENSIONS,
+                guppylang_internals.compiler.hugr_extension.EXTENSION,  # type: ignore[attr-defined]
+            ]
+        return CompilationEngine._base_packaged_extensions
+
+    @staticmethod
+    def _get_base_resolve_registry() -> ExtensionRegistry:
+        """Get the base resolve registry with standard extensions.
+
+        Cached at class level.
+        """
+        if CompilationEngine._base_resolve_registry is None:
+            base_extensions = CompilationEngine._get_base_packaged_extensions()
+            registry = ExtensionRegistry()
+            for ext in [
+                *base_extensions,
+                hugr.std.prelude.PRELUDE_EXTENSION,
+                hugr.std.collections.array.EXTENSION,
+                hugr.std.float.FLOAT_OPS_EXTENSION,
+                hugr.std.float.FLOAT_TYPES_EXTENSION,
+                hugr.std.int.INT_OPS_EXTENSION,
+                hugr.std.int.INT_TYPES_EXTENSION,
+                hugr.std.logic.EXTENSION,
+            ]:
+                registry.register_updated(ext)
+            CompilationEngine._base_resolve_registry = registry
+        return CompilationEngine._base_resolve_registry
+
     def reset(self) -> None:
         """Resets the compilation cache."""
         self.parsed = {}
@@ -220,21 +257,12 @@ class CompilationEngine:
 
         This is the main driver behind `guppy.check()`.
         """
-        from guppylang_internals.checker.core import Globals
-
         # Clear previous compilation cache.
         # TODO: In order to maintain results from the previous `check` call we would
         #  need to store and check if any dependencies have changed.
         self.reset()
 
-        defn = DEF_STORE.raw_defs[id]
-        self.to_check_worklist = {
-            defn.id: (
-                defn.parse(Globals(DEF_STORE.frames[defn.id]), DEF_STORE.sources)
-                if isinstance(defn, ParsableDef)
-                else defn
-            )
-        }
+        self.to_check_worklist[id] = self.get_parsed(id)
         while self.types_to_check_worklist or self.to_check_worklist:
             # Types need to be checked first. This is because parsing e.g. a function
             # definition requires instantiating the types in its signature which can
@@ -273,40 +301,56 @@ class CompilationEngine:
             # loosened after https://github.com/quantinuum/hugr/issues/2501 is fixed
             graph.hugr.entrypoint = compiled_def.hugr_node
 
-        # TODO: Currently the list of extensions is manually managed by the user.
-        #  We should compute this dynamically from the imported dependencies instead.
-        #
-        # The hugr prelude and std_extensions are implicit.
-        from guppylang_internals.std._internal.compiler.tket_exts import TKET_EXTENSIONS
+        # Use cached base extensions and registry, only add additional extensions
+        base_extensions = self._get_base_packaged_extensions()
+        packaged_extensions = [*base_extensions, *self.additional_extensions]
 
-        extensions = [
-            *TKET_EXTENSIONS,
-            guppylang_internals.compiler.hugr_extension.EXTENSION,
-            *self.additional_extensions,
-        ]
-        # TODO replace with computed extensions after https://github.com/quantinuum/guppylang/issues/550
-        all_used_extensions = [
-            *extensions,
-            hugr.std.prelude.PRELUDE_EXTENSION,
-            hugr.std.collections.array.EXTENSION,
-            hugr.std.float.FLOAT_OPS_EXTENSION,
-            hugr.std.float.FLOAT_TYPES_EXTENSION,
-            hugr.std.int.INT_OPS_EXTENSION,
-            hugr.std.int.INT_TYPES_EXTENSION,
-            hugr.std.logic.EXTENSION,
-        ]
-        graph.hugr.module_root.metadata[CoreMetadataKeys.USED_EXTENSIONS.value] = [
+        # Build resolve registry: start with cached base, add any additional
+        if self.additional_extensions:
+            from copy import deepcopy
+
+            resolve_registry = deepcopy(self._get_base_resolve_registry())
+            for ext in self.additional_extensions:
+                resolve_registry.register_updated(ext)
+        else:
+            resolve_registry = self._get_base_resolve_registry()
+
+        # Compute used extensions dynamically from the HUGR.
+        used_extensions_result = graph.hugr.used_extensions(
+            resolve_from=resolve_registry
+        )
+
+        # Set metadata for used extensions
+        used_exts_meta = [
             {
                 "name": ext.name,
                 "version": str(ext.version),
             }
-            for ext in all_used_extensions
+            for ext in used_extensions_result.used_extensions.extensions.values()
         ]
+        # Add unresolved extensions as well, but we only have the names
+        used_exts_meta.extend(
+            {
+                "name": ext,
+            }
+            for ext in used_extensions_result.unresolved_extensions
+        )
+        graph.hugr.module_root.metadata[CoreMetadataKeys.USED_EXTENSIONS.value] = (
+            used_exts_meta
+        )
         graph.hugr.module_root.metadata[CoreMetadataKeys.GENERATOR.value] = {
             "name": "guppylang",
             "version": guppylang_internals.__version__,
         }
-        return ModulePointer(Package(modules=[graph.hugr], extensions=extensions), 0)
+        # only package used extensions
+        packaged_extensions = [
+            ext
+            for ext in packaged_extensions
+            if ext.name in used_extensions_result.ids()
+        ]
+        return ModulePointer(
+            Package(modules=[graph.hugr], extensions=packaged_extensions), 0
+        )
 
 
 ENGINE: CompilationEngine = CompilationEngine()

guppylang_internals/error.py

@@ -104,4 +104,4 @@ def pretty_errors(f: FuncT) -> FuncT:
         with exception_hook(hook):
             return f(*args, **kwargs)
 
-    return cast(FuncT, pretty_errors_wrapped)
+    return cast("FuncT", pretty_errors_wrapped)