// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
// Licensed under the MIT License:
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

// This program is a code generator plugin for `capnp compile` which generates C++ code.

#if _WIN32
#include <kj/win32-api-version.h>
#endif

#include <capnp/schema.capnp.h>
#include "../serialize.h"
#include <kj/debug.h>
#include <kj/io.h>
#include <kj/string-tree.h>
#include <kj/tuple.h>
#include <kj/vector.h>
#include <kj/filesystem.h>
#include "../schema-loader.h"
#include "../dynamic.h"
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <set>
#include <kj/main.h>
#include <algorithm>
#include <capnp/stream.capnp.h>

#if _WIN32
#include <windows.h>
#include <kj/windows-sanity.h>
#undef CONST
#else
#include <sys/time.h>
#endif

#if HAVE_CONFIG_H
#include "config.h"
#endif

#ifndef VERSION
#define VERSION "(unknown)"
#endif

namespace capnp {
namespace {

static constexpr uint64_t NAMESPACE_ANNOTATION_ID = 0xb9c6f99ebf805f2cull;
static constexpr uint64_t NAME_ANNOTATION_ID = 0xf264a779fef191ceull;
static constexpr uint64_t ALLOW_CANCELLATION_ANNOTATION_ID = 0xac7096ff8cfc9dceull;

bool hasDiscriminantValue(const schema::Field::Reader& reader) {
  return reader.getDiscriminantValue() != schema::Field::NO_DISCRIMINANT;
}

void enumerateDeps(schema::Type::Reader type, std::set<uint64_t>& deps) {
  switch (type.which()) {
    case schema::Type::STRUCT:
      deps.insert(type.getStruct().getTypeId());
      break;
    case schema::Type::ENUM:
      deps.insert(type.getEnum().getTypeId());
      break;
    case schema::Type::INTERFACE:
      deps.insert(type.getInterface().getTypeId());
      break;
    case schema::Type::LIST:
      enumerateDeps(type.getList().getElementType(), deps);
      break;
    default:
      break;
  }
}

void enumerateDeps(schema::Node::Reader node, std::set<uint64_t>& deps) {
  switch (node.which()) {
    case schema::Node::STRUCT: {
      auto structNode = node.getStruct();
      for (auto field: structNode.getFields()) {
        switch (field.which()) {
          case schema::Field::SLOT:
            enumerateDeps(field.getSlot().getType(), deps);
            break;
          case schema::Field::GROUP:
            deps.insert(field.getGroup().getTypeId());
            break;
        }
      }
      if (structNode.getIsGroup()) {
        deps.insert(node.getScopeId());
      }
      break;
    }
    case schema::Node::INTERFACE: {
      auto interfaceNode = node.getInterface();
      for (auto superclass: interfaceNode.getSuperclasses()) {
        deps.insert(superclass.getId());
      }
      for (auto method: interfaceNode.getMethods()) {
        deps.insert(method.getParamStructType());
        deps.insert(method.getResultStructType());
      }
      break;
    }
    default:
      break;
  }
}

struct OrderByName {
  template <typename T>
  inline bool operator()(const T& a, const T& b) const {
    return a.getProto().getName() < b.getProto().getName();
  }
};

template <typename MemberList>
kj::Array<uint> makeMembersByName(MemberList&& members) {
  auto sorted = KJ_MAP(member, members) { return member; };
  std::sort(sorted.begin(), sorted.end(), OrderByName());
  return KJ_MAP(member, sorted) { return member.getIndex(); };
}

kj::StringPtr baseName(kj::StringPtr path) {
  KJ_IF_MAYBE(slashPos, path.findLast('/')) {
    return path.slice(*slashPos + 1);
  } else {
    return path;
  }
}

kj::String safeIdentifier(kj::StringPtr identifier) {
  // Given a desired identifier name, munge it to make it safe for use in generated code.
  //
  // If the identifier is a keyword, this adds an underscore to the end.

  static const std::set<kj::StringPtr> keywords({
    "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand", "bitor", "bool", "break",
    "case", "catch", "char", "char16_t", "char32_t", "class", "compl", "const", "constexpr",
    "const_cast", "continue", "decltype", "default", "delete", "do", "double", "dynamic_cast",
    "else", "enum", "explicit", "export", "extern", "false", "float", "for", "friend", "goto",
    "if", "inline", "int", "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq",
    "nullptr", "operator", "or", "or_eq", "private", "protected", "public", "register",
    "reinterpret_cast", "return", "short", "signed", "sizeof", "static", "static_assert",
    "static_cast", "struct", "switch", "template", "this", "thread_local", "throw", "true",
    "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", "void",
    "volatile", "wchar_t", "while", "xor", "xor_eq"
  });

  if (keywords.count(identifier) > 0) {
    return kj::str(identifier, '_');
  } else {
    return kj::heapString(identifier);
  }
}

// =======================================================================================

class CppTypeName {
  // Used to build a C++ type name string. This is complicated in the presence of templates,
  // because we must add the "typename" and "template" disambiguator keywords as needed.

public:
  inline CppTypeName(): isArgDependent(false), needsTypename(false),
                        hasInterfaces_(false), hasDisambiguatedTemplate_(false) {}
  CppTypeName(CppTypeName&& other) = default;
  CppTypeName(const CppTypeName& other)
      : name(kj::strTree(other.name.flatten())),
        isArgDependent(other.isArgDependent),
        needsTypename(other.needsTypename),
        hasInterfaces_(other.hasInterfaces_),
        hasDisambiguatedTemplate_(other.hasDisambiguatedTemplate_) {}

  CppTypeName& operator=(CppTypeName&& other) = default;
  CppTypeName& operator=(const CppTypeName& other) {
    name = kj::strTree(other.name.flatten());
    isArgDependent = other.isArgDependent;
    needsTypename = other.needsTypename;
    return *this;
  }

  static CppTypeName makeRoot() {
    return CppTypeName(kj::strTree(" "), false);
  }

  static CppTypeName makeNamespace(kj::StringPtr name) {
    return CppTypeName(kj::strTree(" ::", name), false);
  }

  static CppTypeName makeTemplateParam(kj::StringPtr name) {
    return CppTypeName(kj::strTree(name), true);
  }

  static CppTypeName makePrimitive(kj::StringPtr name) {
    return CppTypeName(kj::strTree(name), false);
  }

  void addMemberType(kj::StringPtr innerName) {
    // Append "::innerName" to refer to a member.

    name = kj::strTree(kj::mv(name), "::", innerName);
    needsTypename = isArgDependent;
  }

  void addMemberValue(kj::StringPtr innerName) {
    // Append "::innerName" to refer to a member.

    name = kj::strTree(kj::mv(name), "::", innerName);
    needsTypename = false;
  }

  bool hasDisambiguatedTemplate() {
    return hasDisambiguatedTemplate_;
  }

  void addMemberTemplate(kj::StringPtr innerName, kj::Array<CppTypeName>&& params) {
    // Append "::innerName<params, ...>".
    //
    // If necessary, add the "template" disambiguation keyword in front of `innerName`.

    bool parentIsArgDependent = isArgDependent;
    needsTypename = parentIsArgDependent;
    hasDisambiguatedTemplate_ = hasDisambiguatedTemplate_ || parentIsArgDependent;

    name = kj::strTree(kj::mv(name),
        parentIsArgDependent ? "::template " : "::",
        innerName, '<',
        kj::StringTree(KJ_MAP(p, params) {
          if (p.isArgDependent) isArgDependent = true;
          if (p.hasInterfaces_) hasInterfaces_ = true;
          if (p.hasDisambiguatedTemplate_) hasDisambiguatedTemplate_ = true;
          return kj::strTree(kj::mv(p));
        }, ", "),
        '>');
  }

  void setHasInterfaces() {
    hasInterfaces_ = true;
  }

  bool hasInterfaces() {
    return hasInterfaces_;
  }

  kj::StringTree strNoTypename() const & { return name.flatten(); }
  kj::StringTree strNoTypename() && { return kj::mv(name); }
  // Stringify but never prefix with `typename`. Use in contexts where `typename` is implicit.

private:
  kj::StringTree name;

  bool isArgDependent;
  // Does the name contain any template-argument-dependent types?

  bool needsTypename;
  // Does the name require a prefix of "typename"?

  bool hasInterfaces_;
  // Does this type name refer to any interface types? If so it may need to be #ifdefed out in
  // lite mode.

  bool hasDisambiguatedTemplate_;
  // Whether the type name contains a template type that had to be disambiguated using the
  // "template" keyword, e.g. "Foo<T>::template Bar<U>".
  //
  // TODO(msvc): We only track this because MSVC seems to get confused by it in some weird cases.

  inline CppTypeName(kj::StringTree&& name, bool isArgDependent)
      : name(kj::mv(name)), isArgDependent(isArgDependent), needsTypename(false),
        hasInterfaces_(false), hasDisambiguatedTemplate_(false) {}

  friend kj::StringTree KJ_STRINGIFY(CppTypeName&& typeName);
  friend kj::String KJ_STRINGIFY(const CppTypeName& typeName);
};

kj::StringTree KJ_STRINGIFY(CppTypeName&& typeName) {
  if (typeName.needsTypename) {
    return kj::strTree("typename ", kj::mv(typeName.name));
  } else {
    return kj::mv(typeName.name);
  }
}
kj::String KJ_STRINGIFY(const CppTypeName& typeName) {
  if (typeName.needsTypename) {
    return kj::str("typename ", typeName.name);
  } else {
    return typeName.name.flatten();
  }
}

CppTypeName whichKind(Type type) {
  // Make a CppTypeName representing the capnp::Kind value for the given schema type. This makes
  // CppTypeName conflate types and values, but this is all just a hack for MSVC's benefit. Its
  // primary use is as a non-type template parameter to `capnp::List<T, K>` -- normally the Kind K
  // is deduced via SFINAE, but MSVC just can't do it in certain cases, such as when a nested type
  // of `capnp::List<T, K>` is the return type of a function, and the element type T is a template
  // instantiation.

  switch (type.which()) {
    case schema::Type::VOID: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");

    case schema::Type::BOOL: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::INT8: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::INT16: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::INT32: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::INT64: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::UINT8: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::UINT16: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::UINT32: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::UINT64: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::FLOAT32: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");
    case schema::Type::FLOAT64: return CppTypeName::makePrimitive(" ::capnp::Kind::PRIMITIVE");

    case schema::Type::TEXT: return CppTypeName::makePrimitive(" ::capnp::Kind::BLOB");
    case schema::Type::DATA: return CppTypeName::makePrimitive(" ::capnp::Kind::BLOB");

    case schema::Type::ENUM: return CppTypeName::makePrimitive(" ::capnp::Kind::ENUM");
    case schema::Type::STRUCT: return CppTypeName::makePrimitive(" ::capnp::Kind::STRUCT");
    case schema::Type::INTERFACE: return CppTypeName::makePrimitive(" ::capnp::Kind::INTERFACE");

    case schema::Type::LIST: return CppTypeName::makePrimitive(" ::capnp::Kind::LIST");
    case schema::Type::ANY_POINTER: {
      switch (type.whichAnyPointerKind()) {
        case schema::Type::AnyPointer::Unconstrained::CAPABILITY:
          return CppTypeName::makePrimitive(" ::capnp::Kind::INTERFACE");
        default:
          return CppTypeName::makePrimitive(" ::capnp::Kind::OTHER");
      }
    }
  }

  KJ_UNREACHABLE;
}

// =======================================================================================

class CapnpcCppMain {
public:
  CapnpcCppMain(kj::ProcessContext& context): context(context) {}

  kj::MainFunc getMain() {
    return kj::MainBuilder(context, "Cap'n Proto C++ plugin version " VERSION,
          "This is a Cap'n Proto compiler plugin which generates C++ code. "
          "It is meant to be run using the Cap'n Proto compiler, e.g.:\n"
          "    capnp compile -oc++ foo.capnp")
        .callAfterParsing(KJ_BIND_METHOD(*this, run))
        .build();
  }

private:
  kj::ProcessContext& context;
  SchemaLoader schemaLoader;
  std::unordered_set<uint64_t> usedImports;
  bool hasInterfaces = false;

  CppTypeName cppFullName(Schema schema, kj::Maybe<InterfaceSchema::Method> method) {
    return cppFullName(schema, schema, method);
  }

  CppTypeName cppFullName(Schema schema, Schema brand, kj::Maybe<InterfaceSchema::Method> method) {
    auto node = schema.getProto();

    if (node.getScopeId() == 0) {
      // This is the file-level scope. Search for the namespace annotation.
      KJ_REQUIRE(node.isFile(),
          "Non-file had scopeId zero; perhaps it's a method param / result struct?");
      usedImports.insert(node.getId());
      KJ_IF_MAYBE(ns, annotationValue(node, NAMESPACE_ANNOTATION_ID)) {
        return CppTypeName::makeNamespace(ns->getText());
      } else {
        return CppTypeName::makeRoot();
      }
    } else {
      // This is a named type.

      // Figure out what name to use.
      Schema parent = schemaLoader.get(node.getScopeId());
      kj::StringPtr unqualifiedName;
      kj::String ownUnqualifiedName;
      KJ_IF_MAYBE(annotatedName, annotationValue(node, NAME_ANNOTATION_ID)) {
        // The node's name has been overridden for C++ by an annotation.
        unqualifiedName = annotatedName->getText();
      } else {
        // Search among the parent's nested nodes to for this node, in order to determine its name.
        auto parentProto = parent.getProto();
        for (auto nested: parentProto.getNestedNodes()) {
          if (nested.getId() == node.getId()) {
            unqualifiedName = nested.getName();
            break;
          }
        }
        if (unqualifiedName == nullptr) {
          // Hmm, maybe it's a group node?
          if (parentProto.isStruct()) {
            for (auto field: parentProto.getStruct().getFields()) {
              if (field.isGroup() && field.getGroup().getTypeId() == node.getId()) {
                ownUnqualifiedName = toTitleCase(protoName(field));
                unqualifiedName = ownUnqualifiedName;
                break;
              }
            }
          }
        }
        KJ_REQUIRE(unqualifiedName != nullptr,
            "A schema Node's supposed scope did not contain the node as a NestedNode.");
      }

      auto result = cppFullName(parent, brand, method);

      // Construct the generic arguments.
      auto params = node.getParameters();
      if (params.size() > 0) {
        auto args = brand.getBrandArgumentsAtScope(node.getId());

#if 0
        // Figure out exactly how many params are not bound to AnyPointer.
        // TODO(msvc): In a few obscure cases, MSVC does not like empty template parameter lists,
        //   even if all parameters have defaults. So, we give in and explicitly list all
        //   parameters in our generated code for now. Try again later.
        uint paramCount = 0;
        for (uint i: kj::indices(params)) {
          auto arg = args[i];
          if (arg.which() != schema::Type::ANY_POINTER || arg.getBrandParameter() != nullptr ||
              (arg.getImplicitParameter() != nullptr && method != nullptr)) {
            paramCount = i + 1;
          }
        }
#else
        uint paramCount = params.size();
#endif

        result.addMemberTemplate(unqualifiedName,
            KJ_MAP(i, kj::range(0u, paramCount)) {
              return typeName(args[i], method);
            });
      } else {
        result.addMemberType(unqualifiedName);
      }

      return result;
    }
  }

  kj::String toUpperCase(kj::StringPtr name) {
    kj::Vector<char> result(name.size() + 4);

    for (char c: name) {
      if ('a' <= c && c <= 'z') {
        result.add(c - 'a' + 'A');
      } else if (result.size() > 0 && 'A' <= c && c <= 'Z') {
        result.add('_');
        result.add(c);
      } else {
        result.add(c);
      }
    }

    if (result.size() == 4 && memcmp(result.begin(), "NULL", 4) == 0) {
      // NULL probably collides with a macro.
      result.add('_');
    }

    result.add('\0');

    return kj::String(result.releaseAsArray());
  }

