Remove duplicate namespace directives codemod

Summary:
Duplicate `namespace` directives for the same language in Thrift IDL files are
being deprecated. This codemod removes duplicate namespace directives, keeping
only the first one for each language.

As a safety measure, if the duplicate namespace line has any trailing content
after the namespace node's source range (before end-of-line), the codemod skips
the file and notifies the user (e.g. comments like
`namespace cpp2 Foo // keep this`).

Files created/modified:
- `remove_duplicate_namespaces.cc`: Codemod binary using
  `program_.all_namespace_nodes()` to find duplicates.
- `remove_duplicate_namespaces_test.py`: Python unittest with 5 test cases
  (no duplicates, basic removal, multiple languages, trailing content safety
  check, trailing semicolon).
- `BUCK`: Added `cpp_binary` and `python_unittest` targets.

Reviewed By: Mizuchi

Differential Revision: D94761544

fbshipit-source-id: e3bdb92aa8af40935e3017829848f8ce031a4f75

Author: aristidisp

third-party/thrift/src/thrift/compiler/ast/t_program.h

@@ -264,6 +264,9 @@ class t_program : public t_named {
    * directives with the same language, only the first one is returned by
    * `namespaces()`.
    *
+   * The returned nodes are guaranteed to be in source order (i.e. the order
+   * in which the `namespace` directives appear in the IDL file). 
+   *
    * As of February 2026, work is ongoing to forbid duplicate namespaces from
    * Thrift IDL, so eventually the distinction above should become irrelevant.
    */

third-party/thrift/src/thrift/compiler/codemod/remove_duplicate_namespaces.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <set>
+#include <string>
+#include <fmt/core.h>
+#include <thrift/compiler/ast/t_program.h>
+#include <thrift/compiler/ast/t_program_bundle.h>
+#include <thrift/compiler/codemod/codemod.h>
+#include <thrift/compiler/codemod/file_manager.h>
+
+using apache::thrift::compiler::source_manager;
+using apache::thrift::compiler::t_program_bundle;
+
+namespace apache::thrift::compiler {
+namespace {
+
+class RemoveDuplicateNamespaces final {
+ public:
+  RemoveDuplicateNamespaces(source_manager& src_manager, t_program& program)
+      : source_manager_(src_manager),
+        program_(program),
+        file_manager_(source_manager_, program) {}
+
+  void run() {
+    const std::string_view old_content = file_manager_.old_content();
+    std::set<std::string> seen_languages;
+    bool has_duplicates = false;
+
+    for (const t_namespace* ns : program_.all_namespace_nodes()) {
+      const std::string& language = ns->language();
+
+      if (seen_languages.insert(language).second) {
+        // First occurrence of this language — keep it.
+        continue;
+      }
+
+      // Duplicate found. Compute the line range to remove.
+      const size_t begin_offset =
+          file_manager_.to_offset(ns->src_range().begin);
+      const size_t src_end_offset =
+          file_manager_.to_offset(ns->src_range().end);
+      const size_t newline_offset = old_content.find('\n', src_end_offset);
+
+      // Check for any trailing content after the namespace node
+      // (e.g. inline comments) before the end of the line.
+      if (newline_offset != std::string_view::npos &&
+          newline_offset != src_end_offset) {
+        // Compute a 1-based line number for the warning.
+        size_t line_number = 1;
+        for (size_t i = 0; i < begin_offset && i < old_content.size(); ++i) {
+          if (old_content[i] == '\n') {
+            ++line_number;
+          }
+        }
+        fmt::print(
+            stderr,
+            "{}:{}: warning: skipping file due to trailing content on "
+            "duplicate namespace '{}'\n",
+            program_.path(),
+            line_number,
+            language);
+        return;
+      }
+
+      // Remove the entire line (including the trailing newline).
+      const size_t end_offset = newline_offset == std::string_view::npos
+          ? old_content.size()
+          : newline_offset + 1;
+      file_manager_.add({begin_offset, end_offset, ""});
+      has_duplicates = true;
+    }
+
+    if (has_duplicates) {
+      file_manager_.apply_replacements();
+    }
+  }
+
+ private:
+  source_manager& source_manager_;
+  t_program& program_;
+  codemod::file_manager file_manager_;
+};
+
+} // namespace
+} // namespace apache::thrift::compiler
+
+int main(int argc, char** argv) {
+  return apache::thrift::compiler::run_codemod(
+      argc, argv, [](source_manager& sm, t_program_bundle& pb) {
+        apache::thrift::compiler::RemoveDuplicateNamespaces(
+            sm, *pb.root_program())
+            .run();
+      });
+}

third-party/thrift/src/thrift/compiler/codemod/remove_duplicate_namespaces_test.py

@@ -0,0 +1,193 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pyre-unsafe
+
+import os
+import shutil
+import subprocess
+import tempfile
+import textwrap
+import unittest
+
+import pkg_resources
+from xplat.thrift.compiler.codemod.test_utils import read_file, run_binary, write_file
+
+
+class RemoveDuplicateNamespacesTest(unittest.TestCase):
+    def setUp(self):
+        tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, tmp, True)
+        self.tmp = tmp
+        self.addCleanup(os.chdir, os.getcwd())
+        os.chdir(self.tmp)
+        self.maxDiff = None
+
+    def test_no_duplicates(self):
+        write_file(
+            "foo.thrift",
+            textwrap.dedent(
+                """\
+                namespace cpp2 foo
+                namespace python bar
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )
+
+        binary = pkg_resources.resource_filename(__name__, "codemod")
+        run_binary(binary, "foo.thrift")
+
+        self.assertEqual(
+            read_file("foo.thrift"),
+            textwrap.dedent(
+                """\
+                namespace cpp2 foo
+                namespace python bar
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )
+
+    def test_basic_duplicate_removal(self):
+        write_file(
+            "foo.thrift",
+            textwrap.dedent(
+                """\
+                namespace cpp2 first
+                namespace python bar
+                namespace cpp2 second
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )
+
+        binary = pkg_resources.resource_filename(__name__, "codemod")
+        run_binary(binary, "foo.thrift")
+
+        self.assertEqual(
+            read_file("foo.thrift"),
+            textwrap.dedent(
+                """\
+                namespace cpp2 first
+                namespace python bar
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )
+
+    def test_multiple_languages_with_duplicates(self):
+        write_file(
+            "foo.thrift",
+            textwrap.dedent(
+                """\
+                namespace cpp2 a
+                namespace python b
+                namespace cpp2 c
+                namespace python d
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )
+
+        binary = pkg_resources.resource_filename(__name__, "codemod")
+        run_binary(binary, "foo.thrift")
+
+        self.assertEqual(
+            read_file("foo.thrift"),
+            textwrap.dedent(
+                """\
+                namespace cpp2 a
+                namespace python b
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )
+
+    def test_trailing_content_on_duplicate_skips_file(self):
+        original = textwrap.dedent(
+            """\
+            namespace cpp2 first
+            namespace cpp2 second // keep this
+
+            struct S {
+              1: i32 x;
+            }
+            """
+        )
+        write_file("foo.thrift", original)
+
+        binary = pkg_resources.resource_filename(__name__, "codemod")
+        result = subprocess.run(
+            [binary, "foo.thrift"],
+            capture_output=True,
+            text=True,
+        )
+
+        # File should be unchanged.
+        self.assertEqual(read_file("foo.thrift"), original)
+        # Warning should be emitted on stderr.
+        self.assertIn("warning", result.stderr)
+        self.assertIn("trailing content", result.stderr)
+
+    def test_duplicate_with_trailing_semicolon(self):
+        write_file(
+            "foo.thrift",
+            textwrap.dedent(
+                """\
+                namespace cpp2 first;
+                namespace python bar
+                namespace cpp2 second;
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )
+
+        binary = pkg_resources.resource_filename(__name__, "codemod")
+        run_binary(binary, "foo.thrift")
+
+        self.assertEqual(
+            read_file("foo.thrift"),
+            textwrap.dedent(
+                """\
+                namespace cpp2 first;
+                namespace python bar
+
+                struct S {
+                  1: i32 x;
+                }
+                """
+            ),
+        )