[libc++][modules] Avoids duplicated exports.

[Mordante]

Summary

The first issue was found by @ldionne, upon further investigation there
were more duplicates. This removes the duplicates and updates the
clang-tidy test to detect duplicates.

[ldionne]

LGTM but I'd like to understand how the test will fail.

libcxx/modules/std/cmath.cppm

142–143

Is this comment in the right place now?

libcxx/modules/std/filesystem.cppm

38–39

Same.

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

236

This might be dumb, but I don't understand how the test will fail. Can you explain a bit more?

[Mordante]

libcxx/modules/std/cmath.cppm

142–143

I tend to keep the empty sections in other modules too,

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

236

Assume foo.h

void foo(char);
void foo(int);

This will only list one named declaration since duplicates are removed.

using ::foo;

foo.ccpm

export {
using ::foo;
using ::foo;
}

This will list two named declarations since duplicates are *not* removed.

using ::foo;
using ::foo;

Now the header and the module generate different output and are not considered "the same". This fails. This is the same failure when a public named declaration is added to a header and not to the module.

libcxx/modules/std/cmath.cppm

export namespace std {
   using std::fabs;
   using std::fabsf;
   using std::fabsl;
 
   using std::hypot;
   using std::hypotf;
   using std::hypotl;
 
   // [c.math.hypot3], three-dimensional hypotenuse
-  using std::hypot;
 
   using std::pow;
   using std::powf;
   using std::powl;
 
   using std::sqrt;
   using std::sqrtf;
   using std::sqrtl;
 

libcxx/modules/std/filesystem.cppm

export namespace std::filesystem {
 
   // [fs.dir.itr.nonmembers], range access for directory iterators
   using std::filesystem::begin;
   using std::filesystem::end;
 
   // [fs.class.rec.dir.itr], recursive directory iterators
   using std::filesystem::recursive_directory_iterator;
 
   // [fs.rec.dir.itr.nonmembers], range access for recursive directory iterators
-  using std::filesystem::begin;
-  using std::filesystem::end;
 
   // [fs.class.file.status], file status
   using std::filesystem::file_status;
   using std::filesystem::space_info;
 
   // [fs.enum], enumerations
   using std::filesystem::copy_options;
   using std::filesystem::directory_options;
   using std::filesystem::file_type;

libcxx/modules/std/iterator.cppm

export namespace std {
 
   using std::indirect_strict_weak_order;
 
   using std::indirect_result_t;
 
   // [projected], projected
   using std::projected;
 
-  using std::incrementable_traits;
-
   // [alg.req], common algorithm requirements
   // [alg.req.ind.move], concept indirectly_movable
   using std::indirectly_movable;
 
   using std::indirectly_movable_storable;
 
   // [alg.req.ind.copy], concept indirectly_copyable
   using std::indirectly_copyable;
export namespace std {
   using std::move_iterator;
 
   using std::make_move_iterator;
 
   using std::move_sentinel;
 
   using std::common_iterator;
 
-  using std::incrementable_traits;
-
   // [default.sentinel], default sentinel
   using std::default_sentinel;
   using std::default_sentinel_t;
 
   // [iterators.counted], counted iterators
   using std::counted_iterator;
 
   // [unreachable.sentinel], unreachable sentinel

libcxx/modules/std/memory.cppm

export namespace std {
 
   // [unique.ptr], class template unique_ptr
   using std::default_delete;
   using std::unique_ptr;
 
   using std::make_unique;
   using std::make_unique_for_overwrite;
 
-  using std::swap;
-
   using std::operator<;
   using std::operator>;
   using std::operator<=;
   using std::operator>=;
   using std::operator<=>;
 