  kj::String toTitleCase(kj::StringPtr name) {
    kj::String result = kj::heapString(name);
    if ('a' <= result[0] && result[0] <= 'z') {
      result[0] = result[0] - 'a' + 'A';
    }
    return kj::mv(result);
  }

  CppTypeName typeName(Type type, kj::Maybe<InterfaceSchema::Method> method) {
    switch (type.which()) {
      case schema::Type::VOID: return CppTypeName::makePrimitive(" ::capnp::Void");

      case schema::Type::BOOL: return CppTypeName::makePrimitive("bool");
      case schema::Type::INT8: return CppTypeName::makePrimitive(" ::int8_t");
      case schema::Type::INT16: return CppTypeName::makePrimitive(" ::int16_t");
      case schema::Type::INT32: return CppTypeName::makePrimitive(" ::int32_t");
      case schema::Type::INT64: return CppTypeName::makePrimitive(" ::int64_t");
      case schema::Type::UINT8: return CppTypeName::makePrimitive(" ::uint8_t");
      case schema::Type::UINT16: return CppTypeName::makePrimitive(" ::uint16_t");
      case schema::Type::UINT32: return CppTypeName::makePrimitive(" ::uint32_t");
      case schema::Type::UINT64: return CppTypeName::makePrimitive(" ::uint64_t");
      case schema::Type::FLOAT32: return CppTypeName::makePrimitive("float");
      case schema::Type::FLOAT64: return CppTypeName::makePrimitive("double");

      case schema::Type::TEXT: return CppTypeName::makePrimitive(" ::capnp::Text");
      case schema::Type::DATA: return CppTypeName::makePrimitive(" ::capnp::Data");

      case schema::Type::ENUM:
        return cppFullName(type.asEnum(), method);
      case schema::Type::STRUCT:
        return cppFullName(type.asStruct(), method);
      case schema::Type::INTERFACE: {
        auto result = cppFullName(type.asInterface(), method);
        result.setHasInterfaces();
        return result;
      }

      case schema::Type::LIST: {
        CppTypeName result = CppTypeName::makeNamespace("capnp");
        auto params = kj::heapArrayBuilder<CppTypeName>(2);
        auto list = type.asList();
        params.add(typeName(list.getElementType(), method));
        params.add(whichKind(list.getElementType()));
        result.addMemberTemplate("List", params.finish());
        return result;
      }

      case schema::Type::ANY_POINTER:
        KJ_IF_MAYBE(param, type.getBrandParameter()) {
          return CppTypeName::makeTemplateParam(schemaLoader.get(param->scopeId).getProto()
              .getParameters()[param->index].getName());
        } else KJ_IF_MAYBE(param, type.getImplicitParameter()) {
          KJ_IF_MAYBE(m, method) {
            auto params = m->getProto().getImplicitParameters();
            KJ_REQUIRE(param->index < params.size());
            return CppTypeName::makeTemplateParam(params[param->index].getName());
          } else {
            return CppTypeName::makePrimitive(" ::capnp::AnyPointer");
          }
        } else {
          switch (type.whichAnyPointerKind()) {
            case schema::Type::AnyPointer::Unconstrained::ANY_KIND:
              return CppTypeName::makePrimitive(" ::capnp::AnyPointer");
            case schema::Type::AnyPointer::Unconstrained::STRUCT:
              return CppTypeName::makePrimitive(" ::capnp::AnyStruct");
            case schema::Type::AnyPointer::Unconstrained::LIST:
              return CppTypeName::makePrimitive(" ::capnp::AnyList");
            case schema::Type::AnyPointer::Unconstrained::CAPABILITY: {
              hasInterfaces = true;  // Probably need to #include <capnp/capability.h>.
              auto result = CppTypeName::makePrimitive(" ::capnp::Capability");
              result.setHasInterfaces();
              return result;
            }
          }
          KJ_UNREACHABLE;
        }
    }
    KJ_UNREACHABLE;
  }

  template <typename P>
  kj::Maybe<schema::Value::Reader> annotationValue(P proto, uint64_t annotationId) {
    for (auto annotation: proto.getAnnotations()) {
      if (annotation.getId() == annotationId) {
        return annotation.getValue();
      }
    }
    return nullptr;
  }

  template <typename P>
  kj::StringPtr protoName(P proto) {
    KJ_IF_MAYBE(name, annotationValue(proto, NAME_ANNOTATION_ID)) {
      return name->getText();
    } else {
      return proto.getName();
    }
  }

  kj::StringTree literalValue(Type type, schema::Value::Reader value) {
    switch (value.which()) {
      case schema::Value::VOID: return kj::strTree(" ::capnp::VOID");
      case schema::Value::BOOL: return kj::strTree(value.getBool() ? "true" : "false");
      case schema::Value::INT8: return kj::strTree(value.getInt8());
      case schema::Value::INT16: return kj::strTree(value.getInt16());
      case schema::Value::INT32: return kj::strTree(value.getInt32());
      case schema::Value::INT64: return kj::strTree(value.getInt64(), "ll");
      case schema::Value::UINT8: return kj::strTree(value.getUint8(), "u");
      case schema::Value::UINT16: return kj::strTree(value.getUint16(), "u");
      case schema::Value::UINT32: return kj::strTree(value.getUint32(), "u");
      case schema::Value::UINT64: return kj::strTree(value.getUint64(), "llu");
      case schema::Value::FLOAT32: {
        auto text = kj::str(value.getFloat32());
        if (text.findFirst('.') == nullptr &&
            text.findFirst('e') == nullptr &&
            text.findFirst('E') == nullptr) {
          text = kj::str(text, ".0");
        }
        return kj::strTree(kj::mv(text), "f");
      }
      case schema::Value::FLOAT64: return kj::strTree(value.getFloat64());
      case schema::Value::ENUM: {
        EnumSchema schema = type.asEnum();
        if (value.getEnum() < schema.getEnumerants().size()) {
          return kj::strTree(
              cppFullName(schema, nullptr), "::",
              toUpperCase(protoName(schema.getEnumerants()[value.getEnum()].getProto())));
        } else {
          return kj::strTree("static_cast<", cppFullName(schema, nullptr),
                             ">(", value.getEnum(), ")");
        }
      }

      case schema::Value::TEXT:
      case schema::Value::DATA:
      case schema::Value::STRUCT:
      case schema::Value::INTERFACE:
      case schema::Value::LIST:
      case schema::Value::ANY_POINTER:
        KJ_FAIL_REQUIRE("literalValue() can only be used on primitive types.");
    }
    KJ_UNREACHABLE;
  }

  // -----------------------------------------------------------------

  class TemplateContext {
  public:
    TemplateContext(): parent(nullptr) {}
    explicit TemplateContext(schema::Node::Reader node)
        : parent(nullptr), node(node) {}
    TemplateContext(const TemplateContext& parent, kj::StringPtr name, schema::Node::Reader node)
        : parent(parent), name(name), node(node) {}

    bool hasParams() const {
      return node.getParameters().size() > 0;
    }
    bool isGeneric() const {
      return node.getIsGeneric();
    }
    kj::Maybe<const TemplateContext&> getParent() const {
      return parent;
    }
    kj::StringPtr getName() const { return name; }

    kj::StringTree decl(bool withDefaults, kj::StringPtr suffix = nullptr) const {
      // "template <typename T, typename U>" for this type. Includes default assignments
      // ("= ::capnp::AnyPointer") if `withDefaults` is true. Returns empty string if this type
      // is not parameterized.

      auto params = node.getParameters();

      if (params.size() == 0) {
        return kj::strTree();
      } else {
        return kj::strTree(
            "template <", kj::StringTree(KJ_MAP(p, params) {
              return kj::strTree("typename ", p.getName(), suffix,
                  withDefaults ? " = ::capnp::AnyPointer" : "");
            }, ", "), ">\n");
      }
    }

    kj::StringTree allDecls() const {
      // Decl for each generic parent plus this type, one per line.
      return kj::strTree(parentDecls(), decl(false));
    }

    kj::StringTree parentDecls() const {
      // Decls just for the parents.
      KJ_IF_MAYBE(p, parent) {
        return p->allDecls();
      } else {
        return kj::strTree();
      }
    }

    kj::StringTree args(kj::StringPtr suffix = nullptr) const {
      // "<T, U>" for this type.
      auto params = node.getParameters();

      if (params.size() == 0) {
        return kj::strTree();
      } else {
        return kj::strTree(
            "<", kj::StringTree(KJ_MAP(p, params) {
              return kj::strTree(p.getName(), suffix);
            }, ", "), ">");
      }
    }

    kj::StringTree allArgs() const {
      // "S, T, U, V" -- listing all args for all enclosing scopes starting from the outermost.

      auto params = node.getParameters();

      kj::StringTree self(KJ_MAP(p, params) { return kj::strTree(p.getName()); }, ", ");
      kj::StringTree up;
      KJ_IF_MAYBE(p, parent) {
        up = p->allArgs();
      }

      if (self.size() == 0) {
        return up;
      } else if (up.size() == 0) {
        return self;
      } else {
        return kj::strTree(kj::mv(up), ", ", kj::mv(self));
      }
    }

    std::map<uint64_t, List<schema::Node::Parameter>::Reader> getScopeMap() const {
      std::map<uint64_t, List<schema::Node::Parameter>::Reader> result;
      const TemplateContext* current = this;
      for (;;) {
        auto params = current->node.getParameters();
        if (params.size() > 0) {
          result[current->node.getId()] = params;
        }
        KJ_IF_MAYBE(p, current->parent) {
          current = p;
        } else {
          return result;
        }
      }
    }

  private:
    kj::Maybe<const TemplateContext&> parent;
    kj::StringPtr name;
    schema::Node::Reader node;
  };

  struct BrandInitializerText {
    kj::StringTree scopes;
    kj::StringTree bindings;
    kj::StringTree dependencies;
    size_t dependencyCount;
    // TODO(msvc):  `dependencyCount` is the number of individual dependency definitions in
    //   `dependencies`. It's a hack to allow makeGenericDefinitions to hard-code the size of the
    //   `_capnpPrivate::brandDependencies` array into the definition of
    //   `_capnpPrivate::specificBrand::dependencyCount`. This is necessary because MSVC cannot
    //   deduce the size of `brandDependencies` if it is nested under a class template. It's
    //   probably this demoralizingly deferred bug:
    //   https://connect.microsoft.com/VisualStudio/feedback/details/759407/can-not-get-size-of-static-array-defined-in-class-template
  };

  BrandInitializerText makeBrandInitializers(
      const TemplateContext& templateContext, Schema schema) {
    auto scopeMap = templateContext.getScopeMap();

    auto scopes = kj::heapArrayBuilder<kj::StringTree>(scopeMap.size());
    kj::Vector<kj::StringTree> bindings(scopeMap.size() * 2);  // (estimate two params per scope)

    for (auto& scope: scopeMap) {
      scopes.add(kj::strTree("  { ",
        "0x", kj::hex(scope.first), ", "
        "brandBindings + ", bindings.size(), ", ",
        scope.second.size(), ", "
        "false"
      "},\n"));

      for (auto param: scope.second) {
        bindings.add(kj::strTree("  ::capnp::_::brandBindingFor<", param.getName(), ">(),\n"));
      }
    }

    auto depMap = makeBrandDepMap(templateContext, schema);
    auto dependencyCount = depMap.size();
    return {
      kj::strTree("{\n", scopes.finish(), "}"),
      kj::strTree("{\n", bindings.releaseAsArray(), "}"),
      makeBrandDepInitializers(kj::mv(depMap)),
      dependencyCount
    };
  }

  std::map<uint, kj::StringTree>
  makeBrandDepMap(const TemplateContext& templateContext, Schema schema) {
    // Build deps. This is separate from makeBrandDepInitializers to give calling code the
    // opportunity to count the number of dependencies, to calculate array sizes.
    std::map<uint, kj::StringTree> depMap;

#define ADD_DEP(kind, index, ...) \
    { \
      uint location = _::RawBrandedSchema::makeDepLocation( \
          _::RawBrandedSchema::DepKind::kind, index); \
      KJ_IF_MAYBE(dep, makeBrandDepInitializer(__VA_ARGS__)) { \
        depMap[location] = kj::mv(*dep); \
      } \
    }

    switch (schema.getProto().which()) {
      case schema::Node::FILE:
      case schema::Node::ENUM:
      case schema::Node::ANNOTATION:
        break;

      case schema::Node::STRUCT:
        for (auto field: schema.asStruct().getFields()) {
          ADD_DEP(FIELD, field.getIndex(), field.getType());
        }
        break;
      case schema::Node::INTERFACE: {
        auto interface = schema.asInterface();
        auto superclasses = interface.getSuperclasses();
        for (auto i: kj::indices(superclasses)) {
          ADD_DEP(SUPERCLASS, i, superclasses[i]);
        }
        auto methods = interface.getMethods();
        for (auto i: kj::indices(methods)) {
          auto method = methods[i];
          ADD_DEP(METHOD_PARAMS, i, method, method.getParamType(), "Params");
          ADD_DEP(METHOD_RESULTS, i, method, method.getResultType(), "Results");
        }
        break;
      }
      case schema::Node::CONST:
        ADD_DEP(CONST_TYPE, 0, schema.asConst().getType());
        break;
    }
#undef ADD_DEP
    return depMap;
  }

  kj::StringTree makeBrandDepInitializers(std::map<uint, kj::StringTree>&& depMap) {
    // Process depMap. Returns a braced initialiser list, or an empty string if there are no
    // dependencies.
    if (!depMap.size()) {
      return kj::strTree();
    }

    auto deps = kj::heapArrayBuilder<kj::StringTree>(depMap.size());
    for (auto& entry: depMap) {
      deps.add(kj::strTree("  { ", entry.first, ", ", kj::mv(entry.second), " },\n"));
    }

    return kj::strTree("{\n", kj::StringTree(deps.finish(), ""), "}");
  }

  kj::Maybe<kj::StringTree> makeBrandDepInitializer(Schema type) {
    // Be careful not to invoke cppFullName() if it would just be thrown away, as doing so will
    // add the type's declaring file to `usedImports`. In particular, this causes `stream.capnp.h`
    // to be #included unnecessarily.
    if (type.isBranded()) {
      return makeBrandDepInitializer(type, cppFullName(type, nullptr));
    } else {
      return nullptr;
    }
  }

  kj::Maybe<kj::StringTree> makeBrandDepInitializer(
      InterfaceSchema::Method method, StructSchema type, kj::StringPtr suffix) {
    auto typeProto = type.getProto();
    if (typeProto.getScopeId() == 0) {
      // This is an auto-generated params or results type.
      auto name = cppFullName(method.getContainingInterface(), nullptr);
      auto memberTypeName = kj::str(toTitleCase(protoName(method.getProto())), suffix);

      if (typeProto.getParameters().size() == 0) {
        name.addMemberType(memberTypeName);
      } else {
        // The method has implicit parameters (i.e. it's generic). For the purpose of the brand
        // dep initializer, we only want to supply the default AnyPointer variant, so just don't
        // pass any parameters here.
        name.addMemberTemplate(memberTypeName, nullptr);
      }
      return makeBrandDepInitializer(type, kj::mv(name));
    } else {
      return makeBrandDepInitializer(type);
    }
  }

  kj::Maybe<kj::StringTree> makeBrandDepInitializer(Schema type, CppTypeName name) {
    if (type.isBranded()) {
      name.addMemberType("_capnpPrivate");
      name.addMemberValue("brand");
      return kj::strTree(name, "()");
    } else {
      return nullptr;
    }
  }

