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

guppylang_internals/nodes.py

@@ -31,6 +31,14 @@ class PlaceNode(ast.expr):
 
     _fields = ("place",)
 
+    def __init__(self, place: "Place") -> None:
+        super().__init__()
+        self.place = place
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class GlobalName(ast.Name):
     id: str
@@ -41,6 +49,15 @@ class GlobalName(ast.Name):
         "def_id",
     )
 
+    def __init__(self, id: str, def_id: "DefId") -> None:
+        super().__init__(id=id)
+        self.id = id
+        self.def_id = def_id
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class GenericParamValue(ast.Name):
     id: str
@@ -51,6 +68,15 @@ class GenericParamValue(ast.Name):
         "param",
     )
 
+    def __init__(self, id: str, param: "ConstParam") -> None:
+        super().__init__(id=id)
+        self.id = id
+        self.param = param
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class LocalCall(ast.expr):
     func: ast.expr
@@ -61,6 +87,15 @@ class LocalCall(ast.expr):
         "args",
     )
 
+    def __init__(self, func: ast.expr, args: list[ast.expr]) -> None:
+        super().__init__()
+        self.func = func
+        self.args = args
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class GlobalCall(ast.expr):
     def_id: "DefId"
@@ -73,6 +108,16 @@ class GlobalCall(ast.expr):
         "type_args",
     )
 
+    def __init__(self, def_id: "DefId", args: list[ast.expr], type_args: Inst) -> None:
+        super().__init__()
+        self.def_id = def_id
+        self.args = args
+        self.type_args = type_args
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class TensorCall(ast.expr):
     """A call to a tuple of functions. Behaves like a local call, but more
@@ -88,6 +133,18 @@ class TensorCall(ast.expr):
         "tensor_ty",
     )
 
+    def __init__(
+        self, func: ast.expr, args: list[ast.expr], tensor_ty: FunctionType
+    ) -> None:
+        super().__init__()
+        self.func = func
+        self.args = args
+        self.tensor_ty = tensor_ty
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class TypeApply(ast.expr):
     value: ast.expr
@@ -98,6 +155,15 @@ class TypeApply(ast.expr):
         "inst",
     )
 
+    def __init__(self, value: ast.expr, inst: Inst) -> None:
+        super().__init__()
+        self.value = value
+        self.inst = inst
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class PartialApply(ast.expr):
     """A partial function application.
@@ -114,6 +180,15 @@ class PartialApply(ast.expr):
         "args",
     )
 
+    def __init__(self, func: ast.expr, args: list[ast.expr]) -> None:
+        super().__init__()
+        self.func = func
+        self.args = args
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class FieldAccessAndDrop(ast.expr):
     """A field access on a struct, dropping all the remaining other fields."""
@@ -128,6 +203,18 @@ class FieldAccessAndDrop(ast.expr):
         "field",
     )
 
+    def __init__(
+        self, value: ast.expr, struct_ty: "StructType", field: "StructField"
+    ) -> None:
+        super().__init__()
+        self.value = value
+        self.struct_ty = struct_ty
+        self.field = field
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class SubscriptAccessAndDrop(ast.expr):
     """A subscript element access on an object, dropping all the remaining items."""
@@ -139,6 +226,23 @@ class SubscriptAccessAndDrop(ast.expr):
 
     _fields = ("item", "item_expr", "getitem_expr", "original_expr")
 
+    def __init__(
+        self,
+        item: "Variable",
+        item_expr: ast.expr,
+        getitem_expr: ast.expr,
+        original_expr: ast.Subscript,
+    ) -> None:
+        super().__init__()
+        self.item = item
+        self.item_expr = item_expr
+        self.getitem_expr = getitem_expr
+        self.original_expr = original_expr
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class TupleAccessAndDrop(ast.expr):
     """A subscript element access on a tuple, dropping all the remaining items."""
@@ -149,6 +253,16 @@ class TupleAccessAndDrop(ast.expr):
 
     _fields = ("value", "tuple_ty", "index")
 
