Clang generator: Strip same namespace prefixes

This addresses cases where the requested namespace of the SAPI sandbox and the one of
the type(s) to be emitted are the same.

For example assumer the header contains a type
```c++
namespace apps::pdf::sandboxed { struct PageInfo; }
```
and the tequested namespace `apps::pdf::sandboxed`.

Before this chage:
```c++
namespace apps::pdf::sandboxed {
namespace apps::pdf::sandboxed { struct PageInfo; }
}
```

After:
```c++
namespace apps::pdf::sandboxed { struct PageInfo; }
```
PiperOrigin-RevId: 785840598
Change-Id: I34a0e4a17d067ff9eee1e7bca188eaf2b70103ea

Author: cblichmann

sandboxed_api/tools/clang_generator/emitter.cc

@@ -275,24 +275,30 @@ absl::StatusOr<std::string> Emitter::DoEmitHeader() {
   // Emit type dependencies
   if (!rendered_types_ordered_.empty()) {
     absl::StrAppend(&out, "// Types this API depends on\n");
-    std::string last_ns_name = options_.namespace_name;
+    absl::string_view last_ns_name;
+    const std::string ns_prefix = absl::StrCat(options_.namespace_name, "::");
     for (const RenderedType* rt : rendered_types_ordered_) {
-      const auto& [ns_name, spelling] = *rt;
-      if (last_ns_name != ns_name) {
-        if (!last_ns_name.empty() && last_ns_name != options_.namespace_name) {
-          absl::StrAppend(&out, "}  // namespace ", last_ns_name, "\n\n");
-        }
+      absl::string_view ns_name = rt->ns_name;
+      if (ns_name == options_.namespace_name) {
+        ns_name = "";
+      } else {
+        absl::ConsumePrefix(&ns_name, ns_prefix);
+      }
 
-        if (!ns_name.empty() && ns_name != options_.namespace_name) {
+      if (ns_name != last_ns_name) {
+        if (!last_ns_name.empty()) {
+          absl::StrAppend(&out, "\n}  // namespace ", last_ns_name, "\n");
+        }
+        if (!ns_name.empty()) {
           absl::StrAppend(&out, "namespace ", ns_name, " {\n");
         }
         last_ns_name = ns_name;
       }
 
-      absl::StrAppend(&out, spelling, ";\n");
+      absl::StrAppend(&out, rt->spelling, ";\n");
     }
-    if (!last_ns_name.empty() && last_ns_name != options_.namespace_name) {
-      absl::StrAppend(&out, "}  // namespace ", last_ns_name, "\n\n");
+    if (!last_ns_name.empty()) {
+      absl::StrAppend(&out, "\n}  // namespace ", last_ns_name, "\n");
     }
   }
 

sandboxed_api/tools/clang_generator/emitter_test.cc

@@ -26,6 +26,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "sandboxed_api/testing.h"
 #include "sandboxed_api/tools/clang_generator/emitter_base.h"
 #include "sandboxed_api/tools/clang_generator/frontend_action_test_util.h"
 #include "sandboxed_api/tools/clang_generator/generator.h"
@@ -525,6 +526,93 @@ TEST_F(EmitterTest, SkipProtobufMessagesInternals) {
               ElementsAre("class MyMessage"));
 }
 
+TEST_F(EmitterTest, Namespaced) {
+  GeneratorOptions options;
+  EmitterForTesting emitter(&options);
+  EXPECT_THAT(
+      RunFrontendAction(R"(namespace sandboxed {
+                           struct S { int member; };
+                           }  // namespace sandboxed
+                           extern "C" sandboxed::S* Structize();)",
+                        std::make_unique<GeneratorAction>(&emitter, &options)),
+      IsOk());
+  EXPECT_THAT(emitter.GetRenderedFunctions(), SizeIs(1));
+
+  EXPECT_THAT(UglifyAll(emitter.SpellingsForNS("sandboxed")),
+              ElementsAre("struct S { int member; }"));
+
+  SAPI_ASSERT_OK_AND_ASSIGN(std::string header, emitter.EmitHeader());
+  // Expect the namespace to be preserved.
+  EXPECT_THAT(header, HasSubstr("::absl::StatusOr<sandboxed::S*> Structize()"));
+}
+
+TEST_F(EmitterTest, StripNamespacePrefix) {
+  GeneratorOptions options;
+  options.namespace_name = "sandboxed";
+  EmitterForTesting emitter(&options);
+  EXPECT_THAT(
+      RunFrontendAction(R"(namespace sandboxed {
+                           struct S { int member; };
+                           }  // namespace sandboxed
+                           extern "C" sandboxed::S* Structize();)",
+                        std::make_unique<GeneratorAction>(&emitter, &options)),
+      IsOk());
+  EXPECT_THAT(emitter.GetRenderedFunctions(), SizeIs(1));
+
+  EXPECT_THAT(UglifyAll(emitter.SpellingsForNS("sandboxed")),
+              ElementsAre("struct S { int member; }"));
+
+  SAPI_ASSERT_OK_AND_ASSIGN(std::string header, emitter.EmitHeader());
+  // Expect the namespace prefix to be stripped, as `Structize` will also be
+  // emitted in the `sandboxed` namespace.
+  EXPECT_THAT(header, HasSubstr("::absl::StatusOr<S*> Structize()"));
+}
+
+TEST_F(EmitterTest, KeepTextualNamespacePrefix) {
+  GeneratorOptions options;
+  options.namespace_name = "sandboxed";
+  EmitterForTesting emitter(&options);
+  EXPECT_THAT(
+      RunFrontendAction(R"(namespace sandboxed_ns {
+                           struct S { int member; };
+                           }  // namespace sandboxed_ns
+                           extern "C" sandboxed_ns::S* Structize();)",
+                        std::make_unique<GeneratorAction>(&emitter, &options)),
+      IsOk());
+  EXPECT_THAT(emitter.GetRenderedFunctions(), SizeIs(1));
+
+  EXPECT_THAT(UglifyAll(emitter.SpellingsForNS("sandboxed_ns")),
+              ElementsAre("struct S { int member; }"));
+
+  SAPI_ASSERT_OK_AND_ASSIGN(std::string header, emitter.EmitHeader());
+  // Keep the namespace prefix, `sandboxed` and `sandboxed_ns` are different
+  // namespaces.
+  EXPECT_THAT(header,
+              HasSubstr("::absl::StatusOr<sandboxed_ns::S*> Structize()"));
+}
+
+TEST_F(EmitterTest, StripNamespacePrefixNested) {
+  GeneratorOptions options;
+  options.namespace_name = "sandboxed";
+  EmitterForTesting emitter(&options);
+  EXPECT_THAT(
+      RunFrontendAction(R"(namespace sandboxed::nested {
+                           struct S { int member; };
+                           }  // namespace sandboxed::nested
+                           extern "C" sandboxed::nested::S* Structize();)",
+                        std::make_unique<GeneratorAction>(&emitter, &options)),
+      IsOk());
+  EXPECT_THAT(emitter.GetRenderedFunctions(), SizeIs(1));
+
+  EXPECT_THAT(UglifyAll(emitter.SpellingsForNS("sandboxed::nested")),
+              ElementsAre("struct S { int member; }"));
+
+  SAPI_ASSERT_OK_AND_ASSIGN(std::string header, emitter.EmitHeader());
+  // Expect the namespace prefix to be stripped, similar to the
+  // StripNamespacePrefix test.
+  EXPECT_THAT(header, HasSubstr("::absl::StatusOr<nested::S*> Structize()"));
+}
+
 TEST_F(EmitterTest, SymbolListTest) {
   constexpr absl::string_view kInputFile = "simple_functions.cc";
   GeneratorOptions options;