  kj::Maybe<kj::StringTree> makeBrandDepInitializer(Type type) {
    switch (type.which()) {
      case schema::Type::VOID:
      case schema::Type::BOOL:
      case schema::Type::INT8:
      case schema::Type::INT16:
      case schema::Type::INT32:
      case schema::Type::INT64:
      case schema::Type::UINT8:
      case schema::Type::UINT16:
      case schema::Type::UINT32:
      case schema::Type::UINT64:
      case schema::Type::FLOAT32:
      case schema::Type::FLOAT64:
      case schema::Type::TEXT:
      case schema::Type::DATA:
      case schema::Type::ENUM:
      case schema::Type::ANY_POINTER:
        return nullptr;

      case schema::Type::STRUCT:
        return makeBrandDepInitializer(type.asStruct());
      case schema::Type::INTERFACE:
        return makeBrandDepInitializer(type.asInterface());
      case schema::Type::LIST:
        return makeBrandDepInitializer(type.asList().getElementType());
    }

    KJ_UNREACHABLE;
  }

  // -----------------------------------------------------------------
  // Code to deal with "slots" -- determines what to zero out when we clear a group.

  static uint typeSizeBits(schema::Type::Which whichType) {
    switch (whichType) {
      case schema::Type::BOOL: return 1;
      case schema::Type::INT8: return 8;
      case schema::Type::INT16: return 16;
      case schema::Type::INT32: return 32;
      case schema::Type::INT64: return 64;
      case schema::Type::UINT8: return 8;
      case schema::Type::UINT16: return 16;
      case schema::Type::UINT32: return 32;
      case schema::Type::UINT64: return 64;
      case schema::Type::FLOAT32: return 32;
      case schema::Type::FLOAT64: return 64;
      case schema::Type::ENUM: return 16;

      case schema::Type::VOID:
      case schema::Type::TEXT:
      case schema::Type::DATA:
      case schema::Type::LIST:
      case schema::Type::STRUCT:
      case schema::Type::INTERFACE:
      case schema::Type::ANY_POINTER:
        KJ_FAIL_REQUIRE("Should only be called for data types.");
    }
    KJ_UNREACHABLE;
  }

  enum class Section {
    NONE,
    DATA,
    POINTERS
  };

  static Section sectionFor(schema::Type::Which whichType) {
    switch (whichType) {
      case schema::Type::VOID:
        return Section::NONE;
      case schema::Type::BOOL:
      case schema::Type::INT8:
      case schema::Type::INT16:
      case schema::Type::INT32:
      case schema::Type::INT64:
      case schema::Type::UINT8:
      case schema::Type::UINT16:
      case schema::Type::UINT32:
      case schema::Type::UINT64:
      case schema::Type::FLOAT32:
      case schema::Type::FLOAT64:
      case schema::Type::ENUM:
        return Section::DATA;
      case schema::Type::TEXT:
      case schema::Type::DATA:
      case schema::Type::LIST:
      case schema::Type::STRUCT:
      case schema::Type::INTERFACE:
      case schema::Type::ANY_POINTER:
        return Section::POINTERS;
    }
    KJ_UNREACHABLE;
  }

  static kj::StringPtr maskType(schema::Type::Which whichType) {
    switch (whichType) {
      case schema::Type::BOOL: return "bool";
      case schema::Type::INT8: return " ::uint8_t";
      case schema::Type::INT16: return " ::uint16_t";
      case schema::Type::INT32: return " ::uint32_t";
      case schema::Type::INT64: return " ::uint64_t";
      case schema::Type::UINT8: return " ::uint8_t";
      case schema::Type::UINT16: return " ::uint16_t";
      case schema::Type::UINT32: return " ::uint32_t";
      case schema::Type::UINT64: return " ::uint64_t";
      case schema::Type::FLOAT32: return " ::uint32_t";
      case schema::Type::FLOAT64: return " ::uint64_t";
      case schema::Type::ENUM: return " ::uint16_t";

      case schema::Type::VOID:
      case schema::Type::TEXT:
      case schema::Type::DATA:
      case schema::Type::LIST:
      case schema::Type::STRUCT:
      case schema::Type::INTERFACE:
      case schema::Type::ANY_POINTER:
        KJ_FAIL_REQUIRE("Should only be called for data types.");
    }
    KJ_UNREACHABLE;
  }

  struct Slot {
    schema::Type::Which whichType;
    uint offset;

    bool isSupersetOf(Slot other) const {
      auto section = sectionFor(whichType);
      if (section != sectionFor(other.whichType)) return false;
      switch (section) {
        case Section::NONE:
          return true;  // all voids overlap
        case Section::DATA: {
          auto bits = typeSizeBits(whichType);
          auto start = offset * bits;
          auto otherBits = typeSizeBits(other.whichType);
          auto otherStart = other.offset * otherBits;
          return start <= otherStart && otherStart + otherBits <= start + bits;
        }
        case Section::POINTERS:
          return offset == other.offset;
      }
      KJ_UNREACHABLE;
    }

    bool operator<(Slot other) const {
      // Sort by section, then start position, and finally size.

      auto section = sectionFor(whichType);
      auto otherSection = sectionFor(other.whichType);
      if (section < otherSection) {
        return true;
      } else if (section > otherSection) {
        return false;
      }

      switch (section) {
        case Section::NONE:
          return false;
        case Section::DATA: {
          auto bits = typeSizeBits(whichType);
          auto start = offset * bits;
          auto otherBits = typeSizeBits(other.whichType);
          auto otherStart = other.offset * otherBits;
          if (start < otherStart) {
            return true;
          } else if (start > otherStart) {
            return false;
          }

          // Sort larger sizes before smaller.
          return bits > otherBits;
        }
        case Section::POINTERS:
          return offset < other.offset;
      }
      KJ_UNREACHABLE;
    }
  };

  void getSlots(StructSchema schema, kj::Vector<Slot>& slots) {
    auto structProto = schema.getProto().getStruct();
    if (structProto.getDiscriminantCount() > 0) {
      slots.add(Slot { schema::Type::UINT16, structProto.getDiscriminantOffset() });
    }

    for (auto field: schema.getFields()) {
      auto proto = field.getProto();
      switch (proto.which()) {
        case schema::Field::SLOT: {
          auto slot = proto.getSlot();
          slots.add(Slot { slot.getType().which(), slot.getOffset() });
          break;
        }
        case schema::Field::GROUP:
          getSlots(field.getType().asStruct(), slots);
          break;
      }
    }
  }

  kj::Array<Slot> getSortedSlots(StructSchema schema) {
    // Get a representation of all of the field locations owned by this schema, e.g. so that they
    // can be zero'd out.

    kj::Vector<Slot> slots(schema.getFields().size());
    getSlots(schema, slots);
    std::sort(slots.begin(), slots.end());

    kj::Vector<Slot> result(slots.size());

    // All void slots are redundant, and they sort towards the front of the list.  By starting out
    // with `prevSlot` = void, we will end up skipping them all, which is what we want.
    Slot prevSlot = { schema::Type::VOID, 0 };
    for (auto slot: slots) {
      if (prevSlot.isSupersetOf(slot)) {
        // This slot is redundant as prevSlot is a superset of it.
        continue;
      }

      // Since all sizes are power-of-two, if two slots overlap at all, one must be a superset of
      // the other.  Since we sort slots by starting position, we know that the only way `slot`
      // could be a superset of `prevSlot` is if they have the same starting position.  However,
      // since we sort slots with the same starting position by descending size, this is not
      // possible.
      KJ_DASSERT(!slot.isSupersetOf(prevSlot));

      result.add(slot);

      prevSlot = slot;
    }

    return result.releaseAsArray();
  }

  // -----------------------------------------------------------------

  struct DiscriminantChecks {
    kj::String has;
    kj::String check;
    kj::String set;
    kj::StringTree readerIsDecl;
    kj::StringTree builderIsDecl;
    kj::StringTree isDefs;
  };

  DiscriminantChecks makeDiscriminantChecks(kj::StringPtr scope,
                                            kj::StringPtr memberName,
                                            StructSchema containingStruct,
                                            const TemplateContext& templateContext) {
    auto discrimOffset = containingStruct.getProto().getStruct().getDiscriminantOffset();

    kj::String titleCase = toTitleCase(memberName);
    kj::String upperCase = toUpperCase(memberName);

    return DiscriminantChecks {
        kj::str(
            "  if (which() != ", scope, upperCase, ") return false;\n"),
        kj::str(
            // Extra parens around the condition are needed for when we're compiling a multi-arg
            // generic type, which will have a comma, which would otherwise mess up the macro.
            // Ah, C++.
            "  KJ_IREQUIRE((which() == ", scope, upperCase, "),\n"
            "              \"Must check which() before get()ing a union member.\");\n"),
        kj::str(
            "  _builder.setDataField<", scope, "Which>(\n"
            "      ::capnp::bounded<", discrimOffset, ">() * ::capnp::ELEMENTS, ",
                      scope, upperCase, ");\n"),
        kj::strTree("  inline bool is", titleCase, "() const;\n"),
        kj::strTree("  inline bool is", titleCase, "();\n"),
        kj::strTree(
            templateContext.allDecls(),
            "inline bool ", scope, "Reader::is", titleCase, "() const {\n"
            "  return which() == ", scope, upperCase, ";\n"
            "}\n",
            templateContext.allDecls(),
            "inline bool ", scope, "Builder::is", titleCase, "() {\n"
            "  return which() == ", scope, upperCase, ";\n"
            "}\n")
    };
  }

  // -----------------------------------------------------------------

  struct FieldText {
    kj::StringTree readerMethodDecls;
    kj::StringTree builderMethodDecls;
    kj::StringTree pipelineMethodDecls;
    kj::StringTree inlineMethodDefs;
  };

  enum class FieldKind {
    PRIMITIVE,
    BLOB,
    STRUCT,
    LIST,
    INTERFACE,
    ANY_POINTER,
    BRAND_PARAMETER
  };

