Translation-unit-local entities (since C++20)

// 无翻译单元局部约束的模块单元
export module Foo;
import <iostream>;
namespace
{
   class LolWatchThis {        // 内部链接，不可导出
       static void say_hello()
       {
           std::cout << "Hello, everyone!\n";
       }
   };
}
export LolWatchThis lolwut() { // LolWatchThis 作为返回类型被暴露
    return LolWatchThis();
}

// main.cpp
import Foo;
int main()
{
    auto evil = lolwut();        // 'evil' 的类型为 'LolWatchThis'
    decltype(evil)::say_hello(); // 'LolWatchThis' 的定义不再是内部定义
}

// 具有内部链接的翻译单元局部实体
namespace { // 无名命名空间内声明的所有名称均具有内部链接
    int tul_var = 1;                          // 翻译单元局部变量
    int tul_func() { return 1; }              // 翻译单元局部函数
    struct tul_type { int mem; };             // 翻译单元局部（类）类型
}
template<typename T>
static int tul_func_temp() { return 1; }      // 翻译单元局部模板
// 翻译单元局部模板特化
template<>
static int tul_func_temp<int>() { return 3; } // 翻译单元局部特化
// 使用翻译单元局部模板参数的模板特化
template <> struct std::hash<tul_type> {      // 翻译单元局部特化
    std::size_t operator()(const tul_type& t) const { return 4u; }
};

static int tul_var = 1;             // TU局部变量
static int tul_func() { return 1; } // TU局部函数
int* tul_var_ptr = &tul_var;        // TU局部：指向TU局部变量的指针
int (* tul_func_ptr)() = &tul_func; // TU局部：指向TU局部函数的指针
constexpr static int tul_const = 1; // 可在常量表达式中使用的TU局部变量
int tul_arr[] = { tul_const };      // TU局部：由constexpr TU局部对象构成的数组
struct tul_class { int mem; };
tul_class tul_obj{tul_const};       // TU局部：包含constexpr TU局部对象成员的结构体

// lambda 命名
auto x = [] {}; // 命名 decltype(x)
// 非函数（模板）命名
int y1 = 1;                      // 命名 y1（标识表达式）
struct y2 { int mem; };
y2 y2_obj{1};                    // 命名 y2（类型说明符）
struct y3 { int mem_func(); };
int y3::mem_func() { return 0; } // 命名 y3（嵌套名称说明符）
template<typename T> int y4 = 1;
int var = y4<y2>;                // 命名 y4（模板名称）
template<typename T> concept y5 = true;
template<typename T> void func(T&&) requires y5<T>; // 命名 y5（概念名称）
// 函数（模板）命名
int z1(int arg)    { std::cout << "no overload"; return 0; }
int z2(int arg)    { std::cout << "overload 1";  return 1; }
int z2(double arg) { std::cout << "overload 2";  return 2; }
int val1 = z1(0); // 命名 z1
int val2 = z2(0); // 命名 z2（ int z2(int) ）

export module A;
static void f() {}
inline void it() { f(); }         // 错误：暴露了 f
static inline void its() { f(); } // 正确
template<int> void g() { its(); } // 正确
template void g<0>();
decltype(f) *fp;                             // 错误：f（尽管其类型不是）是翻译单元局部
auto &fr = f;                                // 正确
constexpr auto &fr2 = fr;                    // 错误：暴露了 f
constexpr static auto fp2 = fr;              // 正确
struct S { void (&ref)(); } s{f};            // 正确：值是翻译单元局部
constexpr extern struct W { S &s; } wrap{s}; // 正确：值不是翻译单元局部
static auto x = []{ f(); }; // 正确
auto x2 = x;                // 错误：闭包类型是翻译单元局部
int y = ([]{ f(); }(), 0);  // 错误：闭包类型不是翻译单元局部
int y2 = (x, 0);            // 正确
namespace N
{
    struct A {};
    void adl(A);
    static void adl(int);
}
void adl(double);
inline void h(auto x) { adl(x); } // 正确，但特化可能成为暴露

module A;
void other()
{
    g<0>();                  // 正确：特化已显式实例化
    g<1>();                  // 错误：实例化使用了当前翻译单元局部的 its
    h(N::A{});               // 错误：重载集包含当前翻译单元局部的 N::adl(int)
    h(0);                    // 正确：调用 adl(double)
    adl(N::A{});             // 正确：未找到 N::adl(int)，调用 N::adl(N::A)
    fr();                    // 正确：调用 f
    constexpr auto ptr = fr; // 错误：fr 在此处不能用于常量表达式
}