feat!: Support static methods on types by GBoydQ · Pull Request #1699 · Quantinuum/guppylang

GBoydQ · 2026-04-28T16:18:41Z

Adds staticmethods to guppy, supporting structs and enums.

Main changes include, registering if members are staticmethods, and then checking in ExprSynthesizer.visit_Attribute if there is a staticmethod when visiting a Name.

Whether or not members are static could probably mostly be inferred from the type instead (except for the case where the first argument to the staticmethod is also of type Self).

BREAKING CHANGE: DEF_STORE.type_members now has values that also contain information about whether or not members are static.

Closes #694

maximilianruesch

Thank you for the PR, this looks really interesting. I have a bunch of suggestions. I will also request @mark-koch to provide his comments on this PR!

maximilianruesch · 2026-04-29T07:50:25Z

+@dataclass(frozen=True)
+class ImplDefinition:
+    id: DefId
+    is_static: bool


For this it is useful to inherit from NamedTuple (and remove the decorator), since you do not need the full blown features of a dataclass. It gives you lower runtime overhead and virtually the same attribute access.

maximilianruesch · 2026-04-29T08:03:27Z



+@dataclass(frozen=True)
+class ImplDefinition:


Let us call this TypeMember or TypeMemberDef. Impl... was the previous wording in this file, which was confusing.

maximilianruesch · 2026-04-29T08:10:43Z

+                if isinstance(val, GuppyDefinition) and hasattr(
+                    val.wrapped, "python_func"
+                ):


Two things:
Instead of silently failing to register if the wrapped definition has no python_func, let us fail in case it is a GuppyDefinition but we cannot determine whether the function is static or not. If the user can run into this case, it should be a proper error with a diagnostic (and an error test), if not, it can be a InternalGuppyError. This will help us debug / discover new cases where we introduce members that are GuppyDefinition, but have no function attached (for whatever reason).
We discourage hasattr checks, since they are dependent on "implementation-ish" details (characterising a class by which attribute is present), and are not hardened against refactoring changes. Furthermore, from here it is completely invisible which classes may have python_func. Instead, you should use isinstance checks to check all classes that you want to cover explicitly.

Yes the hasattr is not ideal, the problem I was facing here was that I think I originally had isinstance(..., GuppyFunctionDefinition) but mypy was not able to determine that the wrapped Definition actually contained a python_func in that case. Is there a way to ensure a GuppyFunctionDefinition contains a function?

GuppyFunctionDefinition is a subclass of GuppyDefinition, and is not the wrapped member. What you are searching for is RawFunctionDef and other similar classes.

maximilianruesch · 2026-04-29T08:12:13Z

+                if isinstance(val, GuppyDefinition) and hasattr(
+                    val.wrapped, "python_func"
+                ):


See https://github.com/Quantinuum/guppylang/pull/1699/changes#r3159470912

maximilianruesch · 2026-04-29T08:17:30Z

+            # We can only access variants of the enum from the enum class
+            # and staticmethods


For one, this comment should be on the line with the name in variants OR is a static member clause, and for another it is worded confusingly: Right now it sounds like we can access variants from [either the enum class or static methods], which does not make sense.

Instead, let us say something like

# We can only access enum variants or static methods from the enum class

maximilianruesch · 2026-04-29T08:46:37Z

We should really have a CI check for uv.lock synchronisation.

maximilianruesch · 2026-04-29T08:47:57Z

+    @guppy
+    def main() -> None:
+        t = Test.default(1.0)
+        # can call Test.default[int] from Test[float] instance


A bit counterintuitive, but reasonable in this case. Are there cases where this is not allowed?

This does seem odd but I think it makes sense, as I would expect the behaviour of staticmethods to be to ignore the instance.

We should extend the comment by saying "as static methods ignore instance types".

maximilianruesch · 2026-04-29T08:51:28Z

Can we test static guppy.declares? Perhaps with library linking?

On that note, you should check whether link name inference still works with static methods (in the link_name tests).

maximilianruesch · 2026-04-29T08:54:04Z

+    # get the wrapped function if a staticmethod
+    if isinstance(f, staticmethod):
+        f = f.__func__


The fact that the saved self.python_func is wrapped may be breaking as well (depending on if the wrapper copies or forwards key attributes such as __module__.

@mark-koch and I briefly discussed this but I would appreciate any more thoughts / discussion to make sure this is ok

Currently there is no guarantees made by the python_func about its type (because we do not have a proper type for it). However we do access things like __module__ on it, which is defined with regular functions. I guess if you add the link_name tests (and any other paths that may trigger attribute accesses) we should be fine.

We could consider storing the wrapped function directly instead of unwrapping here. That might be cleaner?

maximilianruesch · 2026-04-29T09:10:07Z

+            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


Can this fail when the thing that we are accessing on is not in globals? Can this even happen? I am confused what this does, and what all the if clauses mean. Perhaps @mark-koch has thoughts on this.

This could definitely be cleaner / wrapped up into a function.
Also the cast / isinstances were also a result of my fight with mypy due to my lack of experience with the compiler types.
Essentially I was going for, "if this is a type that has has a type_member of this name and it's static, then return the staticmethod"

I am confused in particular about the if not isinstance(defn, PythonObject):. What does it do?

Also, I guess ENGINE.get_instance_func(...) is not necessarily the right name anymore.

Let us wait for a comment from Mark on this one.

Co-authored-by: Copilot <copilot@github.com>

mark-koch · 2026-04-29T16:19:53Z

+                defn = cast("ParsedDef", self.ctx.globals[node.value.id])
+                if not isinstance(defn, PythonObject):


Suggested change

defn = cast("ParsedDef", self.ctx.globals[node.value.id])

if not isinstance(defn, PythonObject):

defn_or_python_object = self.ctx.globals[node.value.id]

if isinstance(defn_or_python_object, TypeDef):

mark-koch · 2026-04-29T16:24:48Z

+                        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


Do we actually need this static check? Imo type.func would also be fine if func is not static, similar to Python:

x = int.__add__(1, 2)

mark-koch · 2026-04-29T16:25:15Z

+            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]