  FieldText makeFieldText(kj::StringPtr scope, StructSchema::Field field,
                          const TemplateContext& templateContext) {
    auto proto = field.getProto();
    auto typeSchema = field.getType();
    auto baseName = protoName(proto);
    kj::String titleCase = toTitleCase(baseName);

    DiscriminantChecks unionDiscrim;
    if (hasDiscriminantValue(proto)) {
      unionDiscrim = makeDiscriminantChecks(scope, baseName, field.getContainingStruct(),
                                            templateContext);
    }

    switch (proto.which()) {
      case schema::Field::SLOT:
        // Continue below.
        break;

      case schema::Field::GROUP: {
        auto slots = getSortedSlots(field.getType().asStruct());
        return FieldText {
            kj::strTree(
                kj::mv(unionDiscrim.readerIsDecl),
                "  inline typename ", titleCase, "::Reader get", titleCase, "() const;\n"
                "\n"),

            kj::strTree(
                kj::mv(unionDiscrim.builderIsDecl),
                "  inline typename ", titleCase, "::Builder get", titleCase, "();\n"
                "  inline typename ", titleCase, "::Builder init", titleCase, "();\n"
                "\n"),

            hasDiscriminantValue(proto) ? kj::strTree() :
                kj::strTree("  inline typename ", titleCase, "::Pipeline get", titleCase, "();\n"),

            kj::strTree(
                kj::mv(unionDiscrim.isDefs),
                templateContext.allDecls(),
                "inline typename ", scope, titleCase, "::Reader ", scope, "Reader::get", titleCase, "() const {\n",
                unionDiscrim.check,
                "  return typename ", scope, titleCase, "::Reader(_reader);\n"
                "}\n",
                templateContext.allDecls(),
                "inline typename ", scope, titleCase, "::Builder ", scope, "Builder::get", titleCase, "() {\n",
                unionDiscrim.check,
                "  return typename ", scope, titleCase, "::Builder(_builder);\n"
                "}\n",
                hasDiscriminantValue(proto) ? kj::strTree() : kj::strTree(
                  "#if !CAPNP_LITE\n",
                  templateContext.allDecls(),
                  "inline typename ", scope, titleCase, "::Pipeline ", scope, "Pipeline::get", titleCase, "() {\n",
                  "  return typename ", scope, titleCase, "::Pipeline(_typeless.noop());\n"
                  "}\n"
                  "#endif  // !CAPNP_LITE\n"),
                templateContext.allDecls(),
                "inline typename ", scope, titleCase, "::Builder ", scope, "Builder::init", titleCase, "() {\n",
                unionDiscrim.set,
                KJ_MAP(slot, slots) {
                  switch (sectionFor(slot.whichType)) {
                    case Section::NONE:
                      return kj::strTree();
                    case Section::DATA:
                      return kj::strTree(
                          "  _builder.setDataField<", maskType(slot.whichType), ">(::capnp::bounded<",
                              slot.offset, ">() * ::capnp::ELEMENTS, 0);\n");
                    case Section::POINTERS:
                      return kj::strTree(
                          "  _builder.getPointerField(::capnp::bounded<", slot.offset,
                              ">() * ::capnp::POINTERS).clear();\n");
                  }
                  KJ_UNREACHABLE;
                },
                "  return typename ", scope, titleCase, "::Builder(_builder);\n"
                "}\n")
          };
      }
    }

    auto slot = proto.getSlot();

    FieldKind kind = FieldKind::PRIMITIVE;
    kj::String ownedType;
    CppTypeName type = typeName(typeSchema, nullptr);
    kj::StringPtr setterDefault;  // only for void
    kj::String defaultMask;    // primitives only
    size_t defaultOffset = 0;    // pointers only: offset of the default value within the schema.
    size_t defaultSize = 0;      // blobs only: byte size of the default value.

    auto defaultBody = slot.getDefaultValue();
    switch (typeSchema.which()) {
      case schema::Type::VOID:
        kind = FieldKind::PRIMITIVE;
        setterDefault = " = ::capnp::VOID";
        break;

#define HANDLE_PRIMITIVE(discrim, typeName, defaultName, suffix) \
      case schema::Type::discrim: \
        kind = FieldKind::PRIMITIVE; \
        if (defaultBody.get##defaultName() != 0) { \
          defaultMask = kj::str(defaultBody.get##defaultName(), #suffix); \
        } \
        break;

      HANDLE_PRIMITIVE(BOOL, bool, Bool, );
      HANDLE_PRIMITIVE(INT8 , ::int8_t , Int8 , );
      HANDLE_PRIMITIVE(INT16, ::int16_t, Int16, );
      HANDLE_PRIMITIVE(INT32, ::int32_t, Int32, );
      HANDLE_PRIMITIVE(INT64, ::int64_t, Int64, ll);
      HANDLE_PRIMITIVE(UINT8 , ::uint8_t , Uint8 , u);
      HANDLE_PRIMITIVE(UINT16, ::uint16_t, Uint16, u);
      HANDLE_PRIMITIVE(UINT32, ::uint32_t, Uint32, u);
      HANDLE_PRIMITIVE(UINT64, ::uint64_t, Uint64, ull);
#undef HANDLE_PRIMITIVE

      case schema::Type::FLOAT32:
        kind = FieldKind::PRIMITIVE;
        if (defaultBody.getFloat32() != 0) {
          uint32_t mask;
          float value = defaultBody.getFloat32();
          static_assert(sizeof(mask) == sizeof(value), "bug");
          memcpy(&mask, &value, sizeof(mask));
          defaultMask = kj::str(mask, "u");
        }
        break;

      case schema::Type::FLOAT64:
        kind = FieldKind::PRIMITIVE;
        if (defaultBody.getFloat64() != 0) {
          uint64_t mask;
          double value = defaultBody.getFloat64();
          static_assert(sizeof(mask) == sizeof(value), "bug");
          memcpy(&mask, &value, sizeof(mask));
          defaultMask = kj::str(mask, "ull");
        }
        break;

      case schema::Type::TEXT:
        kind = FieldKind::BLOB;
        if (defaultBody.hasText()) {
          defaultOffset = field.getDefaultValueSchemaOffset();
          defaultSize = defaultBody.getText().size();
        }
        break;
      case schema::Type::DATA:
        kind = FieldKind::BLOB;
        if (defaultBody.hasData()) {
          defaultOffset = field.getDefaultValueSchemaOffset();
          defaultSize = defaultBody.getData().size();
        }
        break;

      case schema::Type::ENUM:
        kind = FieldKind::PRIMITIVE;
        if (defaultBody.getEnum() != 0) {
          defaultMask = kj::str(defaultBody.getEnum(), "u");
        }
        break;

      case schema::Type::STRUCT:
        kind = FieldKind::STRUCT;
        if (defaultBody.hasStruct()) {
          defaultOffset = field.getDefaultValueSchemaOffset();
        }
        break;
      case schema::Type::LIST:
        kind = FieldKind::LIST;
        if (defaultBody.hasList()) {
          defaultOffset = field.getDefaultValueSchemaOffset();
        }
        break;
      case schema::Type::INTERFACE:
        kind = FieldKind::INTERFACE;
        break;
      case schema::Type::ANY_POINTER:
        if (defaultBody.hasAnyPointer()) {
          defaultOffset = field.getDefaultValueSchemaOffset();
        }
        if (typeSchema.getBrandParameter() != nullptr) {
          kind = FieldKind::BRAND_PARAMETER;
        } else {
          kind = FieldKind::ANY_POINTER;
          switch (typeSchema.whichAnyPointerKind()) {
            case schema::Type::AnyPointer::Unconstrained::ANY_KIND:
              kind = FieldKind::ANY_POINTER;
              break;
            case schema::Type::AnyPointer::Unconstrained::STRUCT:
              kind = FieldKind::STRUCT;
              break;
            case schema::Type::AnyPointer::Unconstrained::LIST:
              kind = FieldKind::LIST;
              break;
            case schema::Type::AnyPointer::Unconstrained::CAPABILITY:
              kind = FieldKind::INTERFACE;
              break;
          }
        }
        break;
    }

    kj::String defaultMaskParam;
    if (defaultMask.size() > 0) {
      defaultMaskParam = kj::str(", ", defaultMask);
    }

    uint offset = slot.getOffset();

    if (kind == FieldKind::PRIMITIVE) {
      return FieldText {
        kj::strTree(
            kj::mv(unionDiscrim.readerIsDecl),
            "  inline ", type, " get", titleCase, "() const;\n"
            "\n"),

        kj::strTree(
            kj::mv(unionDiscrim.builderIsDecl),
            "  inline ", type, " get", titleCase, "();\n"
            "  inline void set", titleCase, "(", type, " value", setterDefault, ");\n"
            "\n"),

        kj::strTree(),

        kj::strTree(
            kj::mv(unionDiscrim.isDefs),
            templateContext.allDecls(),
            "inline ", type, " ", scope, "Reader::get", titleCase, "() const {\n",
            unionDiscrim.check,
            "  return _reader.getDataField<", type, ">(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::ELEMENTS", defaultMaskParam, ");\n",
            "}\n"
            "\n",
            templateContext.allDecls(),
            "inline ", type, " ", scope, "Builder::get", titleCase, "() {\n",
            unionDiscrim.check,
            "  return _builder.getDataField<", type, ">(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::ELEMENTS", defaultMaskParam, ");\n",
            "}\n",
            templateContext.allDecls(),
            "inline void ", scope, "Builder::set", titleCase, "(", type, " value) {\n",
            unionDiscrim.set,
            "  _builder.setDataField<", type, ">(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::ELEMENTS, value", defaultMaskParam, ");\n",
            "}\n"
            "\n")
      };

    } else if (kind == FieldKind::INTERFACE) {
      CppTypeName clientType = type;
      clientType.addMemberType("Client");

      return FieldText {
        kj::strTree(
            kj::mv(unionDiscrim.readerIsDecl),
            "  inline bool has", titleCase, "() const;\n"
            "#if !CAPNP_LITE\n"
            "  inline ", clientType, " get", titleCase, "() const;\n"
            "#endif  // !CAPNP_LITE\n"
            "\n"),

        kj::strTree(
            kj::mv(unionDiscrim.builderIsDecl),
            "  inline bool has", titleCase, "();\n"
            "#if !CAPNP_LITE\n"
            "  inline ", clientType, " get", titleCase, "();\n"
            "  inline void set", titleCase, "(", clientType, "&& value);\n",
            "  inline void set", titleCase, "(", clientType, "& value);\n",
            "  inline void adopt", titleCase, "(::capnp::Orphan<", type, ">&& value);\n"
            "  inline ::capnp::Orphan<", type, "> disown", titleCase, "();\n"
            "#endif  // !CAPNP_LITE\n"
            "\n"),

        kj::strTree(
            hasDiscriminantValue(proto) ? kj::strTree() : kj::strTree(
              "  inline ", clientType, " get", titleCase, "();\n")),

        kj::strTree(
            kj::mv(unionDiscrim.isDefs),
            templateContext.allDecls(),
            "inline bool ", scope, "Reader::has", titleCase, "() const {\n",
            unionDiscrim.has,
            "  return !_reader.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS).isNull();\n"
            "}\n",
            templateContext.allDecls(),
            "inline bool ", scope, "Builder::has", titleCase, "() {\n",
            unionDiscrim.has,
            "  return !_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS).isNull();\n"
            "}\n"
            "#if !CAPNP_LITE\n",
            templateContext.allDecls(),
            "inline ", clientType, " ", scope, "Reader::get", titleCase, "() const {\n",
            unionDiscrim.check,
            "  return ::capnp::_::PointerHelpers<", type, ">::get(_reader.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
            "}\n",
            templateContext.allDecls(),
            "inline ", clientType, " ", scope, "Builder::get", titleCase, "() {\n",
            unionDiscrim.check,
            "  return ::capnp::_::PointerHelpers<", type, ">::get(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
            "}\n",
            hasDiscriminantValue(proto) ? kj::strTree() : kj::strTree(
              templateContext.allDecls(),
              "inline ", clientType, " ", scope, "Pipeline::get", titleCase, "() {\n",
              "  return ", clientType, "(_typeless.getPointerField(", offset, ").asCap());\n"
              "}\n"),
            templateContext.allDecls(),
            "inline void ", scope, "Builder::set", titleCase, "(", clientType, "&& cap) {\n",
            unionDiscrim.set,
            "  ::capnp::_::PointerHelpers<", type, ">::set(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), kj::mv(cap));\n"
            "}\n",
            templateContext.allDecls(),
            "inline void ", scope, "Builder::set", titleCase, "(", clientType, "& cap) {\n",
            unionDiscrim.set,
            "  ::capnp::_::PointerHelpers<", type, ">::set(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), cap);\n"
            "}\n",
            templateContext.allDecls(),
            "inline void ", scope, "Builder::adopt", titleCase, "(\n"
            "    ::capnp::Orphan<", type, ">&& value) {\n",
            unionDiscrim.set,
            "  ::capnp::_::PointerHelpers<", type, ">::adopt(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), kj::mv(value));\n"
            "}\n",
            templateContext.allDecls(),
            "inline ::capnp::Orphan<", type, "> ", scope, "Builder::disown", titleCase, "() {\n",
            unionDiscrim.check,
            "  return ::capnp::_::PointerHelpers<", type, ">::disown(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
            "}\n"
            "#endif  // !CAPNP_LITE\n"
            "\n")
      };

    } else if (kind == FieldKind::ANY_POINTER) {
      return FieldText {
        kj::strTree(
            kj::mv(unionDiscrim.readerIsDecl),
            "  inline bool has", titleCase, "() const;\n"
            "  inline ::capnp::AnyPointer::Reader get", titleCase, "() const;\n"
            "\n"),

        kj::strTree(
            kj::mv(unionDiscrim.builderIsDecl),
            "  inline bool has", titleCase, "();\n"
            "  inline ::capnp::AnyPointer::Builder get", titleCase, "();\n"
            "  inline ::capnp::AnyPointer::Builder init", titleCase, "();\n"
            "\n"),

        kj::strTree(),

        kj::strTree(
            kj::mv(unionDiscrim.isDefs),
            templateContext.allDecls(),
            "inline bool ", scope, "Reader::has", titleCase, "() const {\n",
            unionDiscrim.has,
            "  return !_reader.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS).isNull();\n"
            "}\n",
            templateContext.allDecls(),
            "inline bool ", scope, "Builder::has", titleCase, "() {\n",
            unionDiscrim.has,
            "  return !_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS).isNull();\n"
            "}\n",
            templateContext.allDecls(),
            "inline ::capnp::AnyPointer::Reader ", scope, "Reader::get", titleCase, "() const {\n",
            unionDiscrim.check,
            "  return ::capnp::AnyPointer::Reader(_reader.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
            "}\n",
            templateContext.allDecls(),
            "inline ::capnp::AnyPointer::Builder ", scope, "Builder::get", titleCase, "() {\n",
            unionDiscrim.check,
            "  return ::capnp::AnyPointer::Builder(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
            "}\n",
            templateContext.allDecls(),
            "inline ::capnp::AnyPointer::Builder ", scope, "Builder::init", titleCase, "() {\n",
            unionDiscrim.set,
            "  auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
            "  result.clear();\n"
            "  return result;\n"
            "}\n"
            "\n")
      };

    } else {
      // Blob, struct, list, or template param.  These have only minor differences.

      uint64_t typeId = field.getContainingStruct().getProto().getId();
      kj::String defaultParam = defaultOffset == 0 ? kj::str() : kj::str(
          ",\n        ::capnp::schemas::bp_", kj::hex(typeId), " + ", defaultOffset,
          defaultSize == 0 ? kj::strTree() : kj::strTree(", ", defaultSize));

      bool shouldIncludeStructInit =
          kind == FieldKind::STRUCT || kind == FieldKind::BRAND_PARAMETER;
      bool shouldIncludeSizedInit =
          kind != FieldKind::STRUCT || kind == FieldKind::BRAND_PARAMETER;
      bool shouldIncludePipelineGetter = !hasDiscriminantValue(proto) &&
          (kind == FieldKind::STRUCT || kind == FieldKind::BRAND_PARAMETER);
      bool shouldIncludeArrayInitializer = false;
      bool shouldExcludeInLiteMode = type.hasInterfaces();
      bool shouldTemplatizeInit = typeSchema.which() == schema::Type::ANY_POINTER &&
          kind != FieldKind::BRAND_PARAMETER;

      CppTypeName elementReaderType;
      if (typeSchema.isList()) {
        bool primitiveElement = false;
        bool interface = false;
        auto elementType = typeSchema.asList().getElementType();
        switch (elementType.which()) {
          case schema::Type::VOID:
          case schema::Type::BOOL:
          case schema::Type::INT8:
          case schema::Type::INT16:
          case schema::Type::INT32:
          case schema::Type::INT64:
          case schema::Type::UINT8:
          case schema::Type::UINT16:
          case schema::Type::UINT32:
          case schema::Type::UINT64:
          case schema::Type::FLOAT32:
          case schema::Type::FLOAT64:
          case schema::Type::ENUM:
            primitiveElement = true;
            shouldIncludeArrayInitializer = true;
            break;

          case schema::Type::TEXT:
          case schema::Type::DATA:
          case schema::Type::LIST:
            primitiveElement = false;
            shouldIncludeArrayInitializer = true;
            break;

          case schema::Type::ANY_POINTER:
            primitiveElement = false;
            shouldIncludeArrayInitializer = elementType.getBrandParameter() != nullptr;
            break;

          case schema::Type::INTERFACE:
            primitiveElement = false;
            interface = true;
            break;

          case schema::Type::STRUCT:
            primitiveElement = false;
            break;
        }
        elementReaderType = typeName(elementType, nullptr);
        if (!primitiveElement) {
          if (interface) {
            elementReaderType.addMemberType("Client");
          } else {
            elementReaderType.addMemberType("Reader");
          }
        }
      };

      CppTypeName readerType;
      CppTypeName builderType;
      CppTypeName pipelineType;
      if (kind == FieldKind::BRAND_PARAMETER) {
        readerType = CppTypeName::makeNamespace("capnp");
        readerType.addMemberTemplate("ReaderFor", kj::heapArray(&type, 1));
        builderType = CppTypeName::makeNamespace("capnp");
        builderType.addMemberTemplate("BuilderFor", kj::heapArray(&type, 1));
        pipelineType = CppTypeName::makeNamespace("capnp");
        pipelineType.addMemberTemplate("PipelineFor", kj::heapArray(&type, 1));
      } else {
        readerType = type;
        readerType.addMemberType("Reader");
        builderType = type;
        builderType.addMemberType("Builder");
        pipelineType = type;
        pipelineType.addMemberType("Pipeline");
      }

      #define COND(cond, ...) ((cond) ? kj::strTree(__VA_ARGS__) : kj::strTree())

      return FieldText {
        kj::strTree(
            kj::mv(unionDiscrim.readerIsDecl),
            "  inline bool has", titleCase, "() const;\n",
            COND(shouldExcludeInLiteMode, "#if !CAPNP_LITE\n"),
            "  inline ", readerType, " get", titleCase, "() const;\n",
            COND(shouldExcludeInLiteMode, "#endif  // !CAPNP_LITE\n"),
            "\n"),

        kj::strTree(
            kj::mv(unionDiscrim.builderIsDecl),
            "  inline bool has", titleCase, "();\n",
            COND(shouldExcludeInLiteMode, "#if !CAPNP_LITE\n"),
            "  inline ", builderType, " get", titleCase, "();\n"
            "  inline void set", titleCase, "(", readerType, " value);\n",
            COND(shouldIncludeArrayInitializer,
              "  inline void set", titleCase, "(::kj::ArrayPtr<const ", elementReaderType, "> value);\n"),
            COND(shouldIncludeStructInit,
              COND(shouldTemplatizeInit,
                "  template <typename T_>\n"
                "  inline ::capnp::BuilderFor<T_> init", titleCase, "As();\n"),
              COND(!shouldTemplatizeInit,
                "  inline ", builderType, " init", titleCase, "();\n")),
            COND(shouldIncludeSizedInit,
              COND(shouldTemplatizeInit,
                "  template <typename T_>\n"
                "  inline ::capnp::BuilderFor<T_> init", titleCase, "As(unsigned int size);\n"),
              COND(!shouldTemplatizeInit,
                "  inline ", builderType, " init", titleCase, "(unsigned int size);\n")),
            "  inline void adopt", titleCase, "(::capnp::Orphan<", type, ">&& value);\n"
            "  inline ::capnp::Orphan<", type, "> disown", titleCase, "();\n",
            COND(shouldExcludeInLiteMode, "#endif  // !CAPNP_LITE\n"),
            "\n"),

        kj::strTree(
            COND(shouldIncludePipelineGetter,
              "  inline ", pipelineType, " get", titleCase, "();\n")),

        kj::strTree(
            kj::mv(unionDiscrim.isDefs),
            templateContext.allDecls(),
            "inline bool ", scope, "Reader::has", titleCase, "() const {\n",
            unionDiscrim.has,
            "  return !_reader.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS).isNull();\n"
            "}\n",
            templateContext.allDecls(),
            "inline bool ", scope, "Builder::has", titleCase, "() {\n",
            unionDiscrim.has,
            "  return !_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS).isNull();\n"
            "}\n",
            COND(shouldExcludeInLiteMode, "#if !CAPNP_LITE\n"),
            templateContext.allDecls(),
            "inline ", readerType, " ", scope, "Reader::get", titleCase, "() const {\n",
            unionDiscrim.check,
            "  return ::capnp::_::PointerHelpers<", type, ">::get(_reader.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS)", defaultParam, ");\n"
            "}\n",
            templateContext.allDecls(),
            "inline ", builderType, " ", scope, "Builder::get", titleCase, "() {\n",
            unionDiscrim.check,
            "  return ::capnp::_::PointerHelpers<", type, ">::get(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS)", defaultParam, ");\n"
            "}\n",
            COND(shouldIncludePipelineGetter,
              "#if !CAPNP_LITE\n",
              templateContext.allDecls(),
              "inline ", pipelineType, " ", scope, "Pipeline::get", titleCase, "() {\n",
              "  return ", pipelineType, "(_typeless.getPointerField(", offset, "));\n"
              "}\n"
              "#endif  // !CAPNP_LITE\n"),
            templateContext.allDecls(),
            "inline void ", scope, "Builder::set", titleCase, "(", readerType, " value) {\n",
            unionDiscrim.set,
            "  ::capnp::_::PointerHelpers<", type, ">::set(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), value);\n"
            "}\n",
            COND(shouldIncludeArrayInitializer,
              templateContext.allDecls(),
              "inline void ", scope, "Builder::set", titleCase, "(::kj::ArrayPtr<const ", elementReaderType, "> value) {\n",
              unionDiscrim.set,
              "  ::capnp::_::PointerHelpers<", type, ">::set(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), value);\n"
              "}\n"),
            COND(shouldIncludeStructInit,
              COND(shouldTemplatizeInit,
                templateContext.allDecls(),
                "template <typename T_>\n"
                "inline ::capnp::BuilderFor<T_> ", scope, "Builder::init", titleCase, "As() {\n",
                "  static_assert(::capnp::kind<T_>() == ::capnp::Kind::STRUCT,\n"
                "                \"", proto.getName(), " must be a struct\");\n",
                unionDiscrim.set,
                "  return ::capnp::_::PointerHelpers<T_>::init(_builder.getPointerField(\n"
                "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
                "}\n"),
              COND(!shouldTemplatizeInit,
                templateContext.allDecls(),
                "inline ", builderType, " ", scope, "Builder::init", titleCase, "() {\n",
                unionDiscrim.set,
                "  return ::capnp::_::PointerHelpers<", type, ">::init(_builder.getPointerField(\n"
                "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
                "}\n")),
            COND(shouldIncludeSizedInit,
              COND(shouldTemplatizeInit,
                templateContext.allDecls(),
                "template <typename T_>\n"
                "inline ::capnp::BuilderFor<T_> ", scope, "Builder::init", titleCase, "As(unsigned int size) {\n",
                "  static_assert(::capnp::kind<T_>() == ::capnp::Kind::LIST,\n"
                "                \"", proto.getName(), " must be a list\");\n",
                unionDiscrim.set,
                "  return ::capnp::_::PointerHelpers<T_>::init(_builder.getPointerField(\n"
                "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), size);\n"
                "}\n"),
              COND(!shouldTemplatizeInit,
                templateContext.allDecls(),
                "inline ", builderType, " ", scope, "Builder::init", titleCase, "(unsigned int size) {\n",
                unionDiscrim.set,
                "  return ::capnp::_::PointerHelpers<", type, ">::init(_builder.getPointerField(\n"
                "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), size);\n"
                "}\n")),
            templateContext.allDecls(),
            "inline void ", scope, "Builder::adopt", titleCase, "(\n"
            "    ::capnp::Orphan<", type, ">&& value) {\n",
            unionDiscrim.set,
            "  ::capnp::_::PointerHelpers<", type, ">::adopt(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS), kj::mv(value));\n"
            "}\n",
            COND(type.hasDisambiguatedTemplate(),
                "#if !defined(_MSC_VER) || defined(__clang__)\n"
                "// Excluded under MSVC because bugs may make it unable to compile this method.\n"),
            templateContext.allDecls(),
            "inline ::capnp::Orphan<", type, "> ", scope, "Builder::disown", titleCase, "() {\n",
            unionDiscrim.check,
            "  return ::capnp::_::PointerHelpers<", type, ">::disown(_builder.getPointerField(\n"
            "      ::capnp::bounded<", offset, ">() * ::capnp::POINTERS));\n"
            "}\n",
            COND(type.hasDisambiguatedTemplate(), "#endif  // !_MSC_VER || __clang__\n"),
            COND(shouldExcludeInLiteMode, "#endif  // !CAPNP_LITE\n"),
            "\n")
      };

      #undef COND
    }
  }

  // -----------------------------------------------------------------

  enum class AsGenericRole { READER, BUILDER, CLIENT };

  kj::StringTree makeAsGenericDef(AsGenericRole role, const TemplateContext& templateContext,
                                  kj::StringPtr type, kj::String innerType = kj::String()) {
    if (!templateContext.isGeneric()) {
      return kj::StringTree();
    }
    kj::StringTree self, up;
    if (templateContext.hasParams()) {
      auto returnType = [&]() {
        return kj::strTree(type, templateContext.args("2"), innerType);
      };
      kj::StringTree asGeneric = kj::strTree("as", innerType.size() ? type : "", "Generic()");
      switch (role) {
        case AsGenericRole::READER:
          self = kj::strTree(
              "  ", templateContext.decl(true, "2"),
              "  typename ", returnType(), "::Reader ", kj::mv(asGeneric), " {\n"
              "    return typename ", returnType(), "::Reader(_reader);\n"
              "  }\n"
              "\n");
          break;
        case AsGenericRole::BUILDER:
          self = kj::strTree(
              "  ", templateContext.decl(true, "2"),
              "  typename ", returnType(), "::Builder ", kj::mv(asGeneric), " {\n"
              "    return typename ", returnType(), "::Builder(_builder);\n"
              "  }\n"
              "\n");
          break;
        case AsGenericRole::CLIENT:
          self = kj::strTree(
              "  ", templateContext.decl(true, "2"),
              "  typename ", returnType(), "::Client ", kj::mv(asGeneric), " {\n"
              "    return castAs<", innerType.size() ? "typename " : "", returnType(), ">();\n"
              "  }\n"
              "\n");
          break;
      }
    }
    KJ_IF_MAYBE(p, templateContext.getParent()) {
      up = makeAsGenericDef(role, *p, p->getName(), kj::strTree(
          templateContext.hasParams() ? "::template " : "::", type,
          templateContext.args()).flatten());
    }
    return kj::strTree(kj::mv(self), kj::mv(up));
  }

  // -----------------------------------------------------------------

  struct StructText {
    kj::StringTree outerTypeDecl;
    kj::StringTree outerTypeDef;
    kj::StringTree readerBuilderDefs;
    kj::StringTree inlineMethodDefs;
    kj::StringTree sourceDefs;
  };

  kj::StringTree makeReaderDef(kj::StringPtr fullName, kj::StringPtr unqualifiedParentType,
                               const TemplateContext& templateContext, bool isUnion,
                               kj::Array<kj::StringTree>&& methodDecls) {
    return kj::strTree(
        templateContext.allDecls(),
        "class ", fullName, "::Reader {\n"
        "public:\n"
        "  typedef ", unqualifiedParentType, " Reads;\n"
        "\n"
        "  Reader() = default;\n"
        "  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}\n"
        "\n"
        "  inline ::capnp::MessageSize totalSize() const {\n"
        "    return _reader.totalSize().asPublic();\n"
        "  }\n"
        "\n"
        "#if !CAPNP_LITE\n"
        "  inline ::kj::StringTree toString() const {\n"
        "    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());\n"
        "  }\n"
        "#endif  // !CAPNP_LITE\n"
        "\n",
        makeAsGenericDef(AsGenericRole::READER, templateContext, unqualifiedParentType),
        isUnion ? kj::strTree("  inline Which which() const;\n") : kj::strTree(),
        kj::mv(methodDecls),
        "private:\n"
        "  ::capnp::_::StructReader _reader;\n"
        "  template <typename, ::capnp::Kind>\n"
        "  friend struct ::capnp::ToDynamic_;\n"
        "  template <typename, ::capnp::Kind>\n"
        "  friend struct ::capnp::_::PointerHelpers;\n"
        "  template <typename, ::capnp::Kind>\n"
        "  friend struct ::capnp::List;\n"
        "  friend class ::capnp::MessageBuilder;\n"
        "  friend class ::capnp::Orphanage;\n"
        "};\n"
        "\n");
  }

  kj::StringTree makeBuilderDef(kj::StringPtr fullName, kj::StringPtr unqualifiedParentType,
                                const TemplateContext& templateContext, bool isUnion,
                                kj::Array<kj::StringTree>&& methodDecls) {
    return kj::strTree(
        templateContext.allDecls(),
        "class ", fullName, "::Builder {\n"
        "public:\n"
        "  typedef ", unqualifiedParentType, " Builds;\n"
        "\n"
        "  Builder() = delete;  // Deleted to discourage incorrect usage.\n"
        "                       // You can explicitly initialize to nullptr instead.\n"
        "  inline Builder(decltype(nullptr)) {}\n"
        "  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}\n"
        "  inline operator Reader() const { return Reader(_builder.asReader()); }\n"
        "  inline Reader asReader() const { return *this; }\n"
        "\n"
        "  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }\n"
        "#if !CAPNP_LITE\n"
        "  inline ::kj::StringTree toString() const { return asReader().toString(); }\n"
        "#endif  // !CAPNP_LITE\n"
        "\n",
        makeAsGenericDef(AsGenericRole::BUILDER, templateContext, unqualifiedParentType),
        isUnion ? kj::strTree("  inline Which which();\n") : kj::strTree(),
        kj::mv(methodDecls),
        "private:\n"
        "  ::capnp::_::StructBuilder _builder;\n"
        "  template <typename, ::capnp::Kind>\n"
        "  friend struct ::capnp::ToDynamic_;\n"
        "  friend class ::capnp::Orphanage;\n",
        "  template <typename, ::capnp::Kind>\n"
        "  friend struct ::capnp::_::PointerHelpers;\n"
        "};\n"
        "\n");
  }

  kj::StringTree makePipelineDef(kj::StringPtr fullName, kj::StringPtr unqualifiedParentType,
                                 const TemplateContext& templateContext, bool isUnion,
                                 kj::Array<kj::StringTree>&& methodDecls) {
    return kj::strTree(
        "#if !CAPNP_LITE\n",
        templateContext.allDecls(),
        "class ", fullName, "::Pipeline {\n"
        "public:\n"
        "  typedef ", unqualifiedParentType, " Pipelines;\n"
        "\n"
        "  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}\n"
        "  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)\n"
        "      : _typeless(kj::mv(typeless)) {}\n"
        "\n",
        kj::mv(methodDecls),
        "private:\n"
        "  ::capnp::AnyPointer::Pipeline _typeless;\n"
        "  friend class ::capnp::PipelineHook;\n"
        "  template <typename, ::capnp::Kind>\n"
        "  friend struct ::capnp::ToDynamic_;\n"
        "};\n"
        "#endif  // !CAPNP_LITE\n"
        "\n");
  }

  kj::StringTree makeGenericDeclarations(const TemplateContext& templateContext,
                                         bool hasBrandDependencies) {
    // Returns the declarations for the private members of a generic struct/interface;
    // paired with the definitions from makeGenericDefinitions().
    return kj::strTree(
        "    static const ::capnp::_::RawBrandedSchema::Scope brandScopes[];\n"
        "    static const ::capnp::_::RawBrandedSchema::Binding brandBindings[];\n",
        (!hasBrandDependencies ? "" :
            "    static const ::capnp::_::RawBrandedSchema::Dependency brandDependencies[];\n"),
        "    static const ::capnp::_::RawBrandedSchema specificBrand;\n"
        "    static constexpr ::capnp::_::RawBrandedSchema const* brand() { "
        "return ::capnp::_::ChooseBrand<_capnpPrivate, ", templateContext.allArgs(), ">::brand(); }\n");
  }

  kj::StringTree makeGenericDefinitions(
      const TemplateContext& templateContext, kj::StringPtr fullName, kj::StringPtr hexId,
      BrandInitializerText brandInitializers) {
    // Returns the definitions for the members from makeGenericDeclarations().
    bool hasBrandDependencies = (brandInitializers.dependencies.size() != 0);

    auto scopeCount = templateContext.getScopeMap().size();
    auto dependencyCount = brandInitializers.dependencyCount;

    kj::String templates = kj::str(templateContext.allDecls());

    return kj::strTree(
        templates, "const ::capnp::_::RawBrandedSchema::Scope ", fullName,
        "::_capnpPrivate::brandScopes[] = ", kj::mv(brandInitializers.scopes), ";\n",

        templates, "const ::capnp::_::RawBrandedSchema::Binding ", fullName,
        "::_capnpPrivate::brandBindings[] = ", kj::mv(brandInitializers.bindings), ";\n",

        (!hasBrandDependencies ? kj::strTree("") : kj::strTree(
            templates, "const ::capnp::_::RawBrandedSchema::Dependency ", fullName,
            "::_capnpPrivate::brandDependencies[] = ", kj::mv(brandInitializers.dependencies),
            ";\n")),

        templates, "const ::capnp::_::RawBrandedSchema ", fullName, "::_capnpPrivate::specificBrand = {\n",
        "  &::capnp::schemas::s_", hexId, ", brandScopes, ",
        (!hasBrandDependencies ? "nullptr" : "brandDependencies"), ",\n",
        "  ", scopeCount, ", ", dependencyCount,
        ", nullptr\n"
        "};\n");
  }

  StructText makeStructText(kj::StringPtr scope, kj::StringPtr name, StructSchema schema,
                            kj::Array<kj::StringTree> nestedTypeDecls,
                            const TemplateContext& templateContext) {
    auto proto = schema.getProto();
    KJ_IF_MAYBE(annotatedName, annotationValue(proto, NAME_ANNOTATION_ID)) {
      name = annotatedName->getText();
    }
    auto fullName = kj::str(scope, name, templateContext.args());
    auto subScope = kj::str(fullName, "::");
    auto fieldTexts = KJ_MAP(f, schema.getFields()) {
      return makeFieldText(subScope, f, templateContext);
    };

    auto structNode = proto.getStruct();
    uint discrimOffset = structNode.getDiscriminantOffset();
    auto hexId = kj::hex(proto.getId());

    kj::String templates = kj::str(templateContext.allDecls());  // Ends with a newline

    // Private members struct
    kj::StringTree declareText = kj::strTree(
         "  struct _capnpPrivate {\n"
         "    CAPNP_DECLARE_STRUCT_HEADER(", hexId, ", ", structNode.getDataWordCount(), ", ",
         structNode.getPointerCount(), ")\n");

    kj::StringTree defineText = kj::strTree(
        "// ", fullName, "\n",
        "#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL\n",
        templates, "constexpr uint16_t ", fullName, "::_capnpPrivate::dataWordSize;\n",
        templates, "constexpr uint16_t ", fullName, "::_capnpPrivate::pointerCount;\n",
        "#endif  // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL\n",
        "#if !CAPNP_LITE\n",
        "#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL\n",
        templates, "constexpr ::capnp::Kind ", fullName, "::_capnpPrivate::kind;\n",
        templates, "constexpr ::capnp::_::RawSchema const* ", fullName, "::_capnpPrivate::schema;\n",
        "#endif  // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL\n");

    if (templateContext.isGeneric()) {
      auto brandInitializers = makeBrandInitializers(templateContext, schema);
      bool hasDeps = (brandInitializers.dependencies.size() != 0);

      declareText = kj::strTree(kj::mv(declareText),
          "    #if !CAPNP_LITE\n",
          makeGenericDeclarations(templateContext, hasDeps),
          "    #endif  // !CAPNP_LITE\n");

      defineText = kj::strTree(kj::mv(defineText),
          makeGenericDefinitions(
              templateContext, fullName, kj::str(hexId), kj::mv(brandInitializers)));
    } else {
      declareText = kj::strTree(kj::mv(declareText),
          "    #if !CAPNP_LITE\n"
          "    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }\n"
          "    #endif  // !CAPNP_LITE\n");
    }

    declareText = kj::strTree(kj::mv(declareText), "  };");
    defineText = kj::strTree(kj::mv(defineText), "#endif  // !CAPNP_LITE\n\n");

    // Name of the ::Which type, when applicable.
    CppTypeName whichName;
    if (structNode.getDiscriminantCount() != 0) {
      whichName = cppFullName(schema, nullptr);
      whichName.addMemberType("Which");
    }

    return StructText {
      kj::strTree(
          templateContext.hasParams() ? "  " : "", templateContext.decl(true),
          "  struct ", name, ";\n"),

      kj::strTree(
          templateContext.parentDecls(),
          templateContext.decl(scope == nullptr),
          "struct ", scope, name, " {\n",
          "  ", name, "() = delete;\n"
          "\n"
          "  class Reader;\n"
          "  class Builder;\n"
          "  class Pipeline;\n",
          structNode.getDiscriminantCount() == 0 ? kj::strTree() : kj::strTree(
              "  enum Which: uint16_t {\n",
              KJ_MAP(f, structNode.getFields()) {
                if (hasDiscriminantValue(f)) {
                  return kj::strTree("    ", toUpperCase(protoName(f)), ",\n");
                } else {
                  return kj::strTree();
                }
              },
              "  };\n"),
          KJ_MAP(n, nestedTypeDecls) { return kj::mv(n); },
          "\n",
          kj::mv(declareText), "\n",
          "};\n"
          "\n"),

      kj::strTree(
          makeReaderDef(fullName, name, templateContext, structNode.getDiscriminantCount() != 0,
                        KJ_MAP(f, fieldTexts) { return kj::mv(f.readerMethodDecls); }),
          makeBuilderDef(fullName, name, templateContext, structNode.getDiscriminantCount() != 0,
                         KJ_MAP(f, fieldTexts) { return kj::mv(f.builderMethodDecls); }),
          makePipelineDef(fullName, name, templateContext, structNode.getDiscriminantCount() != 0,
                          KJ_MAP(f, fieldTexts) { return kj::mv(f.pipelineMethodDecls); })),

      kj::strTree(
          structNode.getDiscriminantCount() == 0 ? kj::strTree() : kj::strTree(
              templateContext.allDecls(),
              "inline ", whichName, " ", fullName, "::Reader::which() const {\n"
              "  return _reader.getDataField<Which>(\n"
              "      ::capnp::bounded<", discrimOffset, ">() * ::capnp::ELEMENTS);\n"
              "}\n",
              templateContext.allDecls(),
              "inline ", whichName, " ", fullName, "::Builder::which() {\n"
              "  return _builder.getDataField<Which>(\n"
              "      ::capnp::bounded<", discrimOffset, ">() * ::capnp::ELEMENTS);\n"
              "}\n"
              "\n"),
          KJ_MAP(f, fieldTexts) { return kj::mv(f.inlineMethodDefs); }),

      kj::mv(defineText)
    };
  }

  // -----------------------------------------------------------------

  struct MethodText {
    kj::StringTree clientDecls;
    kj::StringTree serverDecls;
    kj::StringTree inlineDefs;
    kj::StringTree sourceDefs;
    kj::StringTree dispatchCase;
  };

  MethodText makeMethodText(kj::StringPtr interfaceName, InterfaceSchema::Method method,
                            const TemplateContext& templateContext) {
    auto proto = method.getProto();
    auto name = protoName(proto);
    auto titleCase = toTitleCase(name);
    auto paramSchema = method.getParamType();
    auto resultSchema = method.getResultType();
    auto identifierName = safeIdentifier(name);

    auto paramProto = paramSchema.getProto();
    auto resultProto = resultSchema.getProto();

    bool isStreaming = method.isStreaming();

    auto implicitParamsReader = proto.getImplicitParameters();
    auto implicitParamsBuilder = kj::heapArrayBuilder<CppTypeName>(implicitParamsReader.size());
    for (auto param: implicitParamsReader) {
      implicitParamsBuilder.add(CppTypeName::makeTemplateParam(param.getName()));
    }
    auto implicitParams = implicitParamsBuilder.finish();

    kj::String implicitParamsTemplateDecl;
    if (implicitParams.size() > 0) {
      implicitParamsTemplateDecl = kj::str(
          "template <", kj::StringTree(KJ_MAP(p, implicitParams) {
            return kj::strTree("typename ", p);
          }, ", "), ">\n");
    }


    CppTypeName interfaceTypeName = cppFullName(method.getContainingInterface(), nullptr);
    CppTypeName paramType;
    CppTypeName genericParamType;
    if (paramProto.getScopeId() == 0) {
      paramType = interfaceTypeName;
      if (implicitParams.size() == 0) {
        paramType.addMemberType(kj::str(titleCase, "Params"));
        genericParamType = paramType;
      } else {
        genericParamType = paramType;
        genericParamType.addMemberTemplate(kj::str(titleCase, "Params"), nullptr);
        paramType.addMemberTemplate(kj::str(titleCase, "Params"),
                                    kj::heapArray(implicitParams.asPtr()));
      }
    } else {
      paramType = cppFullName(paramSchema, method);
      genericParamType = cppFullName(paramSchema, nullptr);
    }
    CppTypeName resultType;
    CppTypeName genericResultType;
    if (isStreaming) {
      // We don't use resultType or genericResultType in this case. We want to avoid computing them
      // at all so that we don't end up marking stream.capnp.h in usedImports.
    } else if (resultProto.getScopeId() == 0) {
      resultType = interfaceTypeName;
      if (implicitParams.size() == 0) {
        resultType.addMemberType(kj::str(titleCase, "Results"));
        genericResultType = resultType;
      } else {
        genericResultType = resultType;
        genericResultType.addMemberTemplate(kj::str(titleCase, "Results"), nullptr);
        resultType.addMemberTemplate(kj::str(titleCase, "Results"),
                                     kj::heapArray(implicitParams.asPtr()));
      }
    } else {
      resultType = cppFullName(resultSchema, method);
      genericResultType = cppFullName(resultSchema, nullptr);
    }

    kj::String shortParamType = paramProto.getScopeId() == 0 ?
        kj::str(titleCase, "Params") : kj::str(genericParamType);
    kj::String shortResultType = resultProto.getScopeId() == 0 || isStreaming ?
        kj::str(titleCase, "Results") : kj::str(genericResultType);

    auto interfaceProto = method.getContainingInterface().getProto();
    uint64_t interfaceId = interfaceProto.getId();
    auto interfaceIdHex = kj::hex(interfaceId);
    uint16_t methodId = method.getIndex();

    // TODO(msvc):  Notice that the return type of this method's request function is supposed to be
    // `::capnp::Request<param, result>`. If the first template parameter to ::capnp::Request is a
    // template instantiation, MSVC will sometimes complain that it's unspecialized and can't be
    // used as a parameter in the return type (error C3203). It is not clear to me under what exact
    // conditions this bug occurs, but it commonly crops up in test.capnp.h.
    //
    // The easiest (and only) workaround I found is to use C++14's return type deduction here, thus
    // the `CAPNP_AUTO_IF_MSVC()` hackery in the return type declarations below. We're depending on
    // the fact that that this function has an inline implementation for the deduction to work.

    bool noPromisePipelining = !resultSchema.mayContainCapabilities();

    auto requestMethodImpl = kj::strTree(
        templateContext.allDecls(),
        implicitParamsTemplateDecl,
        templateContext.isGeneric() ? "CAPNP_AUTO_IF_MSVC(" : "",
        isStreaming ? kj::strTree("::capnp::StreamingRequest<", paramType, ">")
                    : kj::strTree("::capnp::Request<", paramType, ", ", resultType, ">"),
        templateContext.isGeneric() ? ")\n" : "\n",
        interfaceName, "::Client::", name, "Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) {\n",
        isStreaming
            ? kj::strTree("  return newStreamingCall<", paramType, ">(\n")
            : kj::strTree("  return newCall<", paramType, ", ", resultType, ">(\n"),
        "      0x", interfaceIdHex, "ull, ", methodId, ", sizeHint, {", noPromisePipelining, "});\n"
        "}\n");

    bool allowCancellation = false;
    if (annotationValue(proto, ALLOW_CANCELLATION_ANNOTATION_ID) != nullptr) {
      allowCancellation = true;
    } else if (annotationValue(interfaceProto, ALLOW_CANCELLATION_ANNOTATION_ID) != nullptr) {
      allowCancellation = true;
    } else {
      schema::Node::Reader node = interfaceProto;
      while (!node.isFile()) {
        node = schemaLoader.get(node.getScopeId()).getProto();
      }
      if (annotationValue(node, ALLOW_CANCELLATION_ANNOTATION_ID) != nullptr) {
        allowCancellation = true;
      }
    }

    return MethodText {
      kj::strTree(
          implicitParamsTemplateDecl.size() == 0 ? "" : "  ", implicitParamsTemplateDecl,
          templateContext.isGeneric() ? "  CAPNP_AUTO_IF_MSVC(" : "  ",
          isStreaming ? kj::strTree("::capnp::StreamingRequest<", paramType, ">")
                      : kj::strTree("::capnp::Request<", paramType, ", ", resultType, ">"),
          templateContext.isGeneric() ? ")" : "",
          " ", name, "Request(\n"
          "      ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr);\n"),

      kj::strTree(
          paramProto.getScopeId() != 0 ? kj::strTree() : kj::strTree(
              "  typedef ", genericParamType, " ", titleCase, "Params;\n"),
          resultProto.getScopeId() != 0 ? kj::strTree() : kj::strTree(
              "  typedef ", genericResultType, " ", titleCase, "Results;\n"),
          isStreaming
              ? kj::strTree("  typedef ::capnp::StreamingCallContext<", shortParamType, "> ")
              : kj::strTree(
                  "  typedef ::capnp::CallContext<", shortParamType, ", ", shortResultType, "> "),
              titleCase, "Context;\n"
          "  virtual ::kj::Promise<void> ", identifierName, "(", titleCase, "Context context);\n"),

      implicitParams.size() == 0 ? kj::strTree() : kj::mv(requestMethodImpl),

      kj::strTree(
          implicitParams.size() == 0 ? kj::mv(requestMethodImpl) : kj::strTree(),
          templateContext.allDecls(),
          "::kj::Promise<void> ", interfaceName, "::Server::", identifierName, "(", titleCase, "Context) {\n"
          "  return ::capnp::Capability::Server::internalUnimplemented(\n"
          "      \"", interfaceProto.getDisplayName(), "\", \"", name, "\",\n"
          "      0x", interfaceIdHex, "ull, ", methodId, ");\n"
          "}\n"),

      kj::strTree(
          "    case ", methodId, ":\n",
          isStreaming
            ? kj::strTree(
              // For streaming calls, we need to add an evalNow() here so that exceptions thrown
              // directly from the call can propagate to later calls. If we don't capture the
              // exception properly then the caller will never find out that this is a streaming
              // call (indicated by the boolean in the return value) so won't know to propagate
              // the exception.
              "      return {\n"
              "        kj::evalNow([&]() {\n"
              "          return ", identifierName, "(::capnp::Capability::Server::internalGetTypedStreamingContext<\n"
              "              ", genericParamType, ">(context));\n"
              "        }),\n"
              "        true,\n"
              "        ", allowCancellation, "\n"
              "      };\n")
            : kj::strTree(
              // For non-streaming calls we let exceptions just flow through for a little more
              // efficiency.
              "      return {\n"
              "        ", identifierName, "(::capnp::Capability::Server::internalGetTypedContext<\n"
              "            ", genericParamType, ", ", genericResultType, ">(context)),\n"
              "        false,\n"
              "        ", allowCancellation, "\n"
              "      };\n"))
    };
  }

  struct InterfaceText {
    kj::StringTree outerTypeDecl;
    kj::StringTree outerTypeDef;
    kj::StringTree clientServerDefs;
    kj::StringTree inlineMethodDefs;
    kj::StringTree sourceDefs;
  };

  struct ExtendInfo {
    CppTypeName typeName;
    uint64_t id;
  };

  void getTransitiveSuperclasses(InterfaceSchema schema, std::map<uint64_t, InterfaceSchema>& map) {
    if (map.insert(std::make_pair(schema.getProto().getId(), schema)).second) {
      for (auto sup: schema.getSuperclasses()) {
        getTransitiveSuperclasses(sup, map);
      }
    }
  }

  InterfaceText makeInterfaceText(kj::StringPtr scope, kj::StringPtr name, InterfaceSchema schema,
                                  kj::Array<kj::StringTree> nestedTypeDecls,
                                  const TemplateContext& templateContext) {
    auto fullName = kj::str(scope, name, templateContext.args());
    auto methods = KJ_MAP(m, schema.getMethods()) {
      return makeMethodText(fullName, m, templateContext);
    };

    auto proto = schema.getProto();
    auto hexId = kj::hex(proto.getId());

    auto superclasses = KJ_MAP(superclass, schema.getSuperclasses()) {
      return ExtendInfo { cppFullName(superclass, nullptr), superclass.getProto().getId() };
    };

    kj::Array<ExtendInfo> transitiveSuperclasses;
    {
      std::map<uint64_t, InterfaceSchema> map;
      getTransitiveSuperclasses(schema, map);
      map.erase(schema.getProto().getId());
      transitiveSuperclasses = KJ_MAP(entry, map) {
        return ExtendInfo { cppFullName(entry.second, nullptr), entry.second.getProto().getId() };
      };
    }

    CppTypeName typeName = cppFullName(schema, nullptr);

    CppTypeName clientName = typeName;
    clientName.addMemberType("Client");

    kj::String templates = kj::str(templateContext.allDecls());  // Ends with a newline

    // Private members struct
    kj::StringTree declareText = kj::strTree(
         "  #if !CAPNP_LITE\n"
         "  struct _capnpPrivate {\n"
         "    CAPNP_DECLARE_INTERFACE_HEADER(", hexId, ")\n");

    kj::StringTree defineText = kj::strTree(
        "// ", fullName, "\n",
        "#if !CAPNP_LITE\n",
        "#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL\n",
        templates, "constexpr ::capnp::Kind ", fullName, "::_capnpPrivate::kind;\n",
        templates, "constexpr ::capnp::_::RawSchema const* ", fullName, "::_capnpPrivate::schema;\n"
        "#endif  // !CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL\n");

    if (templateContext.isGeneric()) {
      auto brandInitializers = makeBrandInitializers(templateContext, schema);
      bool hasDeps = (brandInitializers.dependencies.size() != 0);

      declareText = kj::strTree(kj::mv(declareText),
          makeGenericDeclarations(templateContext, hasDeps));

      defineText = kj::strTree(kj::mv(defineText),
          makeGenericDefinitions(
              templateContext, fullName, kj::str(hexId), kj::mv(brandInitializers)));
    } else {
      declareText = kj::strTree(kj::mv(declareText),
        "    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }\n");
    }

    declareText = kj::strTree(kj::mv(declareText), "  };\n  #endif  // !CAPNP_LITE");
    defineText = kj::strTree(kj::mv(defineText), "#endif  // !CAPNP_LITE\n\n");

    return InterfaceText {
      kj::strTree(
          templateContext.hasParams() ? "  " : "", templateContext.decl(true),
          "  struct ", name, ";\n"),

      kj::strTree(
          templateContext.parentDecls(),
          templateContext.decl(scope == nullptr),
          "struct ", scope, name, " {\n",
          "  ", name, "() = delete;\n"
          "\n"
          "#if !CAPNP_LITE\n"
          "  class Client;\n"
          "  class Server;\n"
          "#endif  // !CAPNP_LITE\n"
          "\n",
          KJ_MAP(n, nestedTypeDecls) { return kj::mv(n); },
          "\n",
          kj::mv(declareText), "\n"
          "};\n"
          "\n"),

      kj::strTree(
          "#if !CAPNP_LITE\n",
          templateContext.allDecls(),
          "class ", fullName, "::Client\n"
          "    : public virtual ::capnp::Capability::Client",
          KJ_MAP(s, superclasses) {
            return kj::strTree(",\n      public virtual ", s.typeName.strNoTypename(), "::Client");
          }, " {\n"
          "public:\n"
          "  typedef ", name, " Calls;\n"
          "  typedef ", name, " Reads;\n"
          "\n"
          "  Client(decltype(nullptr));\n"
          "  explicit Client(::kj::Own< ::capnp::ClientHook>&& hook);\n"
          "  template <typename _t, typename = ::kj::EnableIf< ::kj::canConvert<_t*, Server*>()>>\n"
          "  Client(::kj::Own<_t>&& server);\n"
          "  template <typename _t, typename = ::kj::EnableIf< ::kj::canConvert<_t*, Client*>()>>\n"
          "  Client(::kj::Promise<_t>&& promise);\n"
          "  Client(::kj::Exception&& exception);\n"
          "  Client(Client&) = default;\n"
          "  Client(Client&&) = default;\n"
          "  Client& operator=(Client& other);\n"
          "  Client& operator=(Client&& other);\n"
          "\n",
          makeAsGenericDef(AsGenericRole::CLIENT, templateContext, name),
          KJ_MAP(m, methods) { return kj::mv(m.clientDecls); },
          "\n"
          "protected:\n"
          "  Client() = default;\n"
          "};\n"
          "\n",
          templateContext.allDecls(),
          "class ", fullName, "::Server\n"
          "    : public virtual ::capnp::Capability::Server",
          KJ_MAP(s, superclasses) {
            return kj::strTree(",\n      public virtual ", s.typeName.strNoTypename(), "::Server");
          }, " {\n"
          "public:\n",
          "  typedef ", name, " Serves;\n"
          "\n"
          "  ::capnp::Capability::Server::DispatchCallResult dispatchCall(\n"
          "      uint64_t interfaceId, uint16_t methodId,\n"
          "      ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context)\n"
          "      override;\n"
          "\n"
          "protected:\n",
          KJ_MAP(m, methods) { return kj::mv(m.serverDecls); },
          "\n"
          "  inline ", clientName, " thisCap() {\n"
          "    return ::capnp::Capability::Server::thisCap()\n"
          "        .template castAs<", typeName, ">();\n"
          "  }\n"
          "\n"
          "  ::capnp::Capability::Server::DispatchCallResult dispatchCallInternal(\n"
          "      uint16_t methodId,\n"
          "      ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context);\n"
          "};\n"
          "#endif  // !CAPNP_LITE\n"
          "\n"),

      kj::strTree(
          "#if !CAPNP_LITE\n",
          templateContext.allDecls(),
          "inline ", fullName, "::Client::Client(decltype(nullptr))\n"
          "    : ::capnp::Capability::Client(nullptr) {}\n",
          templateContext.allDecls(),
          "inline ", fullName, "::Client::Client(\n"
          "    ::kj::Own< ::capnp::ClientHook>&& hook)\n"
          "    : ::capnp::Capability::Client(::kj::mv(hook)) {}\n",
          templateContext.allDecls(),
          "template <typename _t, typename>\n"
          "inline ", fullName, "::Client::Client(::kj::Own<_t>&& server)\n"
          "    : ::capnp::Capability::Client(::kj::mv(server)) {}\n",
          templateContext.allDecls(),
          "template <typename _t, typename>\n"
          "inline ", fullName, "::Client::Client(::kj::Promise<_t>&& promise)\n"
          "    : ::capnp::Capability::Client(::kj::mv(promise)) {}\n",
          templateContext.allDecls(),
          "inline ", fullName, "::Client::Client(::kj::Exception&& exception)\n"
          "    : ::capnp::Capability::Client(::kj::mv(exception)) {}\n",
          templateContext.allDecls(),
          "inline ", clientName, "& ", fullName, "::Client::operator=(Client& other) {\n"
          "  ::capnp::Capability::Client::operator=(other);\n"
          "  return *this;\n"
          "}\n",
          templateContext.allDecls(),
          "inline ", clientName, "& ", fullName, "::Client::operator=(Client&& other) {\n"
          "  ::capnp::Capability::Client::operator=(kj::mv(other));\n"
          "  return *this;\n"
          "}\n"
          "\n",
          KJ_MAP(m, methods) { return kj::mv(m.inlineDefs); },
          "#endif  // !CAPNP_LITE\n"),

      kj::strTree(
          "#if !CAPNP_LITE\n",
          KJ_MAP(m, methods) { return kj::mv(m.sourceDefs); },
          templateContext.allDecls(),
          "::capnp::Capability::Server::DispatchCallResult ", fullName, "::Server::dispatchCall(\n"
          "    uint64_t interfaceId, uint16_t methodId,\n"
          "    ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) {\n"
          "  switch (interfaceId) {\n"
          "    case 0x", kj::hex(proto.getId()), "ull:\n"
          "      return dispatchCallInternal(methodId, context);\n",
          KJ_MAP(s, transitiveSuperclasses) {
            return kj::strTree(
              "    case 0x", kj::hex(s.id), "ull:\n"
              "      return ", s.typeName.strNoTypename(),
                         "::Server::dispatchCallInternal(methodId, context);\n");
          },
          "    default:\n"
          "      return internalUnimplemented(\"", proto.getDisplayName(), "\", interfaceId);\n"
          "  }\n"
          "}\n",
          templateContext.allDecls(),
          "::capnp::Capability::Server::DispatchCallResult ", fullName, "::Server::dispatchCallInternal(\n"
          "    uint16_t methodId,\n"
          "    ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) {\n"
          "  switch (methodId) {\n",
          KJ_MAP(m, methods) { return kj::mv(m.dispatchCase); },
          "    default:\n"
          "      (void)context;\n"
          "      return ::capnp::Capability::Server::internalUnimplemented(\n"
          "          \"", proto.getDisplayName(), "\",\n"
          "          0x", kj::hex(proto.getId()), "ull, methodId);\n"
          "  }\n"
          "}\n"
          "#endif  // !CAPNP_LITE\n"
          "\n",
          kj::mv(defineText))
    };
  }

  // -----------------------------------------------------------------

  struct ConstText {
    bool needsSchema;
    kj::StringTree decl;
    kj::StringTree def;
  };

  ConstText makeConstText(kj::StringPtr scope, kj::StringPtr name, ConstSchema schema,
                          const TemplateContext& templateContext) {
    auto proto = schema.getProto();
    auto constProto = proto.getConst();
    auto type = schema.getType();
    auto typeName_ = typeName(type, nullptr);
    auto upperCase = toUpperCase(name);

    // Linkage qualifier for non-primitive types.
    const char* linkage = scope.size() == 0 ? "extern " : "static ";

    switch (type.which()) {
      case schema::Type::BOOL:
      case schema::Type::INT8:
      case schema::Type::INT16:
      case schema::Type::INT32:
      case schema::Type::INT64:
      case schema::Type::UINT8:
      case schema::Type::UINT16:
      case schema::Type::UINT32:
      case schema::Type::UINT64:
      case schema::Type::ENUM:
        return ConstText {
          false,
          kj::strTree("static constexpr ", typeName_, ' ', upperCase, " = ",
              literalValue(schema.getType(), constProto.getValue()), ";\n"),
          scope.size() == 0 ? kj::strTree() : kj::strTree(
              "#if CAPNP_NEED_REDUNDANT_CONSTEXPR_DECL\n"
              "constexpr ", typeName_, ' ', scope, upperCase, ";\n"
              "#endif\n")
        };

      case schema::Type::VOID:
      case schema::Type::FLOAT32:
      case schema::Type::FLOAT64: {
        // TODO(msvc): MSVC doesn't like float- or class-typed constexprs. As soon as this is fixed,
        //   treat VOID, FLOAT32, and FLOAT64 the same as the other primitives.
        kj::String value = literalValue(schema.getType(), constProto.getValue()).flatten();
        return ConstText {
          false,
          kj::strTree("static KJ_CONSTEXPR(const) ", typeName_, ' ', upperCase,
              " CAPNP_NON_INT_CONSTEXPR_DECL_INIT(", value, ");\n"),
          scope.size() == 0 ? kj::strTree() : kj::strTree(
              "KJ_CONSTEXPR(const) ", typeName_, ' ', scope, upperCase,
              " CAPNP_NON_INT_CONSTEXPR_DEF_INIT(", value, ");\n")
        };
      }

      case schema::Type::TEXT: {
        kj::String constType = kj::strTree(
            "::capnp::_::ConstText<", schema.as<Text>().size(), ">").flatten();
        return ConstText {
          true,
          kj::strTree(linkage, "const ", constType, ' ', upperCase, ";\n"),
          kj::strTree("const ", constType, ' ', scope, upperCase, "(::capnp::schemas::b_",
                      kj::hex(proto.getId()), ".words + ", schema.getValueSchemaOffset(), ");\n")
        };
      }

      case schema::Type::DATA: {
        kj::String constType = kj::strTree(
            "::capnp::_::ConstData<", schema.as<Data>().size(), ">").flatten();
        return ConstText {
          true,
          kj::strTree(linkage, "const ", constType, ' ', upperCase, ";\n"),
          kj::strTree("const ", constType, ' ', scope, upperCase, "(::capnp::schemas::b_",
                      kj::hex(proto.getId()), ".words + ", schema.getValueSchemaOffset(), ");\n")
        };
      }

      case schema::Type::STRUCT: {
        kj::String constType = kj::strTree(
            "::capnp::_::ConstStruct<", typeName_, ">").flatten();
        return ConstText {
          true,
          kj::strTree(linkage, "const ", constType, ' ', upperCase, ";\n"),
          kj::strTree("const ", constType, ' ', scope, upperCase, "(::capnp::schemas::b_",
                      kj::hex(proto.getId()), ".words + ", schema.getValueSchemaOffset(), ");\n")
        };
      }

      case schema::Type::LIST: {
        kj::String constType = kj::strTree(
            "::capnp::_::ConstList<", typeName(type.asList().getElementType(), nullptr), ">")
            .flatten();
        return ConstText {
          true,
          kj::strTree(linkage, "const ", constType, ' ', upperCase, ";\n"),
          kj::strTree("const ", constType, ' ', scope, upperCase, "(::capnp::schemas::b_",
                      kj::hex(proto.getId()), ".words + ", schema.getValueSchemaOffset(), ");\n")
        };
      }

      case schema::Type::ANY_POINTER:
      case schema::Type::INTERFACE:
        return ConstText { false, kj::strTree(), kj::strTree() };
    }

    KJ_UNREACHABLE;
  }

  // -----------------------------------------------------------------

  struct NodeText {
    kj::StringTree outerTypeDecl;
    kj::StringTree outerTypeDef;
    kj::StringTree readerBuilderDefs;
    kj::StringTree inlineMethodDefs;
    kj::StringTree capnpSchemaDecls;
    kj::StringTree capnpSchemaDefs;
    kj::StringTree sourceFileDefs;
  };

  NodeText makeNodeText(kj::StringPtr namespace_, kj::StringPtr scope,
                        kj::StringPtr name, Schema schema,
                        const TemplateContext& parentTemplateContext) {
    // `templateContext` is something like "template <typename T>\ntemplate <typename U>\n"
    // declaring template parameters for all parent scopes.

    auto proto = schema.getProto();
    KJ_IF_MAYBE(annotatedName, annotationValue(proto, NAME_ANNOTATION_ID)) {
      name = annotatedName->getText();
    }
    auto hexId = kj::hex(proto.getId());

    TemplateContext templateContext(parentTemplateContext, name, proto);

    auto subScope = kj::str(scope, name, templateContext.args(), "::");

    // Compute nested nodes, including groups.
    kj::Vector<NodeText> nestedTexts(proto.getNestedNodes().size());
    for (auto nested: proto.getNestedNodes()) {
      nestedTexts.add(makeNodeText(
          namespace_, subScope, nested.getName(), schemaLoader.getUnbound(nested.getId()),\
          templateContext));
    };

    if (proto.isStruct()) {
      for (auto field: proto.getStruct().getFields()) {
        if (field.isGroup()) {
          nestedTexts.add(makeNodeText(
              namespace_, subScope, toTitleCase(protoName(field)),
              schemaLoader.getUnbound(field.getGroup().getTypeId()),
              templateContext));
        }
      }
    } else if (proto.isInterface()) {
      for (auto method: proto.getInterface().getMethods()) {
        {
          Schema params = schemaLoader.getUnbound(method.getParamStructType());
          auto paramsProto = schemaLoader.getUnbound(method.getParamStructType()).getProto();
          if (paramsProto.getScopeId() == 0) {
            nestedTexts.add(makeNodeText(namespace_, subScope,
                toTitleCase(kj::str(protoName(method), "Params")), params, templateContext));
          }
        }
        {
          Schema results = schemaLoader.getUnbound(method.getResultStructType());
          auto resultsProto = schemaLoader.getUnbound(method.getResultStructType()).getProto();
          if (resultsProto.getScopeId() == 0) {
            nestedTexts.add(makeNodeText(namespace_, subScope,
                toTitleCase(kj::str(protoName(method), "Results")), results, templateContext));
          }
        }
      }
    }

    // Convert the encoded schema to a literal byte array.
    kj::ArrayPtr<const word> rawSchema = schema.asUncheckedMessage();
    auto schemaLiteral = kj::StringTree(KJ_MAP(w, rawSchema) {
      const byte* bytes = reinterpret_cast<const byte*>(&w);

      return kj::strTree(KJ_MAP(i, kj::range<uint>(0, sizeof(word))) {
        auto text = kj::toCharSequence(kj::implicitCast<uint>(bytes[i]));
        return kj::strTree(kj::repeat(' ', 4 - text.size()), text, ",");
      });
    }, "\n   ");

    auto schemaDecl = kj::strTree(
        "CAPNP_DECLARE_SCHEMA(", hexId, ");\n");

    std::set<uint64_t> deps;
    enumerateDeps(proto, deps);

    kj::Array<uint> membersByName;
    kj::Array<uint> membersByDiscrim;
    switch (proto.which()) {
      case schema::Node::STRUCT: {
        auto structSchema = schema.asStruct();
        membersByName = makeMembersByName(structSchema.getFields());
        auto builder = kj::heapArrayBuilder<uint>(structSchema.getFields().size());
        for (auto field: structSchema.getUnionFields()) {
          builder.add(field.getIndex());
        }
        for (auto field: structSchema.getNonUnionFields()) {
          builder.add(field.getIndex());
        }
        membersByDiscrim = builder.finish();
        break;
      }
      case schema::Node::ENUM:
        membersByName = makeMembersByName(schema.asEnum().getEnumerants());
        break;
      case schema::Node::INTERFACE:
        membersByName = makeMembersByName(schema.asInterface().getMethods());
        break;
      default:
        break;
    }

    auto brandDeps = makeBrandDepInitializers(
        makeBrandDepMap(templateContext, schema.getGeneric()));

    bool mayContainCapabilities = proto.isStruct() && schema.asStruct().mayContainCapabilities();

    auto schemaDef = kj::strTree(
        "static const ::capnp::_::AlignedData<", rawSchema.size(), "> b_", hexId, " = {\n"
        "  {", kj::mv(schemaLiteral), " }\n"
        "};\n"
        "::capnp::word const* const bp_", hexId, " = b_", hexId, ".words;\n"
        "#if !CAPNP_LITE\n",
        deps.size() == 0 ? kj::strTree() : kj::strTree(
            "static const ::capnp::_::RawSchema* const d_", hexId, "[] = {\n",
            KJ_MAP(depId, deps) {
              return kj::strTree("  &s_", kj::hex(depId), ",\n");
            },
            "};\n"),
        membersByName.size() == 0 ? kj::strTree() : kj::strTree(
            "static const uint16_t m_", hexId, "[] = {",
            kj::StringTree(KJ_MAP(index, membersByName) { return kj::strTree(index); }, ", "),
            "};\n"),
        membersByDiscrim.size() == 0 ? kj::strTree() : kj::strTree(
            "static const uint16_t i_", hexId, "[] = {",
            kj::StringTree(KJ_MAP(index, membersByDiscrim) { return kj::strTree(index); }, ", "),
            "};\n"),
        brandDeps.size() == 0 ? kj::strTree() : kj::strTree(
            "KJ_CONSTEXPR(const) ::capnp::_::RawBrandedSchema::Dependency bd_", hexId, "[] = ",
            kj::mv(brandDeps), ";\n"),
        "const ::capnp::_::RawSchema s_", hexId, " = {\n"
        "  0x", hexId, ", b_", hexId, ".words, ", rawSchema.size(), ", ",
        deps.size() == 0 ? kj::strTree("nullptr") : kj::strTree("d_", hexId), ", ",
        membersByName.size() == 0 ? kj::strTree("nullptr") : kj::strTree("m_", hexId), ",\n",
        "  ", deps.size(), ", ", membersByName.size(), ", ",
        membersByDiscrim.size() == 0 ? kj::strTree("nullptr") : kj::strTree("i_", hexId),
        ", nullptr, nullptr, { &s_", hexId, ", nullptr, ",
        brandDeps.size() == 0 ? kj::strTree("nullptr, 0, 0") : kj::strTree(
            "bd_", hexId, ", 0, " "sizeof(bd_", hexId, ") / sizeof(bd_", hexId, "[0])"),
        ", nullptr }, ", mayContainCapabilities, "\n"
        "};\n"
        "#endif  // !CAPNP_LITE\n");

    NodeText top = makeNodeTextWithoutNested(
        namespace_, scope, name, schema,
        KJ_MAP(n, nestedTexts) { return kj::mv(n.outerTypeDecl); },
        templateContext);

    NodeText result = {
      kj::mv(top.outerTypeDecl),

      kj::strTree(
          kj::mv(top.outerTypeDef),
          KJ_MAP(n, nestedTexts) { return kj::mv(n.outerTypeDef); }),

      kj::strTree(
          kj::mv(top.readerBuilderDefs),
          KJ_MAP(n, nestedTexts) { return kj::mv(n.readerBuilderDefs); }),

      kj::strTree(
          kj::mv(top.inlineMethodDefs),
          KJ_MAP(n, nestedTexts) { return kj::mv(n.inlineMethodDefs); }),

      kj::strTree(
          kj::mv(schemaDecl),
          kj::mv(top.capnpSchemaDecls),
          KJ_MAP(n, nestedTexts) { return kj::mv(n.capnpSchemaDecls); }),

      kj::strTree(
          kj::mv(schemaDef),
          kj::mv(top.capnpSchemaDefs),
          KJ_MAP(n, nestedTexts) { return kj::mv(n.capnpSchemaDefs); }),

      kj::strTree(
          kj::mv(top.sourceFileDefs),
          KJ_MAP(n, nestedTexts) { return kj::mv(n.sourceFileDefs); }),
    };

    if (templateContext.isGeneric()) {
      // This is a template, so move all source declarations into the header.
      result.inlineMethodDefs = kj::strTree(
          kj::mv(result.inlineMethodDefs), kj::mv(result.sourceFileDefs));
      result.sourceFileDefs = kj::strTree();
    }

    return result;
  }

  NodeText makeNodeTextWithoutNested(kj::StringPtr namespace_, kj::StringPtr scope,
                                     kj::StringPtr name, Schema schema,
                                     kj::Array<kj::StringTree> nestedTypeDecls,
                                     const TemplateContext& templateContext) {
    auto proto = schema.getProto();
    KJ_IF_MAYBE(annotatedName, annotationValue(proto, NAME_ANNOTATION_ID)) {
      name = annotatedName->getText();
    }
    auto hexId = kj::hex(proto.getId());

    switch (proto.which()) {
      case schema::Node::FILE:
        KJ_FAIL_REQUIRE("This method shouldn't be called on file nodes.");

      case schema::Node::STRUCT: {
        StructText structText =
            makeStructText(scope, name, schema.asStruct(), kj::mv(nestedTypeDecls),
                           templateContext);

        return NodeText {
          kj::mv(structText.outerTypeDecl),
          kj::mv(structText.outerTypeDef),
          kj::mv(structText.readerBuilderDefs),
          kj::mv(structText.inlineMethodDefs),

          kj::strTree(),
          kj::strTree(),

          kj::mv(structText.sourceDefs),
        };
      }

      case schema::Node::ENUM: {
        auto enumerants = schema.asEnum().getEnumerants();

        return NodeText {
          scope.size() == 0 ? kj::strTree() : kj::strTree(
              "  typedef ::capnp::schemas::", name, "_", hexId, " ", name, ";\n"
              "\n"),

          scope.size() > 0 ? kj::strTree() : kj::strTree(
              "typedef ::capnp::schemas::", name, "_", hexId, " ", name, ";\n"
              "\n"),

          kj::strTree(),
          kj::strTree(),

          kj::strTree(
              // We declare enums in the capnp::schemas namespace and then typedef them into
              // place because we don't want them to be parameterized for generics.
              "enum class ", name, "_", hexId, ": uint16_t {\n",
              KJ_MAP(e, enumerants) {
                return kj::strTree("  ", toUpperCase(protoName(e.getProto())), ",\n");
              },
              "};\n"
              "CAPNP_DECLARE_ENUM(", name, ", ", hexId, ");\n"),
          kj::strTree(
              "CAPNP_DEFINE_ENUM(", name, "_", hexId, ", ", hexId, ");\n"),

          kj::strTree(),
        };
      }

      case schema::Node::INTERFACE: {
        hasInterfaces = true;

        InterfaceText interfaceText =
            makeInterfaceText(scope, name, schema.asInterface(), kj::mv(nestedTypeDecls),
                              templateContext);

        return NodeText {
          kj::mv(interfaceText.outerTypeDecl),
          kj::mv(interfaceText.outerTypeDef),
          kj::mv(interfaceText.clientServerDefs),
          kj::mv(interfaceText.inlineMethodDefs),

          kj::strTree(),
          kj::strTree(),

          kj::mv(interfaceText.sourceDefs),
        };
      }

      case schema::Node::CONST: {
        auto constText = makeConstText(scope, name, schema.asConst(), templateContext);

        return NodeText {
          scope.size() == 0 ? kj::strTree() : kj::strTree("  ", kj::mv(constText.decl)),
          scope.size() > 0 ? kj::strTree() : kj::mv(constText.decl),
          kj::strTree(),
          kj::strTree(),

          kj::strTree(),
          kj::strTree(),

          kj::mv(constText.def),
        };
      }

      case schema::Node::ANNOTATION: {
        return NodeText {
          kj::strTree(),
          kj::strTree(),
          kj::strTree(),
          kj::strTree(),

          kj::strTree(),
          kj::strTree(),

          kj::strTree(),
        };
      }
    }

    KJ_UNREACHABLE;
  }

  // -----------------------------------------------------------------

  struct FileText {
    kj::StringTree header;
    kj::StringTree source;
  };

  FileText makeFileText(Schema schema,
                        schema::CodeGeneratorRequest::RequestedFile::Reader request) {
    usedImports.clear();

    auto node = schema.getProto();
    auto displayName = node.getDisplayName();

    kj::Vector<kj::ArrayPtr<const char>> namespaceParts;
    kj::String namespacePrefix;

    for (auto annotation: node.getAnnotations()) {
      if (annotation.getId() == NAMESPACE_ANNOTATION_ID) {
        kj::StringPtr ns = annotation.getValue().getText();
        kj::StringPtr ns2 = ns;
        namespacePrefix = kj::str("::", ns);

        for (;;) {
          KJ_IF_MAYBE(colonPos, ns.findFirst(':')) {
            namespaceParts.add(ns.slice(0, *colonPos));
            ns = ns.slice(*colonPos);
            if (!ns.startsWith("::")) {
              context.exitError(kj::str(displayName, ": invalid namespace spec: ", ns2));
            }
            ns = ns.slice(2);
          } else {
            namespaceParts.add(ns);
            break;
          }
        }

        break;
      }
    }

    auto nodeTexts = KJ_MAP(nested, node.getNestedNodes()) {
      return makeNodeText(namespacePrefix, "", nested.getName(),
                          schemaLoader.getUnbound(nested.getId()), TemplateContext());
    };

    kj::String separator = kj::str("// ", kj::repeat('=', 87), "\n");

    kj::Vector<kj::StringPtr> includes;
    for (auto import: request.getImports()) {
      if (usedImports.count(import.getId()) > 0) {
        includes.add(import.getName());
      }
    }

    kj::StringTree sourceDefs = kj::strTree(
        KJ_MAP(n, nodeTexts) { return kj::mv(n.sourceFileDefs); });

    return FileText {
      kj::strTree(
          "// Generated by Cap'n Proto compiler, DO NOT EDIT\n"
          "// source: ", baseName(displayName), "\n"
          "\n"
          "#pragma once\n"
          "\n"
          "#include <capnp/generated-header-support.h>\n"
          "#include <kj/windows-sanity.h>\n",  // work-around macro conflict with VOID
          hasInterfaces ? kj::strTree(
            "#if !CAPNP_LITE\n"
            "#include <capnp/capability.h>\n"
            "#endif  // !CAPNP_LITE\n"
          ) : kj::strTree(),
          "\n"
          "#ifndef CAPNP_VERSION\n"
          "#error \"CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?\"\n"
          "#elif CAPNP_VERSION != ", CAPNP_VERSION, "\n"
          "#error \"Version mismatch between generated code and library headers.  You must "
              "use the same version of the Cap'n Proto compiler and library.\"\n"
          "#endif\n"
          "\n",
          KJ_MAP(path, includes) {
            if (path.startsWith("/")) {
              return kj::strTree("#include <", path.slice(1), ".h>\n");
            } else {
              return kj::strTree("#include \"", path, ".h\"\n");
            }
          },
          "\n"
          "CAPNP_BEGIN_HEADER\n"
          "\n"
          "namespace capnp {\n"
          "namespace schemas {\n"
          "\n",
          KJ_MAP(n, nodeTexts) { return kj::mv(n.capnpSchemaDecls); },
          "\n"
          "}  // namespace schemas\n"
          "}  // namespace capnp\n"
          "\n",

          KJ_MAP(n, namespaceParts) { return kj::strTree("namespace ", n, " {\n"); }, "\n",
          KJ_MAP(n, nodeTexts) { return kj::mv(n.outerTypeDef); },
          separator, "\n",
          KJ_MAP(n, nodeTexts) { return kj::mv(n.readerBuilderDefs); },
          separator, "\n",
          KJ_MAP(n, nodeTexts) { return kj::mv(n.inlineMethodDefs); },
          KJ_MAP(n, namespaceParts) { return kj::strTree("}  // namespace\n"); },
          "\n"
          "CAPNP_END_HEADER\n"
          "\n"),

      kj::strTree(
          "// Generated by Cap'n Proto compiler, DO NOT EDIT\n"
          "// source: ", baseName(displayName), "\n"
          "\n"
          "#include \"", baseName(displayName), ".h\"\n"
          "\n"
          "namespace capnp {\n"
          "namespace schemas {\n",
          KJ_MAP(n, nodeTexts) { return kj::mv(n.capnpSchemaDefs); },
          "}  // namespace schemas\n"
          "}  // namespace capnp\n",
          sourceDefs.size() == 0 ? kj::strTree() : kj::strTree(
              "\n", separator, "\n",
              KJ_MAP(n, namespaceParts) { return kj::strTree("namespace ", n, " {\n"); }, "\n",
              kj::mv(sourceDefs), "\n",
              KJ_MAP(n, namespaceParts) { return kj::strTree("}  // namespace\n"); }, "\n"))
    };
  }

  // -----------------------------------------------------------------

  kj::Own<kj::Filesystem> fs = kj::newDiskFilesystem();

  void writeFile(kj::StringPtr filename, const kj::StringTree& text) {
    // We don't use replaceFile() here because atomic replacements are actually detrimental for
    // build tools:
    // - It's the responsibility of the build pipeline to ensure that no one else is concurrently
    //   reading the file when we write it, so atomicity brings no benefit.
    // - Atomic replacements force disk syncs which could slow us down for no benefit at all.
    // - Opening the existing file and overwriting it may allow the filesystem to reuse
    //   already-allocated blocks, or maybe even notice that no actual changes occurred.
    // - In a power outage scenario, the user would obviously restart the build from scratch
    //   anyway.
    //
    // At one point, in a fit of over-engineering, we used writable mmap() here. That turned out
    // to be a bad idea: writable mmap() is not implemented on some filesystems, especially shared
    // folders in VirtualBox. Oh well.

    auto path = kj::Path::parse(filename);
    auto file = fs->getCurrent().openFile(path,
        kj::WriteMode::CREATE | kj::WriteMode::MODIFY | kj::WriteMode::CREATE_PARENT);
    file->writeAll(text.flatten());
  }

  kj::MainBuilder::Validity run() {
    ReaderOptions options;
    options.traversalLimitInWords = 1 << 30;  // Don't limit.
    StreamFdMessageReader reader(0, options);
    auto request = reader.getRoot<schema::CodeGeneratorRequest>();

    auto capnpVersion = request.getCapnpVersion();

    if (capnpVersion.getMajor() != CAPNP_VERSION_MAJOR ||
        capnpVersion.getMinor() != CAPNP_VERSION_MINOR ||
        capnpVersion.getMicro() != CAPNP_VERSION_MICRO) {
      auto compilerVersion = request.hasCapnpVersion()
          ? kj::str(capnpVersion.getMajor(), '.', capnpVersion.getMinor(), '.',
                    capnpVersion.getMicro())
          : kj::str("pre-0.6");  // pre-0.6 didn't send the version.
      auto generatorVersion = kj::str(
          CAPNP_VERSION_MAJOR, '.', CAPNP_VERSION_MINOR, '.', CAPNP_VERSION_MICRO);

      KJ_LOG(WARNING,
          "You appear to be using different versions of 'capnp' (the compiler) and "
          "'capnpc-c++' (the code generator). This can happen, for example, if you built "
          "a custom version of 'capnp' but then ran it with '-oc++', which invokes "
          "'capnpc-c++' from your PATH (i.e. the installed version). To specify an alternate "
          "'capnpc-c++' executable, try something like '-o/path/to/capnpc-c++' instead.",
          compilerVersion, generatorVersion);
    }

    for (auto node: request.getNodes()) {
      schemaLoader.load(node);
    }

    schemaLoader.computeOptimizationHints();

    for (auto requestedFile: request.getRequestedFiles()) {
      auto schema = schemaLoader.get(requestedFile.getId());
      auto fileText = makeFileText(schema, requestedFile);

      writeFile(kj::str(schema.getProto().getDisplayName(), ".h"), fileText.header);
      writeFile(kj::str(schema.getProto().getDisplayName(), ".c++"), fileText.source);
    }

    return true;
  }
};

}  // namespace
}  // namespace capnp

KJ_MAIN(capnp::CapnpcCppMain);