+    def __init__(self, value: ast.expr, tuple_ty: TupleType, index: int) -> None:
+        super().__init__()
+        self.value = value
+        self.tuple_ty = tuple_ty
+        self.index = index
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class MakeIter(ast.expr):
     """Creates an iterator using the `__iter__` magic method.
@@ -168,7 +282,8 @@ class MakeIter(ast.expr):
     def __init__(
         self, value: ast.expr, origin_node: ast.AST, unwrap_size_hint: bool = True
     ) -> None:
-        super().__init__(value)
+        super().__init__()
+        self.value = value
         self.origin_node = origin_node
         self.unwrap_size_hint = unwrap_size_hint
 
@@ -191,6 +306,14 @@ class IterNext(ast.expr):
 
     _fields = ("value",)
 
+    def __init__(self, value: ast.expr) -> None:
+        super().__init__()
+        self.value = value
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class DesugaredGenerator(ast.expr):
     """A single desugared generator in a list comprehension.
@@ -215,6 +338,27 @@ class DesugaredGenerator(ast.expr):
         "ifs",
     )
 
+    def __init__(
+        self,
+        iter_assign: ast.Assign,
+        next_call: ast.expr,
+        iter: ast.expr,
+        target: ast.expr,
+        ifs: list[ast.expr],
+        used_outer_places: "list[Place]",
+    ) -> None:
+        super().__init__()
+        self.iter_assign = iter_assign
+        self.next_call = next_call
+        self.iter = iter
+        self.target = target
+        self.ifs = ifs
+        self.used_outer_places = used_outer_places
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class DesugaredGeneratorExpr(ast.expr):
     """A desugared generator expression."""
@@ -227,6 +371,15 @@ class DesugaredGeneratorExpr(ast.expr):
         "generators",
     )
 
+    def __init__(self, elt: ast.expr, generators: list[DesugaredGenerator]) -> None:
+        super().__init__()
+        self.elt = elt
+        self.generators = generators
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class DesugaredListComp(ast.expr):
     """A desugared list comprehension."""
@@ -239,6 +392,15 @@ class DesugaredListComp(ast.expr):
         "generators",
     )
 
+    def __init__(self, elt: ast.expr, generators: list[DesugaredGenerator]) -> None:
+        super().__init__()
+        self.elt = elt
+        self.generators = generators
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class DesugaredArrayComp(ast.expr):
     """A desugared array comprehension."""
@@ -255,6 +417,19 @@ class DesugaredArrayComp(ast.expr):
         "elt_ty",
     )
 
+    def __init__(
+        self, elt: ast.expr, generator: DesugaredGenerator, length: Const, elt_ty: Type
+    ) -> None:
+        super().__init__()
+        self.elt = elt
+        self.generator = generator
+        self.length = length
+        self.elt_ty = elt_ty
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class ComptimeExpr(ast.expr):
     """A compile-time evaluated `py(...)` expression."""
@@ -263,6 +438,14 @@ class ComptimeExpr(ast.expr):
 
     _fields = ("value",)
 
+    def __init__(self, value: ast.expr) -> None:
+        super().__init__()
+        self.value = value
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class ExitKind(Enum):
     ExitShot = 0  # Exit the current shot
@@ -279,6 +462,19 @@ class PanicExpr(ast.expr):
 
     _fields = ("kind", "signal", "msg", "values")
 
+    def __init__(
+        self, kind: ExitKind, signal: ast.expr, msg: ast.expr, values: list[ast.expr]
+    ) -> None:
+        super().__init__()
+        self.kind = kind
+        self.signal = signal
+        self.msg = msg
+        self.values = values
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class BarrierExpr(ast.expr):
     """A `barrier(*args)` expression."""
@@ -287,6 +483,15 @@ class BarrierExpr(ast.expr):
     func_ty: FunctionType
     _fields = ("args", "func_ty")
 
+    def __init__(self, args: list[ast.expr], func_ty: FunctionType) -> None:
+        super().__init__()
+        self.args = args
+        self.func_ty = func_ty
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class StateResultExpr(ast.expr):
     """A `state_result(tag, *args)` expression."""
@@ -299,6 +504,25 @@ class StateResultExpr(ast.expr):
     array_len: Const | None
     _fields = ("tag_value", "tag_expr", "args", "func_ty", "has_array_input")
 
+    def __init__(
+        self,
+        tag_value: Const,
+        tag_expr: ast.expr,
+        args: list[ast.expr],
+        func_ty: FunctionType,
+        array_len: Const | None,
+    ) -> None:
+        super().__init__()
+        self.tag_value = tag_value
+        self.tag_expr = tag_expr
+        self.args = args
+        self.func_ty = func_ty
+        self.array_len = array_len
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 AnyCall = LocalCall | GlobalCall | TensorCall | BarrierExpr | StateResultExpr
 
@@ -311,6 +535,14 @@ class InoutReturnSentinel(ast.expr):
 
     _fields = ("var",)
 
+    def __init__(self, var: "Place | str") -> None:
+        super().__init__()
+        self.var = var
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class UnpackPattern(ast.expr):
     """The LHS of an unpacking assignment like `a, *bs, c = ...` or
@@ -328,6 +560,18 @@ class UnpackPattern(ast.expr):
 
     _fields = ("left", "starred", "right")
 
+    def __init__(
+        self, left: list[ast.expr], starred: ast.expr | None, right: list[ast.expr]
+    ) -> None:
+        super().__init__()
+        self.left = left
+        self.starred = starred
+        self.right = right
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class TupleUnpack(ast.expr):
     """The LHS of an unpacking assignment of a tuple."""
@@ -337,6 +581,14 @@ class TupleUnpack(ast.expr):
 
     _fields = ("pattern",)
 
+    def __init__(self, pattern: UnpackPattern) -> None:
+        super().__init__()
+        self.pattern = pattern
+
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class ArrayUnpack(ast.expr):
     """The LHS of an unpacking assignment of an array."""
@@ -353,7 +605,8 @@ class ArrayUnpack(ast.expr):
     _fields = ("pattern",)
 
     def __init__(self, pattern: UnpackPattern, length: int, elt_type: Type) -> None:
-        super().__init__(pattern)
+        super().__init__()
+        self.pattern = pattern
         self.length = length
         self.elt_type = elt_type
 
@@ -381,7 +634,8 @@ class IterableUnpack(ast.expr):
     def __init__(
         self, pattern: UnpackPattern, compr: DesugaredArrayComp, rhs_var: PlaceNode
     ) -> None:
-        super().__init__(pattern)
+        super().__init__()
+        self.pattern = pattern
         self.compr = compr
         self.rhs_var = rhs_var
 
@@ -404,6 +658,10 @@ class NestedFunctionDef(ast.FunctionDef):
         self.cfg = cfg
         self.ty = ty
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class CheckedNestedFunctionDef(ast.FunctionDef):
     def_id: "DefId"
@@ -429,6 +687,10 @@ class CheckedNestedFunctionDef(ast.FunctionDef):
         self.ty = ty
         self.captured = captured
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class Dagger(ast.expr):
     """The dagger modifier"""
@@ -491,6 +753,10 @@ class ModifiedBlock(ast.With):
         self.control = []
         self.power = []
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
     def is_dagger(self) -> bool:
         return len(self.dagger) % 2 == 1
 

guppylang_internals/span.py

@@ -113,11 +113,15 @@ def to_span(x: ToSpan) -> Span:
     assert file is not None
     assert line_offset is not None
     # x.lineno and line_offset both start at 1, so we have to subtract 1
-    start = Loc(file, x.lineno + line_offset - 1, x.col_offset)
+    start = Loc(
+        file,
+        x.lineno + line_offset - 1,  # type: ignore[attr-defined]
+        x.col_offset,  # type: ignore[attr-defined]
+    )
     end = Loc(
         file,
-        (x.end_lineno or x.lineno) + line_offset - 1,
-        x.end_col_offset or x.col_offset,
+        (x.end_lineno or x.lineno) + line_offset - 1,  # type: ignore[attr-defined]
+        x.end_col_offset or x.col_offset,  # type: ignore[attr-defined]
     )
     return Span(start, end)
 

guppylang_internals/std/_internal/checker.py

@@ -5,7 +5,7 @@ from typing import ClassVar
 from typing_extensions import assert_never
 
 from guppylang_internals.ast_util import get_type, with_loc, with_type
-from guppylang_internals.checker.core import Context
+from guppylang_internals.checker.core import Context, Variable
 from guppylang_internals.checker.errors.generic import UnsupportedError
 from guppylang_internals.checker.errors.type_errors import (
     ArrayComprUnknownSizeError,
@@ -33,6 +33,7 @@ from guppylang_internals.nodes import (
     GlobalCall,
     MakeIter,
     PanicExpr,
+    PlaceNode,
 )
 from guppylang_internals.tys.arg import ConstArg, TypeArg
 from guppylang_internals.tys.builtin import (
@@ -172,6 +173,105 @@ class ArrayCopyChecker(CustomCallChecker):
         return with_loc(self.node, node), get_type(array_arg)
 
 
+class ArrayIndexChecker(CustomCallChecker):
+    """Performs compile-time bounds checking for array indexing.
+
+    When the array size is statically known and the index is a literal constant,
+    this checker validates that the index is within bounds and raises an error
+    at compile time if it's not.
+    """
+
+    @dataclass(frozen=True)
+    class IndexOutOfBoundsError(Error):
+        title: ClassVar[str] = "Index out of bounds"
+        span_label: ClassVar[str] = (
+            "Array index {index} is out of bounds for array of size {size}."
+        )
+        index: int
+        size: int
+
+    def __init__(self, *, expr_index: int = 1):
+        """
+        Args:
+            expr_index: Position of the expression index argument (0 based)
+        """
+        self.expr_index: int = expr_index
+
+    def _extract_constant_index(self, index_expr: ast.expr) -> int | None:
+        """Extract a constant integer value from an index expression if possible.
+
+        Handles both AST constants and PlaceNode structures.
+        """
+        # Case 1: Simple AST constant (e.g., arr.take(0))
+        if isinstance(index_expr, ast.Constant) and isinstance(index_expr.value, int):
+            return index_expr.value
+
+        # Case 2: Subscript accesses (e.g., arr[0])
+        if isinstance(index_expr, PlaceNode):
+            place = index_expr.place
+            if isinstance(place, Variable):
+                defined_at = place.defined_at
+                if isinstance(defined_at, ast.Constant) and isinstance(
+                    defined_at.value, int
+                ):
+                    return defined_at.value
+
+        return None
+
+    def _check_constant_index_bounds(
+        self, index_expr: ast.expr, length_arg: TypeArg | ConstArg
+    ) -> None:
+        """Perform compile-time bounds checking if size and index are constant."""
+
+        # Check if array size is statically known
+        if not (
+            isinstance(length_arg, ConstArg)
+            and isinstance(length_arg.const, ConstValue)
+        ):
+            return
+
+        array_length = length_arg.const.value
+
+        index_value = self._extract_constant_index(index_expr)
+        if index_value is None:
+            return
+
+        if index_value < 0 or index_value >= array_length:
+            raise GuppyError(
+                ArrayIndexChecker.IndexOutOfBoundsError(
+                    index_expr,
+                    index=index_value,
+                    size=array_length,
+                )
+            )
+
+    def check(self, args: list[ast.expr], ty: Type) -> tuple[ast.expr, Subst]:
+        """Check-mode: verify arguments against
+        expected type and perform bounds check."""
+
+        # Run regular type checking for the arguments
+        args, subs, type_args = check_call(self.func.ty, args, ty, self.node, self.ctx)
+
+        # Check the index bounds (first:index expression, second: length_arg)
+        self._check_constant_index_bounds(args[self.expr_index], type_args[1])
+
+        # Return the synthesized node and type
+        node = GlobalCall(def_id=self.func.id, args=args, type_args=type_args)
+        return with_loc(self.node, node), subs
+
+    def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
+        """Synthesize-mode: infer return type and perform bounds check."""
+        # Run regular type synthesis for the arguments
+        args, ty, type_args = synthesize_call(self.func.ty, args, self.node, self.ctx)
+
+        # Check the index bounds (first:index expression, second: length_arg)
+        self._check_constant_index_bounds(args[self.expr_index], type_args[1])
+
+        # Return the synthesized node and type
+        node = GlobalCall(def_id=self.func.id, args=args, type_args=type_args)
+        return with_loc(self.node, node), ty
+
+
 class NewArrayChecker(CustomCallChecker):
     """Function call checker for the `array.__new__` function."""
 
@@ -251,7 +351,9 @@ class NewArrayChecker(CustomCallChecker):
                             ConstValue(nat_type(), len(args)),
                         ]
                         call = GlobalCall(
-                            def_id=self.func.id, args=args, type_args=type_args
+                            self.func.id,
+                            args,
+                            type_args,  # type: ignore[arg-type]
                         )
                         return with_loc(self.node, call), subst
             case type_args:

guppylang_internals/std/_internal/debug.py

@@ -1,6 +1,6 @@
 import ast
 from dataclasses import dataclass
-from typing import ClassVar, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from guppylang_internals.ast_util import with_loc
 from guppylang_internals.checker.core import ComptimeVariable
@@ -12,7 +12,6 @@ from guppylang_internals.checker.expr_checker import (
     synthesize_call,
 )
 from guppylang_internals.definition.custom import CustomCallChecker
-from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.diagnostic import Error
 from guppylang_internals.error import GuppyTypeError
 from guppylang_internals.nodes import GenericParamValue, PlaceNode, StateResultExpr
@@ -31,6 +30,9 @@ from guppylang_internals.tys.ty import (
     Type,
 )
 
+if TYPE_CHECKING:
+    from guppylang_internals.definition.ty import TypeDef
+
 
 class StateResultChecker(CustomCallChecker):
     """Call checker for the `state_result` function."""
@@ -63,7 +65,7 @@ class StateResultChecker(CustomCallChecker):
         from guppylang.std.quantum import qubit
 
         assert isinstance(qubit, GuppyDefinition)
-        qubit_ty = cast(TypeDef, qubit.wrapped).check_instantiate([])
+        qubit_ty = cast("TypeDef", qubit.wrapped).check_instantiate([])
 
         array_len = None
         arg, ty = ExprSynthesizer(self.ctx).synthesize(args[1])

guppylang_internals/tracing/builtins_mock.py

@@ -39,14 +39,14 @@ def _mock_meta(cls: type) -> type:
     return MockMeta
 
 
-class float(builtins.float, metaclass=_mock_meta(builtins.float)):  # type: ignore[misc]
+class float(builtins.float, metaclass=_mock_meta(builtins.float)):  # type: ignore[metaclass]
     def __new__(cls, x: Any = 0.0, /) -> Any:
         if isinstance(x, GuppyObject):
             return x.__float__()
         return builtins.float(x)
 
 
-class int(builtins.int, metaclass=_mock_meta(builtins.int)):  # type: ignore[misc]
+class int(builtins.int, metaclass=_mock_meta(builtins.int)):  # type: ignore[metaclass]
     def __new__(cls, x: Any = 0, /, *args: Any, **kwargs: Any) -> Any:
         if isinstance(x, GuppyObject):
             return x.__int__(*args, **kwargs)

guppylang_internals/tracing/object.py

@@ -347,7 +347,7 @@ class GuppyObject(DunderMixin):
         return self
 
     @hide_trace
-    def __getattr__(self, key: str) -> Any:  # type: ignore[misc]
+    def __getattr__(self, key: str) -> Any:
         # Guppy objects don't have fields (structs are treated separately below), so the
         # only attributes we have to worry about are methods.
         func = get_tracing_state().globals.get_instance_func(self._ty, key)
@@ -454,7 +454,7 @@ class GuppyStructObject(DunderMixin):
         object.__setattr__(self, "_frozen", frozen)
 
     @hide_trace
-    def __getattr__(self, key: str) -> Any:  # type: ignore[misc]
+    def __getattr__(self, key: str) -> Any:
         # It could be an attribute
         if key in self._field_values:
             return self._field_values[key]

guppylang_internals/tys/parsing.py

@@ -143,6 +143,7 @@ def arg_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Argument:
 def _try_parse_defn(node: AstNode, globals: Globals) -> Definition | None:
     """Tries to parse a (possibly qualified) name into a global definition."""
     from guppylang.defs import GuppyDefinition
+
     from guppylang_internals.checker.cfg_checker import VarNotDefinedError
 
     match node:
@@ -378,7 +379,9 @@ def type_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Type:
     """Turns an AST expression into a Guppy type."""
     ty, flags = type_with_flags_from_ast(node, ctx)
     if flags != InputFlags.NoFlags:
-        assert InputFlags.Inout not in flags  # Users shouldn't be able to set this
+        # Users shouldn't be able to set this
+        # Ignore needed for Python 3.10 mypy compatibility with Flag enums
+        assert InputFlags.Inout not in flags  # type: ignore[operator, unused-ignore]
         raise GuppyError(FlagNotAllowedError(node))
     return ty