Merge namespace into name resolver

Summary: Name resolver already contains a namespace resolver but only provides a subset of the API. As a result some users end up creating duplicate caches. Merge the two to keep all name resolution and caches in one place, fix some names that don't follow the conventions and cleanup name resolver tests.

Reviewed By: yoney

Differential Revision: D63923307

fbshipit-source-id: 4cee15d94f17edd518f9f8fb1fd3bc16bec38faf

Author: vitaut

third-party/thrift/src/thrift/compiler/CMakeLists.txt

@@ -129,8 +129,6 @@ target_link_libraries(
 add_library(
   compiler
 
-  gen/cpp/gen.cc
-  gen/cpp/namespace_resolver.cc
   gen/cpp/reference_type.cc
   gen/cpp/name_resolver.cc
 

third-party/thrift/src/thrift/compiler/gen/cpp/gen.cc

@@ -19,9 +19,11 @@
 #include <stdexcept>
 
 #include <fmt/core.h>
+#include <thrift/compiler/ast/t_function.h>
 #include <thrift/compiler/ast/t_list.h>
 #include <thrift/compiler/ast/t_map.h>
 #include <thrift/compiler/ast/t_node.h>
+#include <thrift/compiler/ast/t_program.h>
 #include <thrift/compiler/ast/t_set.h>
 #include <thrift/compiler/ast/t_struct.h>
 #include <thrift/compiler/ast/t_typedef.h>
@@ -44,6 +46,23 @@ const t_type* find_first_type(const t_type& node) {
 
 } // namespace
 
+namespace detail {
+
+std::string gen_template_type(
+    std::string template_name, std::initializer_list<std::string> args) {
+  template_name += "<";
+  auto delim = "";
+  for (const auto& arg : args) {
+    template_name += delim;
+    delim = ", ";
+    template_name += arg;
+  }
+  template_name += ">";
+  return template_name;
+}
+
+} // namespace detail
+
 const std::string& cpp_name_resolver::get_native_type(
     const t_field& field, const t_structured& parent) {
   const t_type& type = *field.type();
@@ -65,7 +84,7 @@ const std::string& cpp_name_resolver::get_native_type(
   // If @cpp.Adapter is used on typedef of the field, use the typedef name.
   if (const auto* typedf = dynamic_cast<const t_typedef*>(&type)) {
     if (find_structured_adapter_annotation(*typedf)) {
-      return namespaces_.get_namespaced_name(*typedf);
+      return get_namespaced_name(*typedf);
     }
   }
 
@@ -181,7 +200,7 @@ const std::string& cpp_name_resolver::get_underlying_namespaced_name(
       auto extra = get_extra_namespace(node);
       return fmt::format(
           "{}::{}{}",
-          namespaces_.get_namespace(*program),
+          get_namespace(*program),
           extra ? *extra + "::" : "",
           get_underlying_name(node));
     }
@@ -198,7 +217,7 @@ const std::string& cpp_name_resolver::get_underlying_name(const t_type& node) {
       return value->get_string();
     }
   }
-  return gen::cpp::namespace_resolver::get_cpp_name(node);
+  return cpp_name_resolver::get_cpp_name(node);
 }
 
 const std::string* cpp_name_resolver::get_extra_namespace(const t_type& node) {
@@ -212,8 +231,8 @@ const std::string* cpp_name_resolver::get_extra_namespace(const t_type& node) {
     const auto* name = annotation->get_value_from_structured_annotation_or_null(
         "underlyingName");
     if (name == nullptr || name->get_string().empty()) {
-      static const std::string kDefault = "detail";
-      return &kDefault;
+      static const std::string detail = "detail";
+      return &detail;
     }
   }
   return nullptr;
@@ -265,6 +284,28 @@ const std::string* cpp_name_resolver::find_first_adapter(const t_field& field) {
   return nullptr;
 }
 
+std::vector<std::string> cpp_name_resolver::gen_namespace_components(
+    const t_program& program) {
+  t_program::namespace_config conf;
+  conf.no_top_level_domain = true;
+  auto components = program.gen_namespace_or_default("cpp2", conf);
+  if (components.empty()) {
+    components = program.gen_namespace_or_default("cpp", conf);
+    components.push_back("cpp2");
+  }
+  return components;
+}
+
+std::string cpp_name_resolver::gen_namespace(const t_program& program) {
+  return "::" + gen_unprefixed_namespace(program);
+}
+
+std::string cpp_name_resolver::gen_unprefixed_namespace(
+    const t_program& program) {
+  const auto components = gen_namespace_components(program);
+  return fmt::format("{}", fmt::join(components, "::"));
+}
+
 bool cpp_name_resolver::can_resolve_to_scalar(const t_type& node) {
   return node.get_true_type()->is_scalar() || find_first_adapter(node) ||
       find_first_type(node);
@@ -274,16 +315,16 @@ const std::string& cpp_name_resolver::default_template(
     t_container::type ctype) {
   switch (ctype) {
     case t_container::type::t_list: {
-      static const auto& kValue = *new std::string("::std::vector");
-      return kValue;
+      static const auto& value = *new std::string("::std::vector");
+      return value;
     }
     case t_container::type::t_set: {
-      static const auto& kValue = *new std::string("::std::set");
-      return kValue;
+      static const auto& value = *new std::string("::std::set");
+      return value;
     }
     case t_container::type::t_map: {
-      static const auto& kValue = *new std::string("::std::map");
-      return kValue;
+      static const auto& value = *new std::string("::std::map");
+      return value;
     }
   }
   throw std::runtime_error(
@@ -294,41 +335,41 @@ const std::string& cpp_name_resolver::default_type(
     t_primitive_type::type btype) {
   switch (btype) {
     case t_primitive_type::type::t_void: {
-      static const auto& kValue = *new std::string("void");
-      return kValue;
+      static const auto& value = *new std::string("void");
+      return value;
     }
     case t_primitive_type::type::t_bool: {
-      static const auto& kValue = *new std::string("bool");
-      return kValue;
+      static const auto& value = *new std::string("bool");
+      return value;
     }
     case t_primitive_type::type::t_byte: {
-      static const auto& kValue = *new std::string("::std::int8_t");
-      return kValue;
+      static const auto& value = *new std::string("::std::int8_t");
+      return value;
     }
     case t_primitive_type::type::t_i16: {
-      static const auto& kValue = *new std::string("::std::int16_t");
-      return kValue;
+      static const auto& value = *new std::string("::std::int16_t");
+      return value;
     }
     case t_primitive_type::type::t_i32: {
-      static const auto& kValue = *new std::string("::std::int32_t");
-      return kValue;
+      static const auto& value = *new std::string("::std::int32_t");
+      return value;
     }
     case t_primitive_type::type::t_i64: {
-      static const auto& kValue = *new std::string("::std::int64_t");
-      return kValue;
+      static const auto& value = *new std::string("::std::int64_t");
+      return value;
     }
     case t_primitive_type::type::t_float: {
-      static const auto& kValue = *new std::string("float");
-      return kValue;
+      static const auto& value = *new std::string("float");
+      return value;
     }
     case t_primitive_type::type::t_double: {
-      static const auto& kValue = *new std::string("double");
-      return kValue;
+      static const auto& value = *new std::string("double");
+      return value;
     }
     case t_primitive_type::type::t_string:
     case t_primitive_type::type::t_binary: {
-      static const auto& kValue = *new std::string("::std::string");
-      return kValue;
+      static const auto& value = *new std::string("::std::string");
+      return value;
     }
   }
   throw std::runtime_error(
@@ -421,7 +462,7 @@ std::string cpp_name_resolver::gen_standard_type(
   }
 
   // For everything else, just use namespaced name.
-  return namespaces_.get_namespaced_name(node);
+  return get_namespaced_name(node);
 }
 
 std::string cpp_name_resolver::gen_container_type(

third-party/thrift/src/thrift/compiler/gen/cpp/gen.h

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <stdint.h>
+#include <initializer_list>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -25,8 +26,6 @@
 #include <thrift/compiler/ast/t_field.h>
 #include <thrift/compiler/ast/t_primitive_type.h>
 #include <thrift/compiler/ast/t_type.h>
-#include <thrift/compiler/gen/cpp/gen.h>
-#include <thrift/compiler/gen/cpp/namespace_resolver.h>
 #include <thrift/compiler/gen/cpp/reference_type.h>
 #include <thrift/compiler/lib/uri.h>
 
@@ -48,11 +47,27 @@ struct std::hash<std::pair<
 };
 
 namespace apache::thrift::compiler {
+namespace detail {
+template <typename C, typename K = typename C::key_type, typename G>
+auto& get_or_gen(C& cache, const K& key, const G& gen_func) {
+  auto itr = cache.find(key);
+  if (itr == cache.end()) {
+    itr = cache.emplace(key, gen_func()).first;
+  }
+  return itr->second;
+}
+
+std::string gen_template_type(
+    std::string template_name, std::initializer_list<std::string> args);
+} // namespace detail
 
+class t_function;
 class t_named;
 class t_program;
 class t_sink;
 class t_stream;
+class t_structured;
+class t_typedef;
 
 using cpp_reference_type = gen::cpp::reference_type;
 
@@ -96,11 +111,41 @@ class cpp_name_resolver {
         field_type_tag_cache_, &node, [&] { return gen_type_tag(node); });
   }
 
-  std::string get_namespaced_name(
+  // Returns C++ namespace for the given program.
+  const std::string& get_namespace(const t_program& node) {
+    return detail::get_or_gen(
+        namespace_cache_, &node, [&]() { return gen_namespace(node); });
+  }
+
+  const std::string& get_namespaced_name(
       const t_program& program, const t_named& node) {
-    return namespaces_.get_namespaced_name(program, node);
+    return detail::get_or_gen(name_cache_, &node, [&]() {
+      return gen_namespaced_name(program, node);
+    });
+  }
+  const std::string& get_namespaced_name(
+      const t_program* program, const t_named& node) {
+    return program == nullptr ? get_cpp_name(node)
+                              : get_namespaced_name(*program, node);
+  }
+  const std::string& get_namespaced_name(const t_type& node) {
+    return get_namespaced_name(node.program(), node);
   }
 
+  static const std::string& get_cpp_name(const t_named& node) {
+    if (const auto* cpp_name =
+            node.find_structured_annotation_or_null(kCppNameUri)) {
+      return cpp_name->get_value_from_structured_annotation("value")
+          .get_string();
+    }
+    return node.get_annotation("cpp.name", &node.name());
+  }
+
+  static std::string gen_namespace(const t_program& progam);
+  static std::string gen_unprefixed_namespace(const t_program& progam);
+  static std::vector<std::string> gen_namespace_components(
+      const t_program& program);
+
   const std::string& get_underlying_namespaced_name(const t_type& node);
 
   static const std::string& get_underlying_name(const t_type& node);
@@ -154,7 +199,8 @@ class cpp_name_resolver {
   using type_resolve_fn =
       const std::string& (cpp_name_resolver::*)(const t_type& node);
 
-  gen::cpp::namespace_resolver namespaces_;
+  std::unordered_map<const t_program*, std::string> namespace_cache_;
+  std::unordered_map<const t_named*, std::string> name_cache_;
   std::unordered_map<const t_type*, std::string> type_cache_;
   std::unordered_map<const t_sink*, std::string> sink_cache_;
   std::unordered_map<const t_const*, std::string> const_cache_;
@@ -169,14 +215,16 @@ class cpp_name_resolver {
   std::unordered_map<const t_field*, std::string> field_type_tag_cache_;
   std::unordered_map<const t_field*, std::string> field_reference_type_cache_;
 
+  std::string gen_namespaced_name(
+      const t_program& program, const t_named& node) {
+    return get_namespace(program) + "::" + get_cpp_name(node);
+  }
   static const std::string* get_string_from_annotation_or_null(
       const t_named& node, const char* uri, const char* key);
 
   static const std::string& default_type(t_primitive_type::type btype);
   static const std::string& default_template(t_container::type ctype);
 
-  const std::string& get_namespace(const t_program& program);
-
   // Generating functions.
   std::string gen_type(const t_type& node);
   std::string gen_field_type(