It should already be ParsedDef?

mark-koch · 2026-05-05T10:09:01Z

+                    ty_def = ENGINE.parsed[defn.id]
+                    if (
+                        node.attr in DEF_STORE.type_members[ty_def.id]
+                        and isinstance(ty_def, TypeDef)


isinstance(ty_def, TypeDef) could be removed if you go with the refactor above

mark-koch · 2026-05-05T10:13:59Z

+            if (
+                impl_def := DEF_STORE.type_members[ty_id].get(node.attr)
+            ) and impl_def.is_static:


I think this would be clearer if we introduced a new ENGINE.get_type_member function that returns the TypeMember:

if member := ENGINE.get_type_member(ty, node.attr): if member.is_static: ... else: ...

mark-koch · 2026-05-05T10:20:37Z

+        # 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


What's the issue with comptime functions, I'd assume everything should just work?

I have not looked into this, but I get 'staticmethod' object has no attribute '__globals__' in mock_builtins

mark-koch · 2026-05-05T10:22:23Z

+                if not isinstance(func_def, RawFunctionDef):
+                    return False


It could also be a RawCustomFunctionDef, RawFunctionDecl, RawTracedFunctionDef, or even another OverloadedFunctionDef

mark-koch · 2026-05-05T10:24:43Z

+                    # TODO guppy error handling
+                    raise TypeError(
+                        "one of the functions in this overload is not static"
+                    )


I think a vanilla Python error is ok here since it raised while decorating, not during compilation.

However, the message could be improved a bit, for example mentioning which overload is static and which isn't. Also could you add an error test for this case?

mark-koch · 2026-05-05T10:29:21Z

+            else:
+                return False
+        case OverloadedFunctionDef():
+            # check all the methods in the overload are also static


I think the current implementation doesn't do that. You just check if any overload is static and then raise an error? I would expect something like

is_static = [determine_static(overload_id) for overload_id in defn.wrapped.func_ids] if all(is_static): return True elif not any(is_static): return False: else: raise TypeError("Some static, some not")

Note that this would refquire refactoring determine_static to take ids instead of GuppyDefinitions

Or, maybe we should just look for @staticmethod on the @guppy.overloaded function instead?

mark-koch · 2026-05-05T10:32:07Z

+    # get the wrapped function if a staticmethod
+    if isinstance(f, staticmethod):
+        f = f.__func__


We could consider storing the wrapped function directly instead of unwrapping here. That might be cleaner?

GBoydQ added 14 commits March 31, 2026 13:35

working with pre-parse

29a7895

remove pre-parse

5ed374d

comments

68b8552

convert to staticmethods

5c9a4be

dont check self on staticmethods

78f1165

Merge remote-tracking branch 'upstream/main' into gb/add_classfunctions

f1506a4

clean

2ec633c

remove unsupported

ee959de

whitespace

d522f88

start adding tests

722472c

support enums

2bddc3c

add pythonobject check

2a5c42b

clean

ee63214

revert lock to main

7f9d6ee

GBoydQ requested a review from a team as a code owner April 28, 2026 16:18

GBoydQ requested a review from maximilianruesch April 28, 2026 16:18

update lock

70a7282

maximilianruesch changed the title ~~feat: staticmethods~~ feat: Support static methods on opaque types Apr 29, 2026

maximilianruesch changed the title ~~feat: Support static methods on opaque types~~ feat: Support static methods on types Apr 29, 2026

maximilianruesch changed the title ~~feat: Support static methods on types~~ feat!: Support static methods on types Apr 29, 2026

maximilianruesch requested changes Apr 29, 2026

View reviewed changes

maximilianruesch requested a review from mark-koch April 29, 2026 09:41

GBoydQ and others added 2 commits April 30, 2026 11:00

easy review comments

4744454

WIP determine_static and support overloads

28be41f

Co-authored-by: Copilot <copilot@github.com>

mark-koch reviewed May 5, 2026

View reviewed changes

		# We can only access variants of the enum from the enum class
		# and staticmethods

		defn = cast("ParsedDef", self.ctx.globals[node.value.id])
		if not isinstance(defn, PythonObject):

Conversation

GBoydQ commented Apr 28, 2026

Uh oh!

maximilianruesch left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

maximilianruesch Apr 30, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mark-koch Apr 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

maximilianruesch Apr 30, 2026 •

edited

Loading

mark-koch Apr 29, 2026 •

edited

Loading