mpgen: support primitive std::optional struct fields

Currently optional primitive fields like `std::optional<int>` are not well
supported as struct members.

Non-primitive optional fields like `std::optional<std::string>` and optional
struct fields are well-supported because Cap'n Proto allows non-primitive
fields to be unset, but primitive fields are always considered set so there is
natural way to represent null values.

Libmultiprocess does already support primitive optional method parameters and
result values, by allowing the .capnp files to declare extra boolean parameters
prefixed with "has" and treating the extra boolean parameters as indicators of
whether options are set or unset. This commit just this functionality to work
for struct members as well.

For example a C++ `std::optional<int> param` parameter can be represented by
'param :Int32, hasParam :Bool` parameters in a .capnp file and libmultiprocess
will use both Cap'n Proto fields together to represent the C++ value. Now C++
struct fields can be represented the same way (see unit changes test for an
example).

Author: ryanofsky

src/mp/gen.cpp

@@ -411,6 +411,13 @@ static void Generate(kj::StringPtr src_prefix,
 
         if (node.getProto().isStruct()) {
             const auto& struc = node.asStruct();
+
+            FieldList fields;
+            for (const auto schema_field : struc.getFields()) {
+                fields.addField(schema_field, true);
+            }
+            fields.mergeFields();
+
             std::ostringstream generic_name;
             generic_name << node_name;
             dec << "template<";
@@ -431,22 +438,23 @@ static void Generate(kj::StringPtr src_prefix,
             dec << "struct ProxyStruct<" << message_namespace << "::" << generic_name.str() << ">\n";
             dec << "{\n";
             dec << "    using Struct = " << message_namespace << "::" << generic_name.str() << ";\n";
-            for (const auto field : struc.getFields()) {
-                auto field_name = field.getProto().getName();
+            for (const auto& field : fields.fields) {
+                if (field.skip) continue;
+                auto field_name = field.param.getProto().getName();
                 add_accessor(field_name);
                 dec << "    using " << Cap(field_name) << "Accessor = Accessor<" << base_name
                     << "_fields::" << Cap(field_name) << ", FIELD_IN | FIELD_OUT";
-                if (BoxedType(field.getType())) dec << " | FIELD_BOXED";
+                if (field.optional) dec << " | FIELD_OPTIONAL";
+                if (field.requested) dec << " | FIELD_REQUESTED";
+                if (BoxedType(field.param.getType())) dec << " | FIELD_BOXED";
                 dec << ">;\n";
             }
             dec << "    using Accessors = std::tuple<";
             size_t i = 0;
-            for (const auto field : struc.getFields()) {
-                if (AnnotationExists(field.getProto(), SKIP_ANNOTATION_ID)) {
-                    continue;
-                }
+            for (const auto& field : fields.fields) {
+                if (field.skip) continue;
                 if (i) dec << ", ";
-                dec << Cap(field.getProto().getName()) << "Accessor";
+                dec << Cap(field.param.getProto().getName()) << "Accessor";
                 ++i;
             }
             dec << ">;\n";
@@ -460,13 +468,11 @@ static void Generate(kj::StringPtr src_prefix,
                 inl << "public:\n";
                 inl << "    using Struct = " << message_namespace << "::" << node_name << ";\n";
                 size_t i = 0;
-                for (const auto field : struc.getFields()) {
-                    if (AnnotationExists(field.getProto(), SKIP_ANNOTATION_ID)) {
-                        continue;
-                    }
-                    auto field_name = field.getProto().getName();
+                for (const auto& field : fields.fields) {
+                    if (field.skip) continue;
+                    auto field_name = field.param.getProto().getName();
                     auto member_name = field_name;
-                    GetAnnotationText(field.getProto(), NAME_ANNOTATION_ID, &member_name);
+                    GetAnnotationText(field.param.getProto(), NAME_ANNOTATION_ID, &member_name);
                     inl << "    static decltype(auto) get(std::integral_constant<size_t, " << i << ">) { return "
                         << "&" << proxied_class_type << "::" << member_name << "; }\n";
                     ++i;

test/mp/test/foo-types.h

@@ -19,6 +19,7 @@
 #include <mp/type-map.h>
 #include <mp/type-message.h>
 #include <mp/type-number.h>
+#include <mp/type-optional.h>
 #include <mp/type-set.h>
 #include <mp/type-string.h>
 #include <mp/type-struct.h>

test/mp/test/foo.capnp

@@ -53,6 +53,8 @@ struct FooStruct $Proxy.wrap("mp::test::FooStruct") {
     name @0 :Text;
     setint @1 :List(Int32);
     vbool @2 :List(Bool);
+    optionalInt @3 :Int32 $Proxy.name("optional_int");
+    hasOptionalInt @4 :Bool;
 }
 
 struct FooCustom $Proxy.wrap("mp::test::FooCustom") {

test/mp/test/foo.h

@@ -9,6 +9,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <set>
 #include <vector>
@@ -21,6 +22,7 @@ struct FooStruct
     std::string name;
     std::set<int> setint;
     std::vector<bool> vbool;
+    std::optional<int> optional_int;
 };
 
 enum class FooEnum : uint8_t { ONE = 1, TWO = 2, };

test/mp/test/test.cpp

@@ -141,6 +141,7 @@ KJ_TEST("Call FooInterface methods")
     in.vbool.push_back(false);
     in.vbool.push_back(true);
     in.vbool.push_back(false);
+    in.optional_int = 3;
     FooStruct out = foo->pass(in);
     KJ_EXPECT(in.name == out.name);
     KJ_EXPECT(in.setint.size() == out.setint.size());
@@ -151,6 +152,12 @@ KJ_TEST("Call FooInterface methods")
     for (size_t i = 0; i < in.vbool.size(); ++i) {
         KJ_EXPECT(in.vbool[i] == out.vbool[i]);
     }
+    KJ_EXPECT(in.optional_int == out.optional_int);
+
+    // Additional checks for std::optional member
+    KJ_EXPECT(foo->pass(in).optional_int == 3);
+    in.optional_int.reset();
+    KJ_EXPECT(!foo->pass(in).optional_int);
 
     FooStruct err;
     try {