   using std::operator<<;
 

libcxx/modules/std/numbers.cppm

export namespace std::numbers {
   using std::numbers::ln2_v;
   using std::numbers::log10e_v;
   using std::numbers::log2e_v;
   using std::numbers::phi_v;
   using std::numbers::pi_v;
   using std::numbers::sqrt2_v;
   using std::numbers::sqrt3_v;
 
-  using std::numbers::e_v;
-  using std::numbers::egamma_v;
-  using std::numbers::inv_pi_v;
-  using std::numbers::inv_sqrt3_v;
-  using std::numbers::inv_sqrtpi_v;
-  using std::numbers::ln10_v;
-  using std::numbers::ln2_v;
-  using std::numbers::log10e_v;
-  using std::numbers::log2e_v;
-  using std::numbers::phi_v;
-  using std::numbers::pi_v;
-  using std::numbers::sqrt2_v;
-  using std::numbers::sqrt3_v;
-
   using std::numbers::e;
   using std::numbers::egamma;
   using std::numbers::inv_pi;
   using std::numbers::inv_sqrt3;
   using std::numbers::inv_sqrtpi;
   using std::numbers::ln10;
   using std::numbers::ln2;
   using std::numbers::log10e;
   using std::numbers::log2e;
   using std::numbers::phi;
   using std::numbers::pi;
   using std::numbers::sqrt2;
   using std::numbers::sqrt3;
 } // namespace std::numbers

libcxx/modules/std/stack.cppm

 #include <stack>
 
 export module std:stack;
 export namespace std {
   // [stack], class template stack
   using std::stack;
 
   using std::operator==;
-  using std::operator==;
   using std::operator!=;
   using std::operator<;
   using std::operator>;
   using std::operator<=;
   using std::operator>=;
   using std::operator<=>;
 
   using std::swap;
   using std::uses_allocator;
 } // namespace std

libcxx/modules/std/tuple.cppm

export namespace std {
   using std::apply;
 
   using std::make_from_tuple;
 
   // [tuple.helper], tuple helper classes
   using std::tuple_element;
   using std::tuple_size;
 
-  using std::tuple_element_t;
-
   // [tuple.elem], element access
   using std::get;
   using std::tuple_element_t;
 
   // [tuple.rel], relational operators
   using std::operator==;
   using std::operator<=>;
 

libcxx/modules/std/utility.cppm

export namespace std {
   using std::operator<=>;
 
   using std::make_pair;
 
   // [pair.astuple], tuple-like access to pair
   using std::tuple_element;
   using std::tuple_size;
 
-  using std::tuple_element;
-  using std::tuple_size;
-
   using std::get;
 
   // [pair.piecewise], pair piecewise construction
   using std::piecewise_construct;
   using std::piecewise_construct_t;
 
   // in-place construction
   using std::in_place;

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

 
 void header_exportable_declarations::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
   // there are no public names in the Standard starting with an underscore, so
   // no need to check the strict rules.
   using namespace clang::ast_matchers;
 
   switch (file_type_) {
   case FileType::Header:
-
     finder->addMatcher(
         namedDecl(
             // Looks at the common locations where headers store their data
             // * header
             // * __header/*.h
             // * __fwd/header.h
             anyOf(isExpansionInFileMatching(("v1/__" + filename_ + "/").str()),
                   isExpansionInFileMatching(extra_header_),
if (is_reserved_name(name))
       return;
 
     // For modules (std, std.compat) only take the declarations exported from the partitions.
     // Making sure no declatations of headers are compared.
     if (file_type_ == FileType::Module)
       if (clang::Module* M = decl->getOwningModule(); M && M->Kind != clang::Module::ModulePartitionInterface)
         return;
 
-    if (decls_.contains(name))
+    if (decls_.contains(name)) {
+      // For modules avoid exporting the same named declaration twice. For
+      // header files this is common and valid.
+      if (file_type_ == FileType::ModulePartition)
+        // After the warning the script continues.
+        // The test will fail since modules have duplicated entries and headers not.
+        llvm::errs() << "Duplicated export of '" << name << "'.\n";
+      else
         return;
+    }
 
     std::cout << "using " << std::string{name} << ";\n";
     decls_.insert(name);
   }
 }
 
 } // namespace libcpp