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, enums and protocols.

Functions are checked for staticness during parsing, and ParsedDefinitions now have an is_static flag.

ExprSynthesizer.visit_Attribute contains logic for calling staticmethods on instantiated types (we need to not partially apply self) and Names both for globals and generic parameters.

Comptime staticmethods are not yet supported, and work still needs to be done to support Self output for staticmethods generally.

LLM disclosure: commit 1e3486b to refactor the location of determine_static was generated by LLM and checked by me, any mistakes are my own.

BREAKING CHANGE:
remove staticmethod from unsupported

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.

Thank you this was very helpful. Logic for different FunctionDef types is now wrapped up in determine_static

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).

I have added a test for library linking and another one to 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?

I am not 100% sure what you mean here.
Are you saying that on decoration we should instead store .__func__ so that the stored py_func is always a function?
I can change this, although it would also require reworking determine_static as I'm not sure there would still be a way to check if a function is static without the decorator being stored in the Definition.

What we can probably do is let the RawFunctionDef take the wrapped function, and upon calling parse, the function is determined to be static or not (and this information will be available on the ParsedFunctionDef, perhaps via a new property, and unwrapped once (if appropriate) to be passed into parse_py_func.

@mark-koch is that roughly what you envisioned? I see no cleaner way to lift the static check without adding factory methods for RawFunctionDef and replacing all of its instantiations.

Hmm I think the best place to store whether the function was static or not would be inside GuppyFunctionDefinition. That is the object we have at hand when you try to register functions in the DEF_STORE which is the point at which you need to know if it's static or not

ok fair enough, the reason I did not do this initially was that I didn't want method information to be stored in functions that are not methods, but in hindsight it would probably simplify things a bit.

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.

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

I was able to make most of the changes in this area but this one didn't work

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: ...

I have introduced this although I still need to use ENGINE.get_instance_func or ENGINE.get_parsed and then cast / check the type is a CallableDef.
I could wrap up get_instance_func and get_type_member into one function that returns both if that would be helpful.

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 · 2026-07-27T11:07:25Z

Apologies for this becoming stale, I have reworked this for v1 and also made some small changes to support protocols.
Other than that, I had to move some things round due to restructuring of the codebase (in particular I could not find a good place for determine_static that did not cause circular imports).

I am happy to either move the gb/add_classmethods branch onto these new changes or to create a new PR, whichever is preferable.

The only piece of review feedback I have not addressed is "We could consider storing the wrapped function directly instead of unwrapping here" because I wanted some clarification there.

maximilianruesch · 2026-07-27T14:10:38Z

@GBoydQ no worries!

I am happy to either move the gb/add_classmethods branch onto these new changes or to create a new PR, whichever is preferable.

Surely you mean your current branch gb/add_classfunctions. But I would suggest you move your current branch to the new changes, if the current reviews would still apply. If they do not, and you would prefer a fresh review (that is unbiased by existing reviews) you may open a new PR. But it does not sound like that is the case here.

The only piece of review feedback I have not addressed is "We could consider storing the wrapped function directly instead of unwrapping here" because I wanted some clarification there.

I will shortly comment with some clarifications. Edit: See #1699 (comment).

maximilianruesch · 2026-07-28T10:29:42Z

@GBoydQ I would not classify this as a breaking change. Adding a feature which was previously unsupported is not breaking, since previous user code did not compile anyways. Furthermore, users should not rely on features remaining to be unsupported.

GBoydQ · 2026-07-28T12:47:26Z

@GBoydQ I would not classify this as a breaking change. Adding a feature which was previously unsupported is not breaking, since previous user code did not compile anyways. Furthermore, users should not rely on features remaining to be unsupported.

I agree, however semver complained at me about this when I removed the previous breaking change by addressing your comments, I will look into it

maximilianruesch · 2026-07-28T13:01:35Z

We recently adjusted the breaking changes check to not warn on breaks in the guppylang_internals interface anymore, since we consider every version bump of that package breaking. Thus, ! now actually corresponds to behavioural breaks that a user of only guppylang can observe.

GBoydQ · 2026-07-29T16:15:51Z

I have refactored to instead determine staticness during parsing and store it on parsed definitions as you've suggested, and also added support for comptime staticmethods.

The remaining failing test I had initially thought was a type inference error similar to ones that I had seen 'in the wild', but now think that it may be due to the fact that I am not calling _instantiate_self on protocol staticmethods.

I was experimenting with Self args a little (kind of necessary for protocol staticmethods to be useful), but I would prefer not to make this PR any larger + I do not understand func_checker and protocol_checker well enough to know the consequences of changes I would make there.

I would appreciate your thoughts, one possible option for now might be to not support staticmethods on protocols with type args.

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

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

mark-koch reviewed May 5, 2026

View reviewed changes

GBoydQ force-pushed the gb/add_classfunctions branch 2 times, most recently from d27f852 to 1a75c10 Compare July 28, 2026 08:46

GBoydQ changed the title ~~feat!: Support static methods on types~~ feat: Support static methods on types Jul 28, 2026

GBoydQ changed the title ~~feat: Support static methods on types~~ feat!: Support static methods on types Jul 28, 2026

maximilianruesch changed the title ~~feat!: Support static methods on types~~ feat: Support static methods on types Jul 28, 2026

maximilianruesch changed the title ~~feat: Support static methods on types~~ feat!: Support static methods on types Jul 28, 2026

GBoydQ added 11 commits July 29, 2026 13:02

add TypeMember and staticmethod tests

795333b

readd staticmethods

22af531

remove fixed enum error test and change error for another

1897056

add link_name and overload tests

2c8d0ba

remove unsupported

7f7dfcf

add TypeMember to protocol def

3fe767f

support protocols

a38c4af

fix link name test

fc109a3

improve staticmethod tests

de94e50

format

030374d

old review comments

52f96ad

GBoydQ added 8 commits July 29, 2026 13:02

store is_static in ParsedDefs

69832b2

remove storing is_static in TypeMember

fa57b41

move determine_static

6187e69

fix determine_static mypy error

390d941

add is_static to check_signature to fix parsing recursion

c62ea39

readd overload error

ea21428

make overloaderror a guppyerror

3ab78b4

support comptime staticmethods

81156f5

GBoydQ force-pushed the gb/add_classfunctions branch from 1a75c10 to 81156f5 Compare July 29, 2026 16:07

		# 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):

Uh oh!

Conversation

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

Uh oh!

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!

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!

GBoydQ commented Apr 28, 2026 •

edited

Loading

maximilianruesch Apr 30, 2026 •

edited

Loading

mark-koch Apr 29, 2026 •

edited

Loading

maximilianruesch commented Jul 27, 2026 •

edited

Loading

GBoydQ commented Jul 29, 2026 •

edited

Loading