Add name property to prototypes

Reviewed By: praihan

Differential Revision: D79455426

fbshipit-source-id: 0b6f99721a106b57e9fe6f5918871b653b8578ee

Author: hchokshi

third-party/thrift/src/thrift/compiler/generate/t_mstch_cpp2_generator.cc

@@ -312,7 +312,7 @@ class t_mstch_cpp2_generator : public t_mstch_generator {
   prototype<t_program>::ptr make_prototype_for_program(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_program(proto);
-    auto def = whisker::dsl::prototype_builder<h_program>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_program>::patches(base);
     def.property(
         "cpp_qualified_namespace", &cpp2::get_gen_unprefixed_namespace);
     return std::move(def).make();
@@ -321,7 +321,7 @@ class t_mstch_cpp2_generator : public t_mstch_generator {
   prototype<t_named>::ptr make_prototype_for_named(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_named(proto);
-    auto def = whisker::dsl::prototype_builder<h_named>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_named>::patches(base);
     def.property("cpp_name", [](const t_named& named) {
       return cpp2::get_name(&named);
     });
@@ -331,7 +331,7 @@ class t_mstch_cpp2_generator : public t_mstch_generator {
   prototype<t_type>::ptr make_prototype_for_type(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_type(proto);
-    auto def = whisker::dsl::prototype_builder<h_type>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_type>::patches(base);
 
     def.property("cpp_qualified_underlying_name", [this](const t_type& type) {
       return cpp_context_->resolver().get_underlying_namespaced_name(type);
@@ -351,7 +351,7 @@ class t_mstch_cpp2_generator : public t_mstch_generator {
   prototype<t_typedef>::ptr make_prototype_for_typedef(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_typedef(proto);
-    auto def = whisker::dsl::prototype_builder<h_typedef>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_typedef>::patches(base);
 
     def.property("cpp_type", [&](const t_typedef& t) {
       return cpp_context_->resolver().get_underlying_type_name(t);
@@ -363,7 +363,7 @@ class t_mstch_cpp2_generator : public t_mstch_generator {
   prototype<t_enum>::ptr make_prototype_for_enum(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_enum(proto);
-    auto def = whisker::dsl::prototype_builder<h_enum>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_enum>::patches(base);
 
     def.property("cpp_min", [](const t_enum& e) -> whisker::object {
       auto values = e.values();
@@ -436,7 +436,7 @@ class t_mstch_cpp2_generator : public t_mstch_generator {
   prototype<t_function>::ptr make_prototype_for_function(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_function(proto);
-    auto def = whisker::dsl::prototype_builder<h_function>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_function>::patches(base);
 
     def.property("cpp_return_type", [&](const t_function& f) -> std::string {
       return cpp_context_->resolver().get_return_type(f);
@@ -454,7 +454,7 @@ class t_mstch_cpp2_generator : public t_mstch_generator {
   prototype<t_service>::ptr make_prototype_for_service(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_service(proto);
-    auto def = whisker::dsl::prototype_builder<h_service>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_service>::patches(base);
 
     def.property("cpp_name", [](const t_service& service) {
       return service.is_interaction() ? service.name()

third-party/thrift/src/thrift/compiler/generate/t_mstch_python_generator.cc

@@ -1243,7 +1243,7 @@ class t_mstch_python_prototypes_generator : public t_mstch_generator {
   prototype<t_named>::ptr make_prototype_for_named(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_named(proto);
-    auto def = whisker::dsl::prototype_builder<h_named>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_named>::patches(base);
 
     def.property("py_name", &python::get_py3_name<t_named>);
 
@@ -1253,7 +1253,7 @@ class t_mstch_python_prototypes_generator : public t_mstch_generator {
   prototype<t_program>::ptr make_prototype_for_program(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_program(proto);
-    auto def = whisker::dsl::prototype_builder<h_program>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_program>::patches(base);
 
     def.property("module_mangle", [&](const t_program& self) {
       return mangle_program_path(&self, get_option("root_module_prefix"));
@@ -1265,7 +1265,7 @@ class t_mstch_python_prototypes_generator : public t_mstch_generator {
   prototype<t_service>::ptr make_prototype_for_service(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_service(proto);
-    auto def = whisker::dsl::prototype_builder<h_service>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_service>::patches(base);
 
     def.property("module_mangle", [&](const t_service& self) {
       return mangle_program_path(
@@ -1278,7 +1278,7 @@ class t_mstch_python_prototypes_generator : public t_mstch_generator {
   prototype<t_type>::ptr make_prototype_for_type(
       const prototype_database& proto) const override {
     auto base = t_whisker_generator::make_prototype_for_type(proto);
-    auto def = whisker::dsl::prototype_builder<h_type>::extends(base);
+    auto def = whisker::dsl::prototype_builder<h_type>::patches(base);
 
     def.property("module_mangle", [&](const t_type& self) {
       return mangle_program_path(

third-party/thrift/src/thrift/compiler/whisker/dsl.h

@@ -635,10 +635,15 @@ class prototype_builder {
   template <
       typename Parent,
       std::enable_if_t<std::is_base_of_v<Parent, self_type>, int> = 0>
-  explicit prototype_builder(prototype_ptr<Parent> parent)
-      : parent_(std::move(parent)) {
+  explicit prototype_builder(
+      prototype_ptr<Parent> parent, const std::string_view& name = "")
+      : parent_(std::move(parent)), name_(name) {
     assert(parent_ != nullptr);
   }
+
+  explicit prototype_builder(const std::string_view& name)
+      : parent_(nullptr), name_(name) {}
+
   prototype_builder() = default;
 
   /**
@@ -686,14 +691,31 @@ class prototype_builder {
    */
   result make() && {
     return std::make_shared<basic_prototype<self_type>>(
-        std::move(descriptors_), std::move(parent_));
+        std::move(descriptors_), std::move(parent_), std::move(name_));
   }
 
+  // Define a prototype which extends from a parent prototype of a super type.
+  // To extend the functionality of a prototype for the same type, use
+  // `patches`.
   template <
       typename Parent,
-      std::enable_if_t<std::is_base_of_v<Parent, self_type>, int> = 0>
-  static prototype_builder extends(prototype_ptr<Parent> parent) {
-    return prototype_builder{std::move(parent)};
+      std::enable_if_t<
+          (std::is_base_of_v<Parent, self_type> &&
+           !std::is_same_v<Parent, self_type>),
+          int> = 0>
+  static prototype_builder extends(
+      prototype_ptr<Parent> parent, const std::string_view& name = "") {
+    return prototype_builder{std::move(parent), name};
+  }
+
+  // Define a prototype which extends from a parent prototype of the same type.
+  // This will return an extension builder which accepts the name (if any) of
+  // the parent.
+  static prototype_builder patches(prototype_ptr<self_type> parent) {
+    const std::string_view name = parent->name();
+    auto builder = prototype_builder{std::move(parent), name};
+
+    return builder;
   }
 
  private:
@@ -707,6 +729,17 @@ class prototype_builder {
 
   prototype<>::ptr parent_;
   prototype<>::descriptors_map descriptors_;
+
+  /**
+   * Optional explicit name.
+   * The name can be used in contexts like loops which implicitly change the
+   * scope from the parent object to the looped type. By using an explicit name
+   * for the prototype, the type of the template variable can be explicitly
+   * specified for readability and as an assertion of the type being operated
+   * on. Names can also be used to explicitly access parent prototype members
+   * on child objects.
+   */
+  std::string_view name_;
 };
 
 /**

third-party/thrift/src/thrift/compiler/whisker/object.cc

@@ -318,9 +318,11 @@ std::string native_function::describe_type() const {
 }
 
 /* static */ prototype<>::ptr prototype<>::from(
-    descriptors_map descriptors, prototype::ptr parent) {
+    descriptors_map descriptors,
+    prototype::ptr parent,
+    const std::string_view& name) {
   return std::make_shared<basic_prototype<>>(
-      std::move(descriptors), std::move(parent));
+      std::move(descriptors), std::move(parent), name);
 }
 
 std::string detail::describe_native_handle_for_type(

third-party/thrift/src/thrift/compiler/whisker/object.h

@@ -1008,12 +1008,18 @@ class prototype<void> {
    */
   virtual const ptr& parent() const = 0;
 
+  /**
+   * Returns the name for this prototype, if one is registered.
+   */
+  virtual const std::string_view& name() const = 0;
+
   using descriptors_map = std::map<std::string, descriptor, std::less<>>;
   /**
    * Creates a prototype from the provided map of descriptors and
    * (optionally) a parent.
    */
-  static ptr from(descriptors_map, ptr parent = nullptr);
+  static ptr from(
+      descriptors_map, ptr parent = nullptr, const std::string_view& name = "");
 };
 
 /**
@@ -1062,13 +1068,20 @@ class basic_prototype : public prototype<T> {
 
   const prototype<>::ptr& parent() const override { return parent_; }
 
+  const std::string_view& name() const override { return name_; }
+
   basic_prototype(
-      prototype<>::descriptors_map descriptors, prototype<>::ptr parent)
-      : descriptors_(std::move(descriptors)), parent_(std::move(parent)) {}
+      prototype<>::descriptors_map descriptors,
+      prototype<>::ptr parent,
+      const std::string_view& name)
+      : descriptors_(std::move(descriptors)),
+        parent_(std::move(parent)),
+        name_(name) {}
 
  private:
   prototype<>::descriptors_map descriptors_;
   prototype<>::ptr parent_;
+  std::string_view name_;
 };
 
 template <typename T>
@@ -1416,6 +1429,9 @@ class prototype_database {
       const prototype<>::ptr& parent() const final {
         return this->resolve()->parent();
       }
+      const std::string_view& name() const final {
+        return this->resolve()->name();
+      }
 
      private:
       prototype_ptr<T> resolve() const {

third-party/thrift/src/thrift/compiler/whisker/test/dsl_test.cc

@@ -53,4 +53,36 @@ TEST(DslTest, make_polymorphic_native_handle) {
   EXPECT_TRUE((std::is_same_v<A, poly<t_A, t_B, t_B2, t_C, t_C2>>));
 }
 
+TEST(DslTest, test_alias_inheritance) {
+  struct t_Base {
+    virtual ~t_Base() = default;
+  };
+  struct t_Child : public t_Base {
+    ~t_Child() override;
+  };
+
+  using h_Child = make_poly<t_Child>;
+  using h_Base = make_poly<t_Base, h_Child>;
+
+  EXPECT_TRUE((std::is_same_v<h_Child, poly<t_Child>>));
+  EXPECT_TRUE((std::is_same_v<h_Base, poly<t_Base, t_Child>>));
+
+  prototype_database proto{};
+  prototype_builder<h_Base> proto_base{"base"};
+  proto.define(std::move(proto_base).make());
+
+  prototype_builder<h_Child> proto_child =
+      prototype_builder<h_Child>::extends(proto.of<t_Base>());
+  EXPECT_EQ("", std::move(proto_child).make()->name())
+      << "Extending a parent type should not inherit its name";
+
+  proto_child =
+      prototype_builder<h_Child>::extends(proto.of<t_Base>(), "child");
+
+  prototype_builder<h_Child> proto_child_extension =
+      prototype_builder<h_Child>::patches(std::move(proto_child).make());
+  EXPECT_EQ("child", std::move(proto_child_extension).make()->name())
+      << "Extending the same type should inherit its name";
+}
+
 } // namespace whisker::dsl