[C++20 modules] error: cannot befriend target of using declaration

[bangerth]

(This is an outgrowth of my work discussed in #127561 and related to dealii/dealii#18071. @ChuanqiXu9: FYI)

The collection of module partition units below produces a bunch of errors of the following kind:

/usr/bin/clang++-20   -std=c++20 -stdlib=libc++ -MD -MT CMakeFiles/test.dir/b.cc.o -MF CMakeFiles/test.dir/b.cc.o.d @CMakeFiles/test.dir/b.cc.o.modmap -o CMakeFiles/test.dir/b.cc.o -c /home/bangerth/tmp/bug/b.cc
In module 'test:A' imported from /home/bangerth/tmp/bug/b.cc:6:
/usr/include/c++/v1/__random/mersenne_twister_engine.h:223:15: error: cannot befriend target of using declaration
  223 |   friend bool operator==(
      |               ^
/home/bangerth/tmp/bug/b.cc:12:16: note: in instantiation of template class 'std::mersenne_twister_engine<unsigned long, 32, 624, 397, 31, 2567483615, 11, 4294967295, 7, 2636928640, 15, 4022730752, 18, 1812433253>' requested here
   12 |   std::mt19937 x1, x2;
      |                ^
/usr/include/c++/v1/__random/mersenne_twister_engine.h:764:1: note: target of using declaration
  764 | operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
      | ^
/home/bangerth/tmp/bug/std.ccm:23:14: note: using declaration
   23 |   using std::operator==;
      |              ^
In module 'test:A' imported from /home/bangerth/tmp/bug/b.cc:6:
/usr/include/c++/v1/__random/mersenne_twister_engine.h:241:15: error: cannot befriend target of using declaration
  241 |   friend bool operator!=(
      |               ^
/usr/include/c++/v1/__random/mersenne_twister_engine.h:807:1: note: target of using declaration
  807 | operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
      | ^
/home/bangerth/tmp/bug/std.ccm:24:14: note: using declaration
   24 |   using std::operator!=;
      |              ^
[...]

I can't see any good reason for this -- it seems like a bug to me.

Here are the relevant files:

// a.ccm
module;
#include <random>
export module test:A;
export {}

// std.ccm
module;

#include <mutex>
#include <random>

export module test:std;

export {
  namespace std {
    using std::mt19937;
    using std::mutex;
    using std::operator==;
    using std::operator!=;
    // Would ordinarily contain much more stuff here...
  } // namespace std


#if defined(_LIBCPP_VERSION) // For CLang's support library

  _LIBCPP_BEGIN_NAMESPACE_STD

  using std::operator==;
  using std::operator!=;

  _LIBCPP_END_NAMESPACE_STD

#endif
} // export

// b.cc
module;

module test:B;

import :std;
import :A;

bool test()
{
  static std::mutex rand_mutex; // Necessary, for unclear reasons

  std::mt19937 x1, x2;
  return (x1 == x2) && (x1 != x2);
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.28 FATAL_ERROR)

project(test LANGUAGES CXX)
add_library(test)
target_compile_features(test PUBLIC cxx_std_20)
target_sources(test PUBLIC
	FILE_SET CXX_MODULES
	FILES
	  std.ccm
	  a.ccm
	  b.cc)

Here are a couple of observations:

• The errors go away if I remove the #include <random> from a.ccm. Because a.ccm does not actually export anything, the presence of <random> does not strike me as wrong. In my original testcase, I cannot remove it because it is transitively #included by something else I actually need in that file -- a.ccm wraps an external library of which one of the headers happens to #include <random>.
• The :std partition also exports the symbols in _LIBCPP_BEGIN_NAMESPACE_STD. This is needed to avoid other errors, and is something that @davidstone had already realized in https://github.com/davidstone/std_module/blob/d121f1701884953c9ca468b159b530556e2475a3/source/std_module.cpp, for example. If I remove these lines, the error goes away, but I get many more errors in other places in return (just not for this minimal testcase).

[llvmbot]

@llvm/issue-subscribers-clang-modules

Author: Wolfgang Bangerth (bangerth)

(This is an outgrowth of my work discussed in #127561 and related to https://github.com/dealii/dealii/issues/18071. @ChuanqiXu9: FYI)

The collection of module partition units below produces a bunch of errors of the following kind:

/usr/bin/clang++-20   -std=c++20 -stdlib=libc++ -MD -MT CMakeFiles/test.dir/b.cc.o -MF CMakeFiles/test.dir/b.cc.o.d @<!-- -->CMakeFiles/test.dir/b.cc.o.modmap -o CMakeFiles/test.dir/b.cc.o -c /home/bangerth/tmp/bug/b.cc
In module 'test:A' imported from /home/bangerth/tmp/bug/b.cc:6:
/usr/include/c++/v1/__random/mersenne_twister_engine.h:223:15: error: cannot befriend target of using declaration
  223 |   friend bool operator==(
      |               ^
/home/bangerth/tmp/bug/b.cc:12:16: note: in instantiation of template class 'std::mersenne_twister_engine&lt;unsigned long, 32, 624, 397, 31, 2567483615, 11, 4294967295, 7, 2636928640, 15, 4022730752, 18, 1812433253&gt;' requested here
   12 |   std::mt19937 x1, x2;
      |                ^
/usr/include/c++/v1/__random/mersenne_twister_engine.h:764:1: note: target of using declaration
  764 | operator==(const mersenne_twister_engine&lt;_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp&gt;&amp; __x,
      | ^
/home/bangerth/tmp/bug/std.ccm:23:14: note: using declaration
   23 |   using std::operator==;
      |              ^
In module 'test:A' imported from /home/bangerth/tmp/bug/b.cc:6:
/usr/include/c++/v1/__random/mersenne_twister_engine.h:241:15: error: cannot befriend target of using declaration
  241 |   friend bool operator!=(
      |               ^
/usr/include/c++/v1/__random/mersenne_twister_engine.h:807:1: note: target of using declaration
  807 | operator!=(const mersenne_twister_engine&lt;_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp&gt;&amp; __x,
      | ^
/home/bangerth/tmp/bug/std.ccm:24:14: note: using declaration
   24 |   using std::operator!=;
      |              ^
[...]

I can't see any good reason for this -- it seems like a bug to me.

Here are the relevant files:

// a.ccm
module;
#include <random>
export module test:A;
export {}

// std.ccm
module;

#include <mutex>
#include <random>

export module test:std;

export {
  namespace std {
    using std::mt19937;
    using std::mutex;
    using std::operator==;
    using std::operator!=;
    // Would ordinarily contain much more stuff here...
  } // namespace std


#if defined(_LIBCPP_VERSION) // For CLang's support library

  _LIBCPP_BEGIN_NAMESPACE_STD

  using std::operator==;
  using std::operator!=;

  _LIBCPP_END_NAMESPACE_STD

#endif
} // export

// b.cc
module;

module test:B;

import :std;
import :A;

bool test()
{
  static std::mutex rand_mutex; // Necessary, for unclear reasons

  std::mt19937 x1, x2;
  return (x1 == x2) && (x1 != x2);
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.28 FATAL_ERROR)

project(test LANGUAGES CXX)
add_library(test)
target_compile_features(test PUBLIC cxx_std_20)
target_sources(test PUBLIC
	FILE_SET CXX_MODULES
	FILES
	  std.ccm
	  a.ccm
	  b.cc)

Here are a couple of observations:

• The errors go away if I remove the #include <random> from a.ccm. Because a.ccm does not actually export anything, the presence of <random> does not strike me as wrong. In my original testcase, I cannot remove it because it is transitively #included by something else I actually need in that file -- a.ccm wraps an external library of which one of the headers happens to #include <random>.
• The :std partition also exports the symbols in _LIBCPP_BEGIN_NAMESPACE_STD. This is needed to avoid other errors, and is something that @davidstone had already realized in https://github.com/davidstone/std_module/blob/d121f1701884953c9ca468b159b530556e2475a3/source/std_module.cpp, for example. If I remove these lines, the error goes away, but I get many more errors in other places in return (just not for this minimal testcase).

[bangerth]

For completeness, this is with CLang 20:

> /usr/bin/clang++-20 --version
Ubuntu clang version 20.1.5 (++20250430014901+ebfae55af454-1~exp1~20250430014920.111)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/lib/llvm-20/bin

[bangerth]

I should also say that I can produce similar errors using std::queue. This one just was the shortest case I could come up with.

[bangerth]

This seems related to #61125.

[ChuanqiXu9]

Have you tried to remove using ==?

I did a simple reproducer:

$cat a.h
class A {
public:
	A();
private:
	friend bool operator==(const A&, const A&) { return true; }
};

$cat a.cppm
module;
#include "a.h"
export module a;
export using ::A;

$cat b.cpp
import a;
bool func() {
	A a1, a2;
	return a1 == a2;
}

$clang++ -std=c++20 a.cppm --precompile -o a.pcm
$clang++ -std=c++20 b.cpp -fmodule-file=a=a.pcm -fsyntax-only

[bangerth]

I can try that at home tonight, but that's not a solution for me. The using std::operator==; statement is in the file that wraps all of namespace std. I may perhaps not need the using declaration for the current case, but I do need it for the many other classes that have std::operator== implemented. Since the targets of using declarations are names, not individual functions, I cannot distinguish between the many overloads of std::operator== to select only a subset to export.

[ChuanqiXu9]

I can try that at home tonight, but that's not a solution for me. The using std::operator==; statement is in the file that wraps all of namespace std. I may perhaps not need the using declaration for the current case, but I do need it for the many other classes that have std::operator== implemented. Since the targets of using declarations are names, not individual functions, I cannot distinguish between the many overloads of std::operator== to select only a subset to export.

The problem is, if the operator== is implemented as an inline definition in the class, I feel it may not be valid to using it. According to the explanation here #61125 (comment)

[bangerth]

Based on the discussion in #61125:

@ChuanqiXu9 Does whatever change cause this issue to be fixed also fix #138558?

I didn't search the commit that makes this issue closed. But #138558 is different than the current one. I feel from what @AaronBallman said, the friend declaration won't be looked up. Since in the current issue, there is a declaration n::aa in the namespace (out of the friend declaration), but in your example, the friend declaration is defined inside the class. This is the difference.

We can see it clearly from the non modular example: https://godbolt.org/z/45jsr61WM

So... we can't fix it since it is not an "issue"

In that case, however, we need adjustments to libc++. If classes such as std::mersenne_twister_engine declare their operator==()s as friend functions, and if these are not automatic targets of using declarations, then we can't wrap these classes into modules because we can't wrap their operator==()s. The fix, in that case, is that these classes need to declare these operators outside the class, though they can of course implement them as they currently do.

[bangerth]

Separately, though, I shrunk the testcase some more:

// a.ccm
module;
#include <random>
export module test:A;
export {}

// std.ccm
module;

#include <mutex>
#include <random>


export module test:std;

export {
  namespace std {
    using std::mt19937;
    // Would ordinarily contain much more stuff here...
  } // namespace std


#if defined(_LIBCPP_VERSION) // For CLang's support library

  _LIBCPP_BEGIN_NAMESPACE_STD

  using std::operator==;

  _LIBCPP_END_NAMESPACE_STD

#endif
} // export

// b.cc
module;

module test:B;

import :std;
import :A;

void test()
{
  std::mt19937 x;
}

This results in the following error:

In module 'test:A' imported from /home/bangerth/tmp/bug/b.cc:6:
/usr/include/c++/v1/__random/mersenne_twister_engine.h:223:15: error: cannot befriend target of using declaration
  223 |   friend bool operator==(
      |               ^
/home/bangerth/tmp/bug/b.cc:10:16: note: in instantiation of template class 'std::mersenne_twister_engine<unsigned long, 32, 624, 397, 31, 2567483615, 11, 4294967295, 7, 2636928640, 15, 4022730752, 18, 1812433253>' requested here
   10 |   std::mt19937 x;
      |                ^
/usr/include/c++/v1/__random/mersenne_twister_engine.h:764:1: note: target of using declaration
  764 | operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
      | ^
/home/bangerth/tmp/bug/std.ccm:20:14: note: using declaration
   20 |   using std::operator==;
      |              ^

As I said elsewhere, I cannot omit the using std::operator== line because in a "real" std.ccm, I would wrap many many more classes and would need to wrap their respective operator==s as well. In the end, it doesn't matter very much to me whether this is addressed in the compiler or the library :-)

[ChuanqiXu9]

Wait, I don't understand the problem now. Here is another example to using == while it is not a friend.

$ cat a.h
class A {
public:
	A();
private:
	friend bool operator==(const A&, const A&) { return true; }
};

struct B {};
inline bool operator==(const B&, const B&) { return true; }

$ cat a.cppm
module;
#include "a.h"
export module a;
export using ::A;
export using ::B;
export using ::operator==;

$ cat b.cpp
import a;
bool func() {
	A a1, a2;
	B b1, b2;
	return a1 == a2 && b1 == b2;
}

$ clang++ -std=c++20 a.cppm --precompile -o a.pcm
$ clang++ -std=c++20 b.cpp -fmodule-file=a=a.pcm -fsyntax-only

And it works as expected.

Would you like to make a minimal example so that we can align up?