Repository navigation
Conversation
Add an Interface template parameter to ProxyMethod, ProxyMethodTraits, ProxyClientMethodTraits and ProxyServerMethodTraits, and generate ProxyMethod specializations for inherited methods as well as each interface's own methods. This lets a wrapped capnp interface inherit methods from a base interface that is wrapped by a different C++ class, or not wrapped at all. Previously the mapping from an inherited method to a C++ method came from the base interface's generated ProxyMethod<Params> specialization, so it only worked when the base interface was wrapped by a C++ base class of the derived interface's class. Each method could only have one mapping, so two wrapped interfaces inheriting from the same unwrapped base could not each supply one. Bitcoin Core needs this to split its Chain interface into stable Chain and UnstableChain capnp interfaces wrapping the same interfaces::Chain class (bitcoin/bitcoin#34981). This is a breaking change for code specializing ProxyClientMethodTraits or ProxyServerMethodTraits, which now takes the interface type as its first template argument. This change was written with Claude Opus 5.5 (1M context).
|
The following sections might be updated with supplementary metadata relevant to reviewers and maintainers. ReviewsSee the guideline and AI policy for information on the review process.
If your review is incorrectly listed, please copy-paste ConflictsReviewers, this pull request conflicts with the following ones:
If you consider this pull request important, please also help to review the conflicting pull requests. Ideally, start with the one that should be merged first. |
enochaz
left a comment
There was a problem hiding this comment.
crACK 08f72b0
Allowing wrapped interfaces to inherit from unwrapped interfaces is a useful improvement that enables the stable/unstable Chain split in bitcoin/bitcoin@06588f7. The stable Chain interface can stand on its own as a protocol definition, while UnstableChain wraps the existing c++ interfaces::Chain class and handles the inherited methods, without requiring matching c++ inheritance.
Left a suggestion below
| // the methods it handles to its own C++ class. The interface | ||
| // declaring an inherited method may be wrapped by a different | ||
| // C++ class, or not be wrapped at all. | ||
| if (!is_construct && !is_destroy) { |
There was a problem hiding this comment.
In commit 08f72b0: mpgen: Key ProxyMethod and method traits by interface type
I was wondering what happens if the c++ subclass adds an overload of an inherited method.
FooCallback already declares call(int). I added these two lines to ExtendedCallback in test/foo.h
using FooCallback::call;
int call(double arg) { return static_cast<int>(arg); }This makes both FooCallback::call(int) and ExtendedCallback::call(double) visible through ExtendedCallback.
Previously, the inherited method used &FooCallback::call, which identifies call(int). The new mapping uses &ExtendedCallback::call, where both overloads are visible.
With these lines added mptest fails to build with:
error: unable to deduce ‘const auto’ from
‘& mp::test::ExtendedCallback::call’
Could we select the c++ class before taking the method pointer? I worked up this possible solution in gen.cpp
index e27b1d2..bb5f5ef 100644
--- i/src/mp/gen.cpp
+++ w/src/mp/gen.cpp
@@ -551,7 +551,19 @@ static void Generate(kj::StringPtr src_prefix,
methods << "template<>\n";
methods << "struct ProxyMethod<" << message_namespace << "::" << node_name << ", " << method_prefix << "Params>\n";
methods << "{\n";
- methods << " static constexpr auto impl = &" << proxied_class_type
+ kj::StringPtr method_class_type = proxied_class_type;
+ kj::StringPtr declaring_class_type;
+ if (&method_interface != &interface &&
+ GetAnnotationText(method_interface.getProto(), WRAP_ANNOTATION_ID, &declaring_class_type) &&
+ declaring_class_type.size()) {
+ // Preserve the declaring C++ base's lookup when possible,
+ // so overloads added by the derived class do not make it ambiguous.
+ methods << " using Impl = std::conditional_t<std::is_convertible_v<"
+ << proxied_class_type << "*, " << declaring_class_type << "*>, "
+ << declaring_class_type << ", " << proxied_class_type << ">;\n";
+ method_class_type = "Impl";
+ }
+ methods << " static constexpr auto impl = &" << method_class_type
<< "::" << proxied_method_name << ";\n";
methods << "};\n\n";There might be a better solution to this, but the reasoning here is that, where the receiving c++ class derives publicly and unambiguously from the declaring class, we can preserve the old base lookup. Here, Impl becomes FooCallback, avoiding the additional overload.
For unrelated c++ classes, the condition is false and we retain the receiving class’s lookup. This selection would only be emitted for inherited methods with a wrapped base and unwrapped bases keep the direct lookup.
With the proposed fix, mptest builds with the added overload. I haven’t found a current Bitcoin Core interface affected by this, and the ambiguity doesn’t arise when the inherited and added methods have distinct c++ names. But the PR does break a previously working libmultiprocess arrangement
There was a problem hiding this comment.
re: #377 (comment)
FooCallbackalready declarescall(int). I added these two lines toExtendedCallbackin test/foo.husing FooCallback::call; int call(double arg) { return static_cast<int>(arg); }
Wow this is an interesting thing to test. My first instinct is that it's good for this to trigger an error because interfaces wrapped by libmultiprocess already have a bunch of restrictions and one listed there is "Interface methods should not be overloaded" (because capnproto doesn't support method overloading, and this helps it be more language-independent).
But maybe overloading could be good to support in a derived class, and I"m thinking in particular of cases where base class may be wrapped and exposed over IPC and derived class is an unwrapped normal c++ class inheriting from some implementation of the interface. This type of class should be free to have its own methods without the same restrictions. I'm assuming this does not work today, so would not want to add support for that here, but I think the change you suggested could make sense as a followup especially if there is a motivating use-case.
There was a problem hiding this comment.
Thanks for pointing out that restriction. I hadn’t accounted for it when testing the wrapped ExtendedCallback case. Agreed that this doesn’t need to expand the scope of this PR.
I also tried the unwrapped subclass case you mentioned; a normal c++ subclass inheriting from an implementation, adding a local overload, and being passed through the wrapped base interface. That builds and passes the ipc test, so that particular arrangement already appears to work.
Problem: Currently, interface inheritance in libmultiprocess only works if capnproto base and derived interfaces both use
$Proxy.wrapannotations and have C++ base and derived classes implementing methods of both interfaces. It is currently not possible to have derived capnproto interface that uses$Proxy.wrapinherit from a base interface that is unwrapped. This is needed for the stable/unstable Chain interface split proposed in bitcoin/bitcoin#34981. This limitation exists becauseProxyMethodtemplate class which is responsible for mapping capnproto method types to c++ method pointers currently assumes that that every capnproto method will be implemented by the wrapped base interface, and doesn't allow them to be implemented be derived classes.Solution: Pass an interface type template parameter to
ProxyMethodand to theProxyMethodTraits,ProxyClientMethodTraitsandProxyServerMethodTraitstraits classes, and have mpgen generateProxyMethodspecializations for every method an interface handles, including inherited ones. Small change toproxy.h,proxy-types.handgen.cpp, plus a test of an interface inheriting from a base interface with no C++ class.This is a potentially breaking change for code that specializes
ProxyClientMethodTraitsorProxyServerMethodTraits, which now takes the interface type as its first template argument. But Bitcoin Core master does not have any of these specializations currently, so it needs no changes. Generated code is otherwise equivalent and there are no wire protocol changes.