feat!: Support static methods on types

guppylang-internals/src/guppylang_internals/checker/expr_checker.py

@@ -28,7 +28,7 @@
 from contextlib import suppress
 from dataclasses import replace
 from types import ModuleType
-from typing import TYPE_CHECKING, Any, NoReturn
+from typing import TYPE_CHECKING, Any, NoReturn, cast
 
 from guppylang_internals.ast_util import (
     AstNode,
@@ -88,11 +88,11 @@
     UnaryOperatorNotDefinedError,
     WrongNumberOfArgsError,
 )
-from guppylang_internals.definition.common import Definition
+from guppylang_internals.definition.common import Definition, ParsedDef
 from guppylang_internals.definition.parameter import ParamDef
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.definition.value import CallableDef, ValueDef
-from guppylang_internals.engine import ENGINE
+from guppylang_internals.engine import DEF_STORE, ENGINE
 from guppylang_internals.error import (
     GuppyComptimeError,
     GuppyError,
@@ -580,7 +580,23 @@ def visit_Attribute(self, node: ast.Attribute) -> tuple[ast.expr, Type]:
             # Name can be a EnumDef only if it is in a attribute access, thus we
             # manually need to call the helper instead of relying on the standard
             # visit_Name (that is called through synthesize)
+
+            # visit node for case of staticmethods on a non-instantiated type
             ty = get_type_opt(node.value)
+            if node.value.id in self.ctx.globals:
+                defn = cast("ParsedDef", self.ctx.globals[node.value.id])
+                if not isinstance(defn, PythonObject):
+                    ty_def = ENGINE.parsed[defn.id]
+                    if (
+                        node.attr in DEF_STORE.type_members[ty_def.id]
+                        and isinstance(ty_def, TypeDef)
+                        and (func := ENGINE.get_instance_func(ty_def, node.attr))
+                        and DEF_STORE.type_members[ty_def.id][node.attr].is_static
+                    ):
+                        return with_loc(
+                            node, GlobalName(id=node.attr, def_id=func.id)
+                        ), func.ty
+
             if ty is None:
                 node.value, ty = self._check_name_id(
                     node.value.id, node.value, allow_enum=True
@@ -642,16 +658,28 @@ def visit_Attribute(self, node: ast.Attribute) -> tuple[ast.expr, Type]:
 
     def _check_method(
         self, ty: Type, node: ast.Attribute
-    ) -> tuple[PartialApply, FunctionType] | None:
+    ) -> tuple[ast.expr, FunctionType] | None:
         """Helper method to check if an attribute access corresponds to a method call"""
         if func := ENGINE.get_instance_func(ty, node.attr):
             name = with_type(
                 func.ty, with_loc(node, GlobalName(id=func.name, def_id=func.id))
             )
-            # Make a closure by partially applying the `self` argument
-            # TODO: Try to infer some type args based on `self`
-            result_ty = FunctionType(func.ty.inputs[1:], func.ty.output, func.ty.params)
-            return with_loc(node, PartialApply(func=name, args=[node.value])), result_ty
+            ty_id = DEF_STORE.type_member_parents[func.id]
+
+            if (
+                impl_def := DEF_STORE.type_members[ty_id].get(node.attr)
+            ) and impl_def.is_static:
+                # if this is a staticmethod do not partially apply `self`
+                return with_loc(node, GlobalName(id=node.attr, def_id=func.id)), func.ty
+            else:
+                # Make a closure by partially applying the `self` argument
+                # TODO: Try to infer some type args based on `self`
+                result_ty = FunctionType(
+                    func.ty.inputs[1:], func.ty.output, func.ty.params
+                )
+                return with_loc(
+                    node, PartialApply(func=name, args=[node.value])
+                ), result_ty
         else:
             return None
 

guppylang-internals/src/guppylang_internals/checker/func_checker.py

@@ -317,19 +317,22 @@ def check_signature(
             param = parse_parameter(param_node, i, globals, param_var_mapping)
             param_var_mapping[param.name] = param
 
+    is_static = False
     # Figure out if this is a method
     self_defn: TypeDef | None = None
     if def_id is not None and def_id in DEF_STORE.type_member_parents:
         self_def_id = DEF_STORE.type_member_parents[def_id]
         self_defn = cast("TypeDef", ENGINE.get_checked(self_def_id, mono_args=()))
         assert isinstance(self_defn, TypeDef)
+        # Figure out if this is a staticmethod
+        is_static = DEF_STORE.type_members[self_def_id][func_def.name].is_static
 
     inputs = []
     ctx = TypeParsingCtx(globals, param_var_mapping, allow_free_vars=True)
     for i, inp in enumerate(func_def.args.args):
-        # Special handling for `self` arguments. Note that `__new__` is excluded here
-        # since it's not a method so doesn't take `self`.
-        if self_defn and i == 0 and func_def.name != "__new__":
+        # Special handling for `self` arguments. Note that `__new__` and staticmethods
+        # are excluded here since they do not take `self`.
+        if self_defn and i == 0 and func_def.name != "__new__" and not is_static:
             input = parse_self_arg(inp, self_defn, ctx)
             ctx = replace(ctx, self_ty=input.ty)
         else:

guppylang-internals/src/guppylang_internals/decorator.py

@@ -22,11 +22,15 @@
     OpCompiler,
     RawCustomFunctionDef,
 )
+from guppylang_internals.definition.declaration import RawFunctionDecl
+from guppylang_internals.definition.function import RawFunctionDef
+from guppylang_internals.definition.overloaded import OverloadedFunctionDef
+from guppylang_internals.definition.traced import RawTracedFunctionDef
 from guppylang_internals.definition.ty import OpaqueTypeDef, TypeDef
 from guppylang_internals.definition.wasm import RawWasmFunctionDef
 from guppylang_internals.dummy_decorator import _dummy_custom_decorator, sphinx_running
 from guppylang_internals.engine import DEF_STORE
-from guppylang_internals.error import GuppyError, pretty_errors
+from guppylang_internals.error import GuppyError, InternalGuppyError, pretty_errors
 from guppylang_internals.std._internal.checker import WasmCallChecker
 from guppylang_internals.std._internal.compiler.wasm import (
     WasmModuleCallCompiler,
@@ -158,12 +162,47 @@ def extend_type(defn: TypeDef, return_class: bool = False) -> Callable[[type], t
     def dec(c: type) -> type:
         for val in c.__dict__.values():
             if isinstance(val, GuppyDefinition):
-                DEF_STORE.register_type_member(defn.id, val.wrapped.name, val.id)
+                DEF_STORE.register_type_member(
+                    defn.id, val.wrapped.name, val.id, is_static=determine_static(val)
+                )
         return c if return_class else GuppyDefinition(defn)  # type: ignore[return-value]
 
     return dec
 
 
+def determine_static(defn: GuppyDefinition) -> bool:
+    """If defn corresponds to a function, check if it is static."""
+    if not isinstance(defn, GuppyFunctionDefinition):
+        return False
+    match defn.wrapped:
+        case RawFunctionDef() | RawCustomFunctionDef() | RawFunctionDecl():
+            return isinstance(defn.wrapped.python_func, staticmethod)
+        # comptime methods not yet supported
+        case RawTracedFunctionDef():
+            if isinstance(defn.wrapped.python_func, staticmethod):
+                # TODO guppy error handling
+                raise TypeError("static comptime func")
+            else:
+                return False
+        case OverloadedFunctionDef():
+            # check all the methods in the overload are also static
+            for func_id in defn.wrapped.func_ids:
+                func_def = DEF_STORE.raw_defs[func_id]
+                if not isinstance(func_def, RawFunctionDef):
+                    return False
+                if not isinstance(func_def.python_func, staticmethod):
+                    # TODO guppy error handling
+                    raise TypeError(
+                        "one of the functions in this overload is not static"
+                    )
+            return True
+        case _:
+            raise InternalGuppyError(
+                f"Cannot determine staticness of GuppyFunctionDefinition wrapping \
+                {type(defn.wrapped)}"
+            )
+
+
 def custom_type(
     hugr_ty: ht.Type | Callable[[Sequence[Argument], CompilerContext], ht.Type],
     name: str = "",
@@ -202,7 +241,9 @@ def dec(c: type[T]) -> type[T]:
         DEF_STORE.register_def(defn, get_calling_frame())
         for val in c.__dict__.values():
             if isinstance(val, GuppyDefinition):
-                DEF_STORE.register_type_member(defn.id, val.wrapped.name, val.id)
+                DEF_STORE.register_type_member(
+                    defn.id, val.wrapped.name, val.id, is_static=determine_static(val)
+                )
         # We're pretending to return the class unchanged, but in fact we return
         # a `GuppyDefinition` that handles the comptime logic
         return GuppyDefinition(defn)  # type: ignore[return-value]
@@ -300,7 +341,10 @@ def dec(cls: builtins.type[T]) -> GuppyDefinition:
             for val in cls.__dict__.values():
                 if isinstance(val, GuppyDefinition):
                     DEF_STORE.register_type_member(
-                        ext_module.id, val.wrapped.name, val.id
+                        ext_module.id,
+                        val.wrapped.name,
+                        val.id,
+                        is_static=determine_static(val),
                     )
                     wasm_def: RawWasmFunctionDef
                     if isinstance(val, GuppyFunctionDefinition) and isinstance(

guppylang-internals/src/guppylang_internals/definition/function.py

@@ -325,6 +325,9 @@ def compile_call(
 
 
 def parse_py_func(f: PyFunc, sources: SourceMap) -> tuple[ast.FunctionDef, str | None]:
+    # get the wrapped function if a staticmethod
+    if isinstance(f, staticmethod):
+        f = f.__func__
     source_lines, line_offset = inspect.getsourcelines(f)
     source, func_ast, line_offset = parse_source(source_lines, line_offset)
     file = inspect.getsourcefile(f)

guppylang-internals/src/guppylang_internals/engine.py

@@ -3,7 +3,7 @@
 from contextlib import suppress
 from dataclasses import dataclass
 from types import FrameType
-from typing import ClassVar, cast
+from typing import ClassVar, NamedTuple, cast
 
 import hugr
 import hugr.build.function as hf
@@ -102,6 +102,11 @@
 MonoDefId = tuple[DefId, Inst]
 
 
+class TypeMember(NamedTuple):
+    id: DefId
+    is_static: bool
+
+
 class DefinitionStore:
     """Storage class holding references to all Guppy definitions created in the current
     interpreter session.
@@ -110,7 +115,7 @@ class DefinitionStore:
     """
 
     raw_defs: dict[DefId, RawDef]
-    type_members: defaultdict[DefId, dict[str, DefId]]
+    type_members: defaultdict[DefId, dict[str, TypeMember]]
     type_member_parents: dict[DefId, DefId]
     wasm_functions: dict[DefId, FunctionType]
     frames: dict[DefId, FrameType]
@@ -128,9 +133,11 @@ def register_def(self, defn: RawDef, frame: FrameType) -> None:
         self.raw_defs[defn.id] = defn
         self.frames[defn.id] = frame
 
-    def register_type_member(self, ty_id: DefId, name: str, member_id: DefId) -> None:
+    def register_type_member(
+        self, ty_id: DefId, name: str, member_id: DefId, *, is_static: bool = False
+    ) -> None:
         assert member_id not in self.type_member_parents, "Already a type member"
-        self.type_members[ty_id][name] = member_id
+        self.type_members[ty_id][name] = TypeMember(member_id, is_static)
         self.type_member_parents[member_id] = ty_id
         # Update the frame of the definition to the frame of the defining class
         if member_id in self.frames:
@@ -362,7 +369,7 @@ def get_instance_func(self, ty: Type | TypeDef, name: str) -> CallableDef | None
             type_defn.id in DEF_STORE.type_members
             and name in DEF_STORE.type_members[type_defn.id]
         ):
-            def_id = DEF_STORE.type_members[type_defn.id][name]
+            def_id = DEF_STORE.type_members[type_defn.id][name].id
             defn = ENGINE.get_parsed(def_id)
             if isinstance(defn, CallableDef):
                 return defn

guppylang-internals/src/guppylang_internals/tracing/object.py

@@ -559,9 +559,9 @@ def __call__(self, *args: Any) -> Any:
             # Definition is non-generic, so we can use `mono_args=()` here
             defn = ENGINE.get_checked(self.wrapped.id, mono_args=())
             if isinstance(defn, TypeDef) and (
-                constructor_id := DEF_STORE.type_members[defn.id].get("__new__")
+                constructor_def := DEF_STORE.type_members[defn.id].get("__new__")
             ):
-                return TracingDefMixin(DEF_STORE.raw_defs[constructor_id])(*args)
+                return TracingDefMixin(DEF_STORE.raw_defs[constructor_def.id])(*args)
         err = f"{defn.description.capitalize()} `{defn.name}` is not callable"
         raise GuppyComptimeError(err)
 
@@ -608,7 +608,7 @@ def to_guppy_object(self) -> GuppyObject:
                 and "__new__" in DEF_STORE.type_members[defn.id]
             ):
                 constructor = DEF_STORE.raw_defs[
-                    DEF_STORE.type_members[defn.id]["__new__"]
+                    DEF_STORE.type_members[defn.id]["__new__"].id
                 ]
                 return TracingDefMixin(constructor).to_guppy_object()
         err = f"{defn.description.capitalize()} `{defn.name}` is not a value"

guppylang/src/guppylang/decorator.py

@@ -12,6 +12,7 @@
 from guppylang_internals.decorator import (
     custom_function,
     custom_type,
+    determine_static,
     hugr_op,
 )
 from guppylang_internals.definition.common import DefId
@@ -247,7 +248,12 @@ def decorator(
             DEF_STORE.register_def(defn, frame)
             for val in cls.__dict__.values():
                 if isinstance(val, GuppyDefinition):
-                    DEF_STORE.register_type_member(defn.id, val.wrapped.name, val.id)
+                    DEF_STORE.register_type_member(
+                        defn.id,
+                        val.wrapped.name,
+                        val.id,
+                        is_static=determine_static(val),
+                    )
             # Prior to Python 3.13, the `__firstlineno__` attribute on classes is not
             # set. However, we need this information to precisely look up the source for
             # the class later. If it's not there, we can set it from the calling frame:
@@ -291,7 +297,12 @@ def decorator(
             DEF_STORE.register_def(defn, frame)
             for val in cls.__dict__.values():
                 if isinstance(val, GuppyDefinition):
-                    DEF_STORE.register_type_member(defn.id, val.wrapped.name, val.id)
+                    DEF_STORE.register_type_member(
+                        defn.id,
+                        val.wrapped.name,
+                        val.id,
+                        is_static=determine_static(val),
+                    )
             # Prior to Python 3.13, the `__firstlineno__` attribute on classes is not
             # set. However, we need this information to precisely look up the source for
             # the class later. If it's not there, we can set it from the calling frame:

guppylang/src/guppylang/defs.py

@@ -104,13 +104,13 @@ def __getattr__(self, name: str) -> Any:
         defn = ENGINE.get_checked(self.wrapped.id, mono_args=())
         assert isinstance(defn, CheckedEnumDef)
         if (
-            # We can only access the variants of the enum from the enum class,
-            # not methods
-            name in defn.variants
-            and defn.id in DEF_STORE.type_members
+            # We can only access enum variants or static methods from the enum class
+            defn.id in DEF_STORE.type_members
             and name in DEF_STORE.type_members[defn.id]
+        ) and (
+            name in defn.variants or DEF_STORE.type_members[defn.id][name].is_static
         ):
-            member_def = DEF_STORE.raw_defs[DEF_STORE.type_members[defn.id][name]]
+            member_def = DEF_STORE.raw_defs[DEF_STORE.type_members[defn.id][name].id]
             return TracingDefMixin(member_def)
         raise AttributeError(
             f"{defn.description.capitalize()} `{defn.name}` has no attribute `{name}`"

guppylang/src/guppylang/std/builtins.py

@@ -75,7 +75,6 @@
     setattr,
     slice,
     sorted,
-    staticmethod,
     sum,
     super,
     type,

guppylang/src/guppylang/std/unsupported.py

@@ -205,10 +205,6 @@ def slice(x): ...
 def sorted(x): ...
 
 
-@custom_function(checker=UnsupportedChecker(), higher_order_value=False)
-def staticmethod(x): ...
-
-
 @custom_function(checker=UnsupportedChecker(), higher_order_value=False)
 def sum(x): ...