Interface code generation. Also update method grammar to allow multiple…

Interface code generation.  Also update method grammar to allow multiple returns, and allow specifying request/response structs instead of parameter lists.

c++/src/capnp/arena.c++

@@ -106,7 +106,7 @@ namespace {
 
 class DummyClientHook final: public ClientHook {
 public:
-  Request<ObjectPointer, TypelessAnswer> newCall(
+  Request<ObjectPointer, TypelessResults> newCall(
       uint64_t interfaceId, uint16_t methodId) const override {
     KJ_FAIL_REQUIRE("Calling capability that was extracted from a message that had no "
                     "capability context.");

c++/src/capnp/capability.c++

@@ -22,10 +22,35 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "capability.h"
+#include <kj/debug.h>
 
 namespace capnp {
 
-TypelessAnswer::Pipeline TypelessAnswer::Pipeline::getPointerField(
+kj::Promise<void> Capability::Server::internalUnimplemented(
+    const char* actualInterfaceName, uint64_t requestedTypeId) {
+  KJ_FAIL_REQUIRE("Requested interface not implemented.", actualInterfaceName, requestedTypeId) {
+    // Recoverable exception will be caught by promise framework.
+    return kj::READY_NOW;
+  }
+}
+
+kj::Promise<void> Capability::Server::internalUnimplemented(
+    const char* interfaceName, uint64_t typeId, uint16_t methodId) {
+  KJ_FAIL_REQUIRE("Method not implemented.", interfaceName, typeId, methodId) {
+    // Recoverable exception will be caught by promise framework.
+    return kj::READY_NOW;
+  }
+}
+
+kj::Promise<void> Capability::Server::internalUnimplemented(
+    const char* interfaceName, const char* methodName, uint64_t typeId, uint16_t methodId) {
+  KJ_FAIL_REQUIRE("Method not implemented.", interfaceName, typeId, methodName, methodId) {
+    // Recoverable exception will be caught by promise framework.
+    return kj::READY_NOW;
+  }
+}
+
+TypelessResults::Pipeline TypelessResults::Pipeline::getPointerField(
     uint16_t pointerIndex) const {
   auto newOps = kj::heapArray<PipelineOp>(ops.size() + 1);
   for (auto i: kj::indices(ops)) {

c++/src/capnp/compiler/capnpc-capnp.c++

@@ -175,11 +175,11 @@ private:
       case schema::Type::LIST:
         return kj::strTree("List(", genType(type.getList().getElementType(), scope), ")");
       case schema::Type::ENUM:
-        return nodeName(scope.getDependency(type.getEnum().getTypeId()), scope);
+        return nodeName(schemaLoader.get(type.getEnum().getTypeId()), scope);
       case schema::Type::STRUCT:
-        return nodeName(scope.getDependency(type.getStruct().getTypeId()), scope);
+        return nodeName(schemaLoader.get(type.getStruct().getTypeId()), scope);
       case schema::Type::INTERFACE:
-        return nodeName(scope.getDependency(type.getInterface().getTypeId()), scope);
+        return nodeName(schemaLoader.get(type.getInterface().getTypeId()), scope);
       case schema::Type::OBJECT: return kj::strTree("Object");
     }
     return kj::strTree();
@@ -262,7 +262,7 @@ private:
       }
       case schema::Value::ENUM: {
         KJ_REQUIRE(type.isEnum(), "type/value mismatch");
-        auto enumNode = scope.getDependency(type.getEnum().getTypeId()).asEnum().getProto();
+        auto enumNode = schemaLoader.get(type.getEnum().getTypeId()).asEnum().getProto();
         auto enumerants = enumNode.getEnum().getEnumerants();
         KJ_REQUIRE(value.getEnum() < enumerants.size(),
                 "Enum value out-of-range.", value.getEnum(), enumNode.getDisplayName());
@@ -271,7 +271,7 @@ private:
       case schema::Value::STRUCT: {
         KJ_REQUIRE(type.isStruct(), "type/value mismatch");
         auto structValue = value.getStruct().getAs<DynamicStruct>(
-            scope.getDependency(type.getStruct().getTypeId()).asStruct());
+            schemaLoader.get(type.getStruct().getTypeId()).asStruct());
         return kj::strTree(structValue);
       }
       case schema::Value::INTERFACE: {
@@ -386,7 +386,7 @@ private:
             "\n");
       }
       case schema::Field::GROUP: {
-        auto group = scope.getDependency(field.getGroup().getTypeId()).asStruct();
+        auto group = schemaLoader.get(field.getGroup().getTypeId()).asStruct();
         return kj::strTree(
             indent, field.getName(),
             " :group", genAnnotations(field.getAnnotations(), scope), " {",
@@ -400,6 +400,25 @@ private:
     return kj::strTree();
   }
 
+  kj::StringTree genParamList(InterfaceSchema interface, StructSchema schema) {
+    if (schema.getProto().getScopeId() == 0) {
+      // A named parameter list.
+      return kj::strTree("(", kj::StringTree(
+          KJ_MAP(field, schema.getFields()) {
+            auto proto = field.getProto();
+            auto slot = proto.getSlot();
+
+            return kj::strTree(
+                proto.getName(), " :", genType(slot.getType(), interface),
+                isEmptyValue(slot.getDefaultValue()) ? kj::strTree("") :
+                    kj::strTree(" = ", genValue(
+                        slot.getType(), slot.getDefaultValue(), interface)));
+          }, ", "), ")");
+    } else {
+      return nodeName(schema, interface);
+    }
+  }
+
   kj::StringTree genDecl(Schema schema, Text::Reader name, uint64_t scopeId, Indent indent) {
     auto proto = schema.getProto();
     if (proto.getScopeId() != scopeId) {
@@ -439,28 +458,17 @@ private:
             indent, "}\n");
       }
       case schema::Node::INTERFACE: {
+        auto interface = schema.asInterface();
         return kj::strTree(
             indent, "interface ", name, " @0x", kj::hex(proto.getId()),
             genAnnotations(schema), " {\n",
-            KJ_MAP(method, sortByCodeOrder(schema.asInterface().getMethods())) {
-              int i = 0;
+            KJ_MAP(method, sortByCodeOrder(interface.getMethods())) {
               auto methodProto = method.getProto();
+              auto params = schemaLoader.get(methodProto.getParamStructType()).asStruct();
+              auto results = schemaLoader.get(methodProto.getResultStructType()).asStruct();
               return kj::strTree(
-                  indent.next(), methodProto.getName(), " @", method.getIndex(), "(",
-                  KJ_MAP(param, methodProto.getParams()) {
-                    bool hasDefault = i >= methodProto.getRequiredParamCount() ||
-                        !isEmptyValue(param.getDefaultValue());
-                    return kj::strTree(
-                        i++ > 0 ? ", " : "",
-                        param.getName(), ": ", genType(param.getType(), schema),
-                        hasDefault
-                            ? kj::strTree(" = ", genValue(
-                                param.getType(), param.getDefaultValue(), schema))
-                            : kj::strTree(),
-                        genAnnotations(param.getAnnotations(), schema));
-                  },
-                  ") :", genType(methodProto.getReturnType(), schema),
-                  genAnnotations(methodProto.getAnnotations(), schema), ";\n");
+                  indent.next(), methodProto.getName(), " @", method.getIndex(), " ",
+                  genParamList(interface, params), " -> ", genParamList(interface, results), ";\n");
             },
             genNestedDecls(schema, indent.next()),
             indent, "}\n");

c++/src/capnp/compiler/compiler.c++

@@ -199,7 +199,8 @@ private:
   void traverseAnnotations(const List<schema::Annotation>::Reader& annotations, uint eagerness,
                            std::unordered_map<const Node*, uint>& seen) const;
   void traverseDependency(uint64_t depId, uint eagerness,
-                          std::unordered_map<const Node*, uint>& seen) const;
+                          std::unordered_map<const Node*, uint>& seen,
+                          bool ignoreIfNotFound = false) const;
   // Helpers for traverse().
 };
 
@@ -730,11 +731,8 @@ void Compiler::Node::traverseNodeDependencies(
         }
       }
       for (auto method: interface.getMethods()) {
-        for (auto param: method.getParams()) {
-          traverseType(param.getType(), eagerness, seen);
-          traverseAnnotations(param.getAnnotations(), eagerness, seen);
-        }
-        traverseType(method.getReturnType(), eagerness, seen);
+        traverseDependency(method.getParamStructType(), eagerness, seen, true);
+        traverseDependency(method.getResultStructType(), eagerness, seen, true);
         traverseAnnotations(method.getAnnotations(), eagerness, seen);
       }
       break;
@@ -771,10 +769,11 @@ void Compiler::Node::traverseType(const schema::Type::Reader& type, uint eagerne
 }
 
 void Compiler::Node::traverseDependency(uint64_t depId, uint eagerness,
-                                        std::unordered_map<const Node*, uint>& seen) const {
+                                        std::unordered_map<const Node*, uint>& seen,
+                                        bool ignoreIfNotFound) const {
   KJ_IF_MAYBE(node, module->getCompiler().findNode(depId)) {
     node->traverse(eagerness, seen);
-  } else {
+  } else if (!ignoreIfNotFound) {
     KJ_FAIL_ASSERT("Dependency ID not present in compiler?", depId);
   }
 }
@@ -872,14 +871,31 @@ static void findImports(Declaration::Reader decl, std::set<kj::StringPtr>& outpu
       break;
     case Declaration::METHOD: {
       auto method = decl.getMethod();
-      for (auto param: method.getParams()) {
+
+      auto params = method.getParams();
+      if (params.isNamedList()) {
+        for (auto param: params.getNamedList()) {
           findImports(param.getType(), output);
           for (auto ann: param.getAnnotations()) {
             findImports(ann.getName(), output);
           }
         }
-      if (method.getReturnType().isExpression()) {
-        findImports(method.getReturnType().getExpression(), output);
+      } else {
+        findImports(params.getType(), output);
+      }
+
+      if (method.getResults().isExplicit()) {
+        auto results = method.getResults().getExplicit();
+        if (results.isNamedList()) {
+          for (auto param: results.getNamedList()) {
+            findImports(param.getType(), output);
+            for (auto ann: param.getAnnotations()) {
+              findImports(ann.getName(), output);
+            }
+          }
+        } else {
+          findImports(results.getType(), output);
+        }
       }
       break;
     }

c++/src/capnp/compiler/grammar.capnp

@@ -170,10 +170,10 @@ struct Declaration {
       extends @21 :List(DeclName);
     }
     method :group {
-      params @22 :List(Param);
-      returnType :union {
+      params @22 :ParamList;
+      results :union {
         none @23 :Void;
-        expression @24 :TypeExpression;
+        explicit @24 :ParamList;
       }
     }
 
@@ -221,6 +221,19 @@ struct Declaration {
     builtinObject @55 :Void;
   }
 
+  struct ParamList {
+    # A list of method parameters or method returns.
+
+    union {
+      namedList @0 :List(Param);
+
+      type @1 :DeclName;
+      # Specified some other struct type instead of a named list.
+    }
+
+    startByte @2 :UInt32;
+    endByte @3 :UInt32;
+  }
   struct Param {
     name @0 :LocatedText;  # If null, param failed to parse.
     type @1 :TypeExpression;
@@ -229,6 +242,9 @@ struct Declaration {
       none @3 :Void;
       value @4 :ValueExpression;
     }
+
+    startByte @5 :UInt32;
+    endByte @6 :UInt32;
   }
 }
 

c++/src/capnp/compiler/node-translator.h

@@ -90,7 +90,7 @@ public:
     kj::Array<schema::Node::Reader> auxNodes;
     // Auxiliary nodes that were produced when translating this node and should be loaded along
     // with it.  In particular, structs that contain groups (or named unions) spawn extra nodes
-    // representing those.
+    // representing those, and interfaces spawn struct nodes representing method params/results.
   };
 
   NodeSet getBootstrapNode();
@@ -119,6 +119,9 @@ private:
   // If this is a struct node and it contains groups, these are the nodes for those groups,  which
   // must be loaded together with the top-level node.
 
+  kj::Vector<Orphan<schema::Node>> paramStructs;
+  // If this is an interface, these are the auto-generated structs representing params and results.
+
   struct UnfinishedValue {
     ValueExpression::Reader source;
     schema::Type::Reader type;
@@ -151,6 +154,10 @@ private:
   // The `members` arrays contain only members with ordinal numbers, in code order.  Other members
   // are handled elsewhere.
 
+  uint64_t compileParamList(kj::StringPtr methodName, uint16_t ordinal, bool isResults,
+                            Declaration::ParamList::Reader paramList);
+  // Compile a param (or result) list and return the type ID of the struct type.
+
   bool compileType(TypeExpression::Reader source, schema::Type::Builder target);
   // Returns false if there was a problem, in which case value expressions of this type should
   // not be parsed.

c++/src/capnp/compiler/parser.c++

@@ -95,6 +95,33 @@ uint64_t generateGroupId(uint64_t parentId, uint16_t groupIndex) {
   return result | (1ull << 63);
 }
 
+uint64_t generateMethodParamsId(uint64_t parentId, uint16_t methodOrdinal, bool isResults) {
+  // Compute ID by MD5 hashing the concatenation of the parent ID, the method ordinal, and a
+  // boolean indicating whether this is the params or the results, and then taking the first 8
+  // bytes.
+
+  kj::byte bytes[sizeof(uint64_t) + sizeof(uint16_t) + 1];
+  for (uint i = 0; i < sizeof(uint64_t); i++) {
+    bytes[i] = (parentId >> (i * 8)) & 0xff;
+  }
+  for (uint i = 0; i < sizeof(uint16_t); i++) {
+    bytes[sizeof(uint64_t) + i] = (methodOrdinal >> (i * 8)) & 0xff;
+  }
+  bytes[sizeof(bytes) - 1] = isResults;
+
+  Md5 md5;
+  md5.update(bytes);
+
+  kj::ArrayPtr<const kj::byte> resultBytes = md5.finish();
+
+  uint64_t result = 0;
+  for (uint i = 0; i < sizeof(uint64_t); i++) {
+    result = (result << 8) | resultBytes[i];
+  }
+
+  return result | (1ull << 63);
+}
+
 void parseFile(List<Statement>::Reader statements, ParsedFile::Builder result,
                const ErrorReporter& errorReporter) {
   CapnpParser parser(Orphanage::getForMessageContaining(result), errorReporter);
@@ -813,17 +840,20 @@ CapnpParser::CapnpParser(Orphanage orphanageParam, const ErrorReporter& errorRep
         return DeclParserResult(kj::mv(decl), parsers.interfaceLevelDecl);
       }));
 
-  parsers.param = arena.copy(p::transform(
+  parsers.param = arena.copy(p::transformWithLocation(
       p::sequence(identifier, op(":"), parsers.typeExpression,
                   p::optional(p::sequence(op("="), parsers.valueExpression)),
                   p::many(parsers.annotation)),
-      [this](Located<Text::Reader>&& name, Orphan<TypeExpression>&& type,
+      [this](kj::parse::Span<List<Token>::Reader::Iterator> location,
+             Located<Text::Reader>&& name, Orphan<TypeExpression>&& type,
              kj::Maybe<Orphan<ValueExpression>>&& defaultValue,
              kj::Array<Orphan<Declaration::AnnotationApplication>>&& annotations)
                  -> Orphan<Declaration::Param> {
         auto result = orphanage.newOrphan<Declaration::Param>();
         auto builder = result.get();
 
+        initLocation(location, builder);
+
         name.copyTo(builder.initName());
         builder.adoptType(kj::mv(type));
         builder.adoptAnnotations(arrayToList(orphanage, kj::mv(annotations)));
@@ -836,14 +866,39 @@ CapnpParser::CapnpParser(Orphanage orphanageParam, const ErrorReporter& errorRep
         return kj::mv(result);
       }));
 
+  auto& paramList = arena.copy(p::oneOf(
+      p::transform(parenthesizedList(parsers.param, errorReporter),
+          [this](Located<kj::Array<kj::Maybe<Orphan<Declaration::Param>>>>&& params)
+                -> Orphan<Declaration::ParamList> {
+            auto decl = orphanage.newOrphan<Declaration::ParamList>();
+            auto builder = decl.get();
+            params.copyLocationTo(builder);
+            auto listBuilder = builder.initNamedList(params.value.size());
+            for (uint i: kj::indices(params.value)) {
+              KJ_IF_MAYBE(param, params.value[i]) {
+                listBuilder.adoptWithCaveats(i, kj::mv(*param));
+              }
+            }
+            return decl;
+          }),
+      p::transform(parsers.declName,
+          [this](Orphan<DeclName>&& name) -> Orphan<Declaration::ParamList> {
+            auto decl = orphanage.newOrphan<Declaration::ParamList>();
+            auto builder = decl.get();
+            auto nameReader = name.getReader();
+            builder.setStartByte(nameReader.getStartByte());
+            builder.setEndByte(nameReader.getEndByte());
+            builder.adoptType(kj::mv(name));
+            return decl;
+          })));
+
   parsers.methodDecl = arena.copy(p::transform(
-      p::sequence(identifier, parsers.ordinal,
-                  parenthesizedList(parsers.param, errorReporter),
-                  p::optional(p::sequence(op(":"), parsers.typeExpression)),
+      p::sequence(identifier, parsers.ordinal, paramList,
+                  p::optional(p::sequence(op("->"), paramList)),
                   p::many(parsers.annotation)),
       [this](Located<Text::Reader>&& name, Orphan<LocatedInteger>&& ordinal,
-             Located<kj::Array<kj::Maybe<Orphan<Declaration::Param>>>>&& params,
-             kj::Maybe<Orphan<TypeExpression>>&& returnType,
+             Orphan<Declaration::ParamList>&& params,
+             kj::Maybe<Orphan<Declaration::ParamList>>&& results,
              kj::Array<Orphan<Declaration::AnnotationApplication>>&& annotations)
                  -> DeclParserResult {
         auto decl = orphanage.newOrphan<Declaration>();
@@ -851,18 +906,14 @@ CapnpParser::CapnpParser(Orphanage orphanageParam, const ErrorReporter& errorRep
             initMemberDecl(decl.get(), kj::mv(name), kj::mv(ordinal), kj::mv(annotations))
                 .initMethod();
 
-        auto paramsBuilder = builder.initParams(params.value.size());
-        for (uint i = 0; i < params.value.size(); i++) {
-          KJ_IF_MAYBE(param, params.value[i]) {
-            paramsBuilder.adoptWithCaveats(i, kj::mv(*param));
-          }
-        }
+        builder.adoptParams(kj::mv(params));
 
-        KJ_IF_MAYBE(t, returnType) {
-          builder.getReturnType().adoptExpression(kj::mv(*t));
+        KJ_IF_MAYBE(r, results) {
+          builder.getResults().adoptExplicit(kj::mv(*r));
         } else {
-          builder.getReturnType().setNone();
+          builder.getResults().setNone();
         }
+
         return DeclParserResult(kj::mv(decl));
       }));
 

c++/src/capnp/compiler/parser.h

@@ -48,6 +48,9 @@ uint64_t generateChildId(uint64_t parentId, kj::StringPtr childName);
 
 uint64_t generateGroupId(uint64_t parentId, uint16_t groupIndex);
 // Generate the ID for a group within a struct.
+
+uint64_t generateMethodParamsId(uint64_t parentId, uint16_t methodOrdinal, bool isResults);
+// Generate the ID for a struct representing method params / results.
 //
 // TODO(cleanup):  Move generate*Id() somewhere more sensible.
 

c++/src/capnp/schema-loader.c++

@@ -30,6 +30,8 @@
 #include <kj/debug.h>
 #include <kj/exception.h>
 #include <kj/arena.h>
+#include <kj/vector.h>
+#include <algorithm>
 
 namespace capnp {
 
@@ -386,17 +388,8 @@ private:
                       "invalid codeOrder");
       sawCodeOrder[method.getCodeOrder()] = true;
 
-      auto params = method.getParams();
-      for (auto param: params) {
-        KJ_CONTEXT("validating parameter", param.getName());
-        uint dummy1;
-        bool dummy2;
-        validate(param.getType(), param.getDefaultValue(), &dummy1, &dummy2);
-      }
-
-      VALIDATE_SCHEMA(method.getRequiredParamCount() <= params.size(),
-                      "invalid requiredParamCount");
-      validate(method.getReturnType());
+      validateTypeId(method.getParamStructType(), schema::Node::STRUCT);
+      validateTypeId(method.getResultStructType(), schema::Node::STRUCT);
     }
   }
 
@@ -754,6 +747,43 @@ private:
 
   void checkCompatibility(const schema::Node::Interface::Reader& interfaceNode,
                           const schema::Node::Interface::Reader& replacement) {
+    {
+      // Check superclasses.
+
+      kj::Vector<uint64_t> extends;
+      kj::Vector<uint64_t> replacementExtends;
+      for (uint64_t extend: interfaceNode.getExtends()) {
+        extends.add(extend);
+      }
+      for (uint64_t extend: replacement.getExtends()) {
+        replacementExtends.add(extend);
+      }
+      std::sort(extends.begin(), extends.end());
+      std::sort(replacementExtends.begin(), replacementExtends.end());
+
+      auto iter = extends.begin();
+      auto replacementIter = replacementExtends.begin();
+
+      while (iter != extends.end() || replacementIter != replacementExtends.end()) {
+        if (iter == extends.end()) {
+          replacementIsNewer();
+          break;
+        } else if (replacementIter == replacementExtends.end()) {
+          replacementIsOlder();
+          break;
+        } else if (*iter < *replacementIter) {
+          replacementIsOlder();
+          ++iter;
+        } else if (*iter > *replacementIter) {
+          replacementIsNewer();
+          ++replacementIter;
+        } else {
+          ++iter;
+          ++replacementIter;
+        }
+      }
+    }
+
     auto methods = interfaceNode.getMethods();
     auto replacementMethods = replacement.getMethods();
 
@@ -774,40 +804,11 @@ private:
                           const schema::Method::Reader& replacement) {
     KJ_CONTEXT("comparing method", method.getName());
 
-    auto params = method.getParams();
-    auto replacementParams = replacement.getParams();
-
-    if (replacementParams.size() > params.size()) {
-      replacementIsNewer();
-    } else if (replacementParams.size() < params.size()) {
-      replacementIsOlder();
-    }
-
-    uint count = std::min(params.size(), replacementParams.size());
-    for (uint i = 0; i < count; i++) {
-      auto param = params[i];
-      auto replacementParam = replacementParams[i];
-
-      KJ_CONTEXT("comparing parameter", param.getName());
-
-      checkCompatibility(param.getType(), replacementParam.getType(),
-                         NO_UPGRADE_TO_STRUCT);
-      checkDefaultCompatibility(param.getDefaultValue(), replacementParam.getDefaultValue());
-    }
-
-    // Before checking that the required parameter counts are equal, check if the user added new
-    // parameters without defaulting them, as this is the most common reason for this error and we
-    // can provide a nicer error message.
-    VALIDATE_SCHEMA(replacement.getRequiredParamCount() <= count &&
-                    method.getRequiredParamCount() <= count,
-        "Updated method signature contains additional parameters that lack default values");
-
-    VALIDATE_SCHEMA(replacement.getRequiredParamCount() == method.getRequiredParamCount(),
-        "Updated method signature has different number of required parameters (parameters without "
-        "default values)");
-
-    checkCompatibility(method.getReturnType(), replacement.getReturnType(),
-                       ALLOW_UPGRADE_TO_STRUCT);
+    // TODO(someday):  Allow named parameter list to be replaced by compatible struct type.
+    VALIDATE_SCHEMA(method.getParamStructType() == replacement.getParamStructType(),
+                    "Updated method has different parameters.");
+    VALIDATE_SCHEMA(method.getResultStructType() == replacement.getResultStructType(),
+                    "Updated method has different results.");
   }
 
   void checkCompatibility(const schema::Node::Const::Reader& constNode,

c++/src/capnp/schema.capnp

@@ -191,6 +191,12 @@ struct Field {
 
       type @5 :Type;
       defaultValue @6 :Value;
+
+      hadExplicitDefault @10 :Bool;
+      # Whether the default value was specified explicitly.  Non-explicit default values are always
+      # zero or empty values.  Usually, whether the default value was explicit shouldn't matter.
+      # The main use case for this flag is for structs representing method parameters:
+      # explicitly-defaulted parameters may be allowed to be omitted when calling the method.
     }
 
     group :group {
@@ -232,22 +238,16 @@ struct Method {
   # Specifies order in which the methods were declared in the code.
   # Like Struct.Field.codeOrder.
 
-  params @2 :List(Param);
-  struct Param {
-    name @0 :Text;
-    type @1 :Type;
-    defaultValue @2 :Value;
-    annotations @3 :List(Annotation);
-  }
+  paramStructType @2 :Id;
+  # ID of the parameter struct type.  If a named parameter list was specified in the method
+  # declaration (rather than a single struct parameter type) then a corresponding struct type is
+  # auto-generated.  Such an auto-generated type will not be listed in the interface's
+  # `nestedNodes` and its `scopeId` will be zero -- it is completely detached from the namespace.
 
-  requiredParamCount @3 :UInt16;
-  # One plus the index of the last parameter that has no default value.  In languages where
-  # method calls look like function calls, this is the minimum number of parameters that must
-  # always be specified, while subsequent parameters are optional.
+  resultStructType @3 :Id;
+  # ID of the return struct type; similar to `paramStructType`.
 
-  returnType @4 :Type;
-
-  annotations @5 :List(Annotation);
+  annotations @4 :List(Annotation);
 }
 
 struct Type {

c++/src/capnp/test.capnp

@@ -574,11 +574,13 @@ const derivedConstant :TestAllTypes = (
     structList = TestConstants.structListConst);
 
 interface TestInterface {
-  foo @0 (i :UInt32, j :Bool) :Text;
-  bar @1 () :Void;
+  foo @0 (i :UInt32, j :Bool) -> (x: Text);
+  bar @1 () -> ();
   baz @2 (s: TestAllTypes);
 }
 
 interface TestExtends extends(TestInterface) {
   qux @0 ();
+  corge @1 TestAllTypes -> ();
+  grault @2 () -> TestAllTypes;
 }