[C++20][Modules] Adjust handling of exports of namespaces and using-decls.

[iains]

Summary

This adjusts the handling for:

export module M;

export namespace {};

export namespace N {};
export using namespace N;

In the first case, we were allowing empty anonymous namespaces
as part of an extension allowing empty top-level entities, but that seems
inappropriate in this case, since the linkage would be internal for the
anonymous namespace. We now report an error for this.

The second case was producing a warning diagnostic that this was
accepted as an extension - however the C++20 standard does allow this
as well-formed.

In the third case we keep the current practice that this is accepted with a
warning (as an extension). The C++20 standard says it's an error.

We also ensure that using decls are only applied to items with external linkage.

This adjusts error messages for exports involving redeclarations in modules to
be more specific about the reason that the decl has been rejected.

[iains]

this covers most of the tests from the standard section 10.3 (one to follow that has an additional dependency on header units)

note the change in the "cannot export redeclaration 'xxxx here since the previous declaration" errors to include a more specific reason than before.

[ChuanqiXu]

clang/include/clang/Basic/DiagnosticSemaKinds.td

7856–7858

I feel this change is not intended?

clang/lib/Sema/SemaDecl.cpp

1682–1689

It looks like that this change isn't reflected in the summary. Although this is not bad, I feel it is not good. From the perspective of the user, I feel the new message here is a little bit more confusing.

clang/lib/Sema/SemaModule.cpp

822–824

Unnecessary change?

830–831

nit: the general style in clang/llvm I see is to use (bool) conversion.

861–862

I think we should remove it. So that the above if could be further merged.

[iains]

So the adjustment to the error message is something I am 50/50 about (IMO it makes some messages more useful, but maybe not needed in others).

Without the change we get
"cannot export redeclaration 'xxx' here since the previous declaration is not exported"

So, e.g in C++20 10.2 example 6. every case has the same error message (which was what prompted me to make the change).

With the change here we now get:
cannot export redeclaration 'f' here since the previous declaration has internal linkage
cannot export redeclaration 'S' here since the previous declaration has module linkage

which seems maybe to be more helpful to the user in telling them why.

I hope others can weigh in with an opinion here .. @dblaikie @vsapsai ?

clang/include/clang/Basic/DiagnosticSemaKinds.td

7856–7858

the change is intentional, but we should maybe decide if it is more or less helpful to the user.

clang/lib/Sema/SemaDecl.cpp

1682–1689

it is reflected in the summary:

"
This adjusts error messages for exports involving redeclarations in modules to
be more specific about the reason that the decl has been rejected.
"
Iet us discuss whether this is more/less useful outside of the code.

[ChuanqiXu]

In D122119#3398823, @iains wrote:

So the adjustment to the error message is something I am 50/50 about (IMO it makes some messages more useful, but maybe not needed in others).

Without the change we get
"cannot export redeclaration 'xxx' here since the previous declaration is not exported"

So, e.g in C++20 10.2 example 6. every case has the same error message (which was what prompted me to make the change).

With the change here we now get:
cannot export redeclaration 'f' here since the previous declaration has internal linkage
cannot export redeclaration 'S' here since the previous declaration has module linkage

which seems maybe to be more helpful to the user in telling them why.

I hope others can weigh in with an opinion here .. @dblaikie @vsapsai ?

I am OK to wait for opinions from others. Let me talk it a little bit more.

The first feeling I saw the change is that not every C++ programmer knows about linkage. OK, it depends on the environment really and every one might has their own opinion.

Another thought is that 10.2.6 (http://eel.is/c++draft/module.interface#6) doesn't talk anything about linkage:

A redeclaration of an entity X is implicitly exported if X was introduced by an exported declaration; otherwise it shall not be exported.

So it looks like confusing to talk about linkage this time. In my imagination, there might be a such situation:

A programmer met the error when he tries to export a redeclaration which is internal linkage (maybe a simple const variable). Then the message told him the internal linkage is not allowed to re-export. Then he removes the const specifier. Now he meets the error again. It tells that we couldn't export redeclaration which is module linkage. I guess he would feel bad. Then he might try to export the first declaration to get passed. However, the const specifier is lost in the case. And in the current message, I guess he would add export to the first declaration directly after he reads the message.

[iains]

In D122119#3398949, @ChuanqiXu wrote:

In D122119#3398823, @iains wrote:

So the adjustment to the error message is something I am 50/50 about (IMO it makes some messages more useful, but maybe not needed in others).

Without the change we get
"cannot export redeclaration 'xxx' here since the previous declaration is not exported"

So, e.g in C++20 10.2 example 6. every case has the same error message (which was what prompted me to make the change).

With the change here we now get:
cannot export redeclaration 'f' here since the previous declaration has internal linkage
cannot export redeclaration 'S' here since the previous declaration has module linkage

which seems maybe to be more helpful to the user in telling them why.

I hope others can weigh in with an opinion here .. @dblaikie @vsapsai ?

I am OK to wait for opinions from others. Let me talk it a little bit more.

The first feeling I saw the change is that not every C++ programmer knows about linkage. OK, it depends on the environment really and every one might has their own opinion.

Another thought is that 10.2.6 (http://eel.is/c++draft/module.interface#6) doesn't talk anything about linkage:

A redeclaration of an entity X is implicitly exported if X was introduced by an exported declaration; otherwise it shall not be exported.

So it looks like confusing to talk about linkage this time. In my imagination, there might be a such situation:

A programmer met the error when he tries to export a redeclaration which is internal linkage (maybe a simple const variable). Then the message told him the internal linkage is not allowed to re-export. Then he removes the const specifier. Now he meets the error again. It tells that we couldn't export redeclaration which is module linkage. I guess he would feel bad. Then he might try to export the first declaration to get passed. However, the const specifier is lost in the case. And in the current message, I guess he would add export to the first declaration directly after he reads the message.

yes, that seems like a reasonable counter argument, and perhaps talking about linkage in a user message is a bit "implementor speak"..
... as I said, I was kind of 50/50 about this - I'll wait 48h for any other comments and then remove the change if there are no votes in favour.

[urnathan]

In D122119#3398823, @iains wrote:

With the change here we now get:
cannot export redeclaration 'f' here since the previous declaration has internal linkage
cannot export redeclaration 'S' here since the previous declaration has module linkage

which seems maybe to be more helpful to the user in telling them why.

I hope others can weigh in with an opinion here .. @dblaikie @vsapsai ?

Yes, this is more helpful -- tell the user what the compiler thinks it is, rather than what it thinks it is not.

[urnathan]

In D122119#3398949, @ChuanqiXu wrote:

The first feeling I saw the change is that not every C++ programmer knows about linkage. OK, it depends on the environment really and every one might has their own opinion.

You may be confusing object-file linkage with the linkage concepts of C++, which are specified in [basic.link]? Sadly we have to live with the overloaded term.

Another thought is that 10.2.6 (http://eel.is/c++draft/module.interface#6) doesn't talk anything about linkage:

A redeclaration of an entity X is implicitly exported if X was introduced by an exported declaration; otherwise it shall not be exported.

So it looks like confusing to talk about linkage this time. In my imagination, there might be a such situation:

A programmer met the error when he tries to export a redeclaration which is internal linkage (maybe a simple const variable). Then the message told him the internal linkage is not allowed to re-export. Then he removes the const specifier. Now he meets the error again. It tells that we couldn't export redeclaration which is module linkage. I guess he would feel bad. Then he might try to export the first declaration to get passed. However, the const specifier is lost in the case. And in the current message, I guess he would add export to the first declaration directly after he reads the message.

further, with attachment, the original error 'cannot export as previous was not exported' is not correct in general. Consider:

module;
Pretend this is from #include, ok?
void Foo ();
module bob;
extern "C++" export void Foo (); can export even though prior was not exported

[dblaikie]

SOrry, I don't have much context here - the more informative (module/internal linkage) diagnostic does seem better to me than saying "is not exported", even if it's a bit esoteric for some users. We do have other diagnostics that mention linkage, I'm sure (because it's necessary/useful to describe certain things).

Without much context on this patch: is the diagnostic change a necessary part of the patch? (is the diagnostic new regardless of which wording option is chosen? or is this affecting an existing diagnostic?) - if it's possible to separate the diagnostic change from the rest of the patch that's probably a good thing to do regardless of the choice. If not, yeah, I think going with the more explicit/nuanced diagnostic wording seems better to me at a glance.

[ChuanqiXu]

In D122119#3400032, @urnathan wrote:

In D122119#3398949, @ChuanqiXu wrote:

The first feeling I saw the change is that not every C++ programmer knows about linkage. OK, it depends on the environment really and every one might has their own opinion.

You may be confusing object-file linkage with the linkage concepts of C++, which are specified in [basic.link]? Sadly we have to live with the overloaded term.

Another thought is that 10.2.6 (http://eel.is/c++draft/module.interface#6) doesn't talk anything about linkage:

A redeclaration of an entity X is implicitly exported if X was introduced by an exported declaration; otherwise it shall not be exported.

So it looks like confusing to talk about linkage this time. In my imagination, there might be a such situation:

A programmer met the error when he tries to export a redeclaration which is internal linkage (maybe a simple const variable). Then the message told him the internal linkage is not allowed to re-export. Then he removes the const specifier. Now he meets the error again. It tells that we couldn't export redeclaration which is module linkage. I guess he would feel bad. Then he might try to export the first declaration to get passed. However, the const specifier is lost in the case. And in the current message, I guess he would add export to the first declaration directly after he reads the message.

further, with attachment, the original error 'cannot export as previous was not exported' is not correct in general. Consider:

module;
Pretend this is from #include, ok?
void Foo ();
module bob;
extern "C++" export void Foo (); can export even though prior was not exported

I think the example is invalid since it violates [[ http://eel.is/c++draft/module.interface#6 | [module.interface]p6 ]] explicitly. If this is intended behavior or by design, we should change the wording.

[urnathan]

In D122119#3401322, @ChuanqiXu wrote:

I think the example is invalid since it violates [[ http://eel.is/c++draft/module.interface#6 | [module.interface]p6 ]] explicitly. If this is intended behavior or by design, we should change the wording.

That wording failed to be updated when the linkage-decl changes went in. I'll add a note to DR 2541. Linkage specifications, module purview, and module attachment

[ChuanqiXu]

In D122119#3402168, @urnathan wrote:

In D122119#3401322, @ChuanqiXu wrote:

I think the example is invalid since it violates [[ http://eel.is/c++draft/module.interface#6 | [module.interface]p6 ]] explicitly. If this is intended behavior or by design, we should change the wording.

That wording failed to be updated when the linkage-decl changes went in. I'll add a note to DR 2541. Linkage specifications, module purview, and module attachment

OK, if the wording is not consistent with the design, I have no further objections.

[iains]

In D122119#3400267, @dblaikie wrote:

SOrry, I don't have much context here - the more informative (module/internal linkage) diagnostic does seem better to me than saying "is not exported", even if it's a bit esoteric for some users. We do have other diagnostics that mention linkage, I'm sure (because it's necessary/useful to describe certain things).

Without much context on this patch: is the diagnostic change a necessary part of the patch? (is the diagnostic new regardless of which wording option is chosen? or is this affecting an existing diagnostic?) - if it's possible to separate the diagnostic change from the rest of the patch that's probably a good thing to do regardless of the choice. If not, yeah, I think going with the more explicit/nuanced diagnostic wording seems better to me at a glance.

The diagnostic change was made so that the test cases introduced by the patch could have (diagnostic) wording that reflected the examples in the standard. As such, it seemed reasonable to make the change at the same time. I can split it out of course if that still seems better given the clarification.

[iains]

rebased, addressed review comments.

clang/lib/Sema/SemaModule.cpp

861–862

we can remove the else ; but we cannot merge the !HasName into the if (that changes the logic of the expression such that empty & unnamed namespace decls get passed to checkExportedDeclContext()) - which emits a diagnostic not expected by the standard.

For me, the 'else ;' makes it clear what the alternative is doing (and there's a comment as well) - but if the general opinions is to remove it, that's also fine.

[iains]

@dblaikie - is the explanation for the change in diagnostics at the same time OK? (if not, I am happy to split the patch, but either way I'd like to land what is acceptable soonish).

[dblaikie]

In D122119#3432220, @iains wrote:

@dblaikie - is the explanation for the change in diagnostics at the same time OK? (if not, I am happy to split the patch, but either way I'd like to land what is acceptable soonish).

I think it'll be OK as-is.

[erichkeane]

clang/lib/Sema/SemaModule.cpp

861–862

I'd much prefer we did NOT do the empty else/semicolon here. This ends up causing a warning with GCC ( warning: suggest braces around empty body in an ‘else’ statement [-Wempty-body] ) and is jsut strange. I don't mind a comment, but the else/; is strange.

[iains]

clang/lib/Sema/SemaModule.cpp

861–862

I committed:
rG92fed06f800a: [C++20][Modules] Remove an empty statement [NFC].
to resolve this.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 
 def err_expected_class_or_namespace : Error<"%0 is not a class"
   "%select{ or namespace|, namespace, or enumeration}1">;
 def err_invalid_declarator_scope : Error<"cannot define or redeclare %0 here "
   "because namespace %1 does not enclose namespace %2">;
 def err_export_non_namespace_scope_name : Error<
   "cannot export %0 as it is not at namespace scope">;
 def err_redeclaration_non_exported : Error <
-  "cannot export redeclaration %0 here since the previous declaration is not "
-  "exported">;
+  "cannot export redeclaration %0 here since the previous declaration "
+  "%select{is not exported|has internal linkage|has module linkage}1">;
 def err_invalid_declarator_global_scope : Error<
   "definition or redeclaration of %0 cannot name the global scope">;
 def err_invalid_declarator_in_function : Error<
   "definition or redeclaration of %0 not allowed inside a function">;
 def err_invalid_declarator_in_block : Error<
   "definition or redeclaration of %0 not allowed inside a block">;
 def err_not_tag_in_scope : Error<
   "no %select{struct|interface|union|class|enum}0 named %1 in %2">;
 
def err_export_within_anonymous_namespace : Error<
   "export declaration appears within anonymous namespace">;
 def note_anonymous_namespace : Note<"anonymous namespace begins here">;
 def ext_export_no_name_block : ExtWarn<
   "ISO C++20 does not permit %select{an empty|a static_assert}0 declaration "
   "to appear in an export block">, InGroup<ExportUnnamed>;
 def ext_export_no_names : ExtWarn<
   "ISO C++20 does not permit a declaration that does not introduce any names "
   "to be exported">, InGroup<ExportUnnamed>;
+def introduces_no_names : Error<
+  "declaration does not introduce any names to be exported">;
 def note_export : Note<"export block begins here">;
 def err_export_no_name : Error<
   "%select{empty|static_assert|asm}0 declaration cannot be exported">;
 def ext_export_using_directive : ExtWarn<
   "ISO C++20 does not permit using directive to be exported">,
   InGroup<DiagGroup<"export-using-directive">>;
 def err_export_within_export : Error<
   "export declaration appears within another export declaration">;
 def err_export_internal : Error<
   "declaration of %0 with internal linkage cannot be exported">;
 def err_export_using_internal : Error<
-  "using declaration referring to %0 with internal linkage cannot be exported">;
+  "using declaration referring to %1 with %select{internal|module|unknown}0 "
+  "linkage cannot be exported">;
 def err_export_not_in_module_interface : Error<
   "export declaration can only be used within a module interface unit"
   "%select{ after the module declaration|}0">;
 def err_export_partition_impl : Error<
   "module partition implementations cannot be exported">;
 def err_export_in_private_module_fragment : Error<
   "export declaration cannot be used in a private module fragment">;
 def note_private_module_fragment : Note<

clang/lib/Sema/SemaDecl.cpp

bool Sema::CheckRedeclarationExported(NamedDecl *New, NamedDecl *Old) {
   if (!IsNewExported && !IsOldExported)
     return false;
 
   if (IsOldExported)
     return false;
 
   assert(IsNewExported);
 
-  Diag(New->getLocation(), diag::err_redeclaration_non_exported) << New;
+  auto Lk = Old->getFormalLinkage();
+  int S = 0;
+  if (Lk == Linkage::InternalLinkage)
+    S = 1;
+  else if (Lk == Linkage::ModuleLinkage)
+    S = 2;
+  Diag(New->getLocation(), diag::err_redeclaration_non_exported) << New << S;
   Diag(Old->getLocation(), diag::note_previous_declaration);
   return true;
 }
 
 // A wrapper function for checking the semantic restrictions of
 // a redeclaration within a module.
 bool Sema::CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old) {
   if (CheckRedeclarationModuleOwnership(New, Old))
     return true;

clang/lib/Sema/SemaModule.cpp

static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
                                      SourceLocation BlockStart);
 
 namespace {
 enum class UnnamedDeclKind {
   Empty,
   StaticAssert,
   Asm,
   UsingDirective,
+  Namespace,
   Context
 };
 }
 
 static llvm::Optional<UnnamedDeclKind> getUnnamedDeclKind(Decl *D) {
   if (isa<EmptyDecl>(D))
     return UnnamedDeclKind::Empty;
   if (isa<StaticAssertDecl>(D))
case UnnamedDeclKind::StaticAssert:
     // Allow empty-declarations and static_asserts in an export block as an
     // extension.
     return InBlock ? diag::ext_export_no_name_block : diag::err_export_no_name;
 
   case UnnamedDeclKind::UsingDirective:
     // Allow exporting using-directives as an extension.
     return diag::ext_export_using_directive;
 
+  case UnnamedDeclKind::Namespace:
+    // Anonymous namespace with no content.
+    return diag::introduces_no_names;
+
   case UnnamedDeclKind::Context:
     // Allow exporting DeclContexts that transitively contain no declarations
     // as an extension.
     return diag::ext_export_no_names;
 
   case UnnamedDeclKind::Asm:
     return diag::err_export_no_name;
   }
   llvm_unreachable("unknown kind");
 }
 
 static void diagExportedUnnamedDecl(Sema &S, UnnamedDeclKind UDK, Decl *D,
                                     SourceLocation BlockStart) {
   S.Diag(D->getLocation(), getUnnamedDeclDiag(UDK, BlockStart.isValid()))
       << (unsigned)UDK;
   if (BlockStart.isValid())
     S.Diag(BlockStart, diag::note_export);
 }
 
 /// Check that it's valid to export \p D.
 static bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart) {
   // C++2a [module.interface]p3:
   //   An exported declaration shall declare at least one name
   if (auto UDK = getUnnamedDeclKind(D))
     diagExportedUnnamedDecl(S, *UDK, D, BlockStart);
 
   //   [...] shall not declare a name with internal linkage.
+  bool HasName = false;
   if (auto *ND = dyn_cast<NamedDecl>(D)) {
     // Don't diagnose anonymous union objects; we'll diagnose their members
     // instead.
-    if (ND->getDeclName() && ND->getFormalLinkage() == InternalLinkage) {
+    HasName = (bool)ND->getDeclName();
+    if (HasName && ND->getFormalLinkage() == InternalLinkage) {
       S.Diag(ND->getLocation(), diag::err_export_internal) << ND;
       if (BlockStart.isValid())
         S.Diag(BlockStart, diag::note_export);
     }
   }
 
   // C++2a [module.interface]p5:
   //   all entities to which all of the using-declarators ultimately refer
   //   shall have been introduced with a name having external linkage
   if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
     NamedDecl *Target = USD->getUnderlyingDecl();
-    if (Target->getFormalLinkage() == InternalLinkage) {
-      S.Diag(USD->getLocation(), diag::err_export_using_internal) << Target;
+    Linkage Lk = Target->getFormalLinkage();
+    if (Lk == InternalLinkage || Lk == ModuleLinkage) {
+      S.Diag(USD->getLocation(), diag::err_export_using_internal)
+          << (Lk == InternalLinkage ? 0 : 1) << Target;
       S.Diag(Target->getLocation(), diag::note_using_decl_target);
       if (BlockStart.isValid())
         S.Diag(BlockStart, diag::note_export);
     }
   }
 
   // Recurse into namespace-scope DeclContexts. (Only namespace-scope
-  // declarations are exported.)
-  if (auto *DC = dyn_cast<DeclContext>(D))
-    if (DC->getRedeclContext()->isFileContext() && !isa<EnumDecl>(D))
+  // declarations are exported.).
+  if (auto *DC = dyn_cast<DeclContext>(D)) {
+    if (isa<NamespaceDecl>(D) && DC->decls().empty()) {
+      if (!HasName)
+        // We don't allow an empty anonymous namespace (we don't allow decls
+        // in them either, but that's handled in the recursion).
+        diagExportedUnnamedDecl(S, UnnamedDeclKind::Namespace, D, BlockStart);
+      else
+        ; // We allow an empty named namespace decl.
+    } else if (DC->getRedeclContext()->isFileContext() && !isa<EnumDecl>(D))
       return checkExportedDeclContext(S, DC, BlockStart);
+  }
   return false;
 }
 
 /// Check that it's valid to export all the declarations in \p DC.
 static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
                                      SourceLocation BlockStart) {
   bool AllUnnamed = true;
   for (auto *D : DC->decls())

clang/test/CXX/module/module.interface/p3.cpp

 // RUN: %clang_cc1 -std=c++2a %s -verify -pedantic-errors
 
 export module p3;
 
-namespace A { int ns_mem; }
+namespace A { int ns_mem; } // expected-note 2{{target}}
 
 // An exported declaration shall declare at least one name.
 export; // expected-error {{empty declaration cannot be exported}}
 export static_assert(true); // expected-error {{static_assert declaration cannot be exported}}
-export using namespace A; // expected-error {{ISO C++20 does not permit using directive to be exported}}
+export using namespace A;   // expected-error {{ISO C++20 does not permit using directive to be exported}}
 
 export { // expected-note 3{{export block begins here}}
   ; // expected-error {{ISO C++20 does not permit an empty declaration to appear in an export block}}
   static_assert(true); // expected-error {{ISO C++20 does not permit a static_assert declaration to appear in an export block}}
-  using namespace A; // expected-error {{ISO C++20 does not permit using directive to be exported}}
+  using namespace A;   // expected-error {{ISO C++20 does not permit using directive to be exported}}
 }
 
 export struct {}; // expected-error {{must be class member}} expected-error {{GNU extension}} expected-error {{does not declare anything}}
 export struct {} struct_;
 export union {}; // expected-error {{must be declared 'static'}} expected-error {{does not declare anything}}
 export union {} union_;
 export enum {}; // expected-error {{does not declare anything}}
 export enum {} enum_;
 export enum E : int;
 export typedef int; // expected-error {{typedef requires a name}}
 export static union {}; // expected-error {{does not declare anything}}
 export asm(""); // expected-error {{asm declaration cannot be exported}}
 export namespace B = A;
-export using A::ns_mem;
+export using A::ns_mem; // expected-error {{using declaration referring to 'ns_mem' with module linkage cannot be exported}}
 namespace A {
-  export using A::ns_mem;
+  export using A::ns_mem; // expected-error {{using declaration referring to 'ns_mem' with module linkage cannot be exported}}
 }
 export using Int = int;
 export extern "C++" {} // expected-error {{ISO C++20 does not permit a declaration that does not introduce any names to be exported}}
 export extern "C++" { extern "C" {} } // expected-error {{ISO C++20 does not permit a declaration that does not introduce any names to be exported}}
 export extern "C++" { extern "C" int extern_c; }
 export { // expected-note {{export block}}
   extern "C++" int extern_cxx;
   extern "C++" {} // expected-error {{ISO C++20 does not permit a declaration that does not introduce any names to be exported}}

clang/test/CXX/module/module.interface/p5.cpp

 // RUN: %clang_cc1 -std=c++2a %s -verify -pedantic-errors
 
 export module p5;
 
-int a;
+int a; // expected-note {{target}}
 static int sa; // expected-note {{target}}
-void b();
+void b(); // expected-note {{target}}
 static void sb(); // expected-note {{target}}
-struct c {};
-enum d {};
+struct c {}; // expected-note {{target}}
+enum d {}; // expected-note {{target}}
 using e = int;
 using f = c;
 static union { int sg1, sg2; }; // expected-note {{target}}
 namespace NS {}
 
-template<typename> int ta;
+template<typename> int ta; // expected-note {{target}}
 template<typename> static int sta; // expected-note {{target}}
-template<typename> void tb();
+template<typename> void tb(); // expected-note {{target}}
 template<typename> static void stb(); // expected-note {{target}}
-template<typename> struct tc {};
-template<typename> using te = int;
-template<typename> using tf = c;
+template<typename> struct tc {}; // expected-note {{target}}
+template<typename> using te = int; // expected-note {{target}}
+template<typename> using tf = c; // expected-note {{target}}
 
 namespace UnnamedNS {
   namespace {
     int a; // expected-note {{target}}
     static int sa; // expected-note {{target}}
     void b(); // expected-note {{target}}
     static void sb(); // expected-note {{target}}
     struct c {}; // expected-note {{target}}
     enum d {}; // expected-note {{target}}
     using e = int;
     using f = c;
     static union { int sg1, sg2; }; // expected-note {{target}}
     namespace NS {}
 
     template<typename> int ta; // expected-note {{target}}
     template<typename> static int sta; // expected-note {{target}}
     template<typename> void tb(); // expected-note {{target}}
     template<typename> static void stb(); // expected-note {{target}}
     template<typename> struct tc {}; // expected-note {{target}}
     template<typename> using te = int; // expected-note {{target}}
     template<typename> using tf = c; // expected-note {{target}}
   }
 }
 
-export { // expected-note 19{{here}}
-  using ::a;
+export { // expected-note 28{{here}}
+  using ::a; // expected-error {{using declaration referring to 'a' with module linkage cannot be exported}}
   using ::sa; // expected-error {{using declaration referring to 'sa' with internal linkage}}
-  using ::b;
+  using ::b; // expected-error {{using declaration referring to 'b' with module linkage cannot be exported}}
   using ::sb; // expected-error {{using declaration referring to 'sb' with internal linkage}}
-  using ::c;
-  using ::d;
+  using ::c; // expected-error {{using declaration referring to 'c' with module linkage cannot be exported}}
+  using ::d; // expected-error {{using declaration referring to 'd' with module linkage cannot be exported}}
   using ::e;
   using ::f;
   using ::sg1; // expected-error {{using declaration referring to 'sg1' with internal linkage}}
 
-  using ::ta;
+  using ::ta; // expected-error {{using declaration referring to 'ta' with module linkage cannot be exported}}
   using ::sta; // expected-error {{using declaration referring to 'sta' with internal linkage}}
-  using ::tb;
+  using ::tb; // expected-error {{using declaration referring to 'tb' with module linkage cannot be exported}}
   using ::stb; // expected-error {{using declaration referring to 'stb' with internal linkage}}
-  using ::tc;
-  using ::te;
-  using ::tf;
+  using ::tc; // expected-error {{using declaration referring to 'tc' with module linkage cannot be exported}}
+  using ::te; // expected-error {{using declaration referring to 'te' with module linkage cannot be exported}}
+  using ::tf; // expected-error {{using declaration referring to 'tf' with module linkage cannot be exported}}
   namespace NS2 = ::NS;
 
   namespace UnnamedNS {
     using UnnamedNS::a; // expected-error {{internal linkage}}
     using UnnamedNS::sa; // expected-error {{internal linkage}}
     using UnnamedNS::b; // expected-error {{internal linkage}}
     using UnnamedNS::sb; // expected-error {{internal linkage}}
     using UnnamedNS::c; // expected-error {{internal linkage}}

clang/test/CXX/module/module.interface/p6.cpp

 // The test is check we couldn't export a redeclaration which isn't exported previously and
 // check it is OK to redeclare no matter exported nor not if is the previous declaration is exported.
 // RUN: %clang_cc1 -std=c++20 %s -verify
 
 export module X;
 
 struct S { // expected-note {{previous declaration is here}}
   int n;
 };
 typedef S S;
 export typedef S S; // OK, does not redeclare an entity
-export struct S;    // expected-error {{cannot export redeclaration 'S' here since the previous declaration is not exported}}
+export struct S;    // expected-error {{cannot export redeclaration 'S' here since the previous declaration has module linkage}}
 
 namespace A {
 struct X; // expected-note {{previous declaration is here}}
 export struct Y;
 } // namespace A
 
 namespace A {
-export struct X; // expected-error {{cannot export redeclaration 'X' here since the previous declaration is not exported}}
+export struct X; // expected-error {{cannot export redeclaration 'X' here since the previous declaration has module linkage}}
 export struct Y; // OK
 struct Z;        // expected-note {{previous declaration is here}}
-export struct Z; // expected-error {{cannot export redeclaration 'Z' here since the previous declaration is not exported}}
+export struct Z; // expected-error {{cannot export redeclaration 'Z' here since the previous declaration has module linkage}}
 } // namespace A
 
 namespace A {
 struct B;    // expected-note {{previous declaration is here}}
 struct C {}; // expected-note {{previous declaration is here}}
 } // namespace A
 
 namespace A {
-export struct B {}; // expected-error {{cannot export redeclaration 'B' here since the previous declaration is not exported}}
-export struct C;    // expected-error {{cannot export redeclaration 'C' here since the previous declaration is not exported}}
+export struct B {}; // expected-error {{cannot export redeclaration 'B' here since the previous declaration has module linkage}}
+export struct C;    // expected-error {{cannot export redeclaration 'C' here since the previous declaration has module linkage}}
 } // namespace A
 
 template <typename T>
 struct TemplS; // expected-note {{previous declaration is here}}
 
 export template <typename T>
-struct TemplS {}; // expected-error {{cannot export redeclaration 'TemplS' here since the previous declaration is not exported}}
+struct TemplS {}; // expected-error {{cannot export redeclaration 'TemplS' here since the previous declaration has module linkage}}
 
 template <typename T>
 struct TemplS2; // expected-note {{previous declaration is here}}
 
 export template <typename U>
-struct TemplS2 {}; // expected-error {{cannot export redeclaration 'TemplS2' here since the previous declaration is not exported}}
+struct TemplS2 {}; // expected-error {{cannot export redeclaration 'TemplS2' here since the previous declaration has module linkage}}
 
 void baz();        // expected-note {{previous declaration is here}}
-export void baz(); // expected-error {{cannot export redeclaration 'baz' here since the previous declaration is not exported}}
+export void baz(); // expected-error {{cannot export redeclaration 'baz' here since the previous declaration has module linkage}}
 
 namespace A {
 export void foo();
 void bar();        // expected-note {{previous declaration is here}}
-export void bar(); // expected-error {{cannot export redeclaration 'bar' here since the previous declaration is not exported}}
+export void bar(); // expected-error {{cannot export redeclaration 'bar' here since the previous declaration has module linkage}}
 void f1();         // expected-note {{previous declaration is here}}
 } // namespace A
 
 // OK
 //
 // [module.interface]/p6
 // A redeclaration of an entity X is implicitly exported if X was introduced by an exported declaration
 void A::foo();
 
 // The compiler couldn't export A::f1() here since A::f1() is declared above without exported.
 // See [module.interface]/p6 for details.
-export void A::f1(); // expected-error {{cannot export redeclaration 'f1' here since the previous declaration is not exported}}
+export void A::f1(); // expected-error {{cannot export redeclaration 'f1' here since the previous declaration has module linkage}}
 
 template <typename T>
 void TemplFunc(); // expected-note {{previous declaration is here}}
 
 export template <typename T>
-void TemplFunc() { // expected-error {{cannot export redeclaration 'TemplFunc' here since the previous declaration is not exported}}
+void TemplFunc() { // expected-error {{cannot export redeclaration 'TemplFunc' here since the previous declaration has module linkage}}
 }
 
 namespace A {
 template <typename T>
 void TemplFunc2(); // expected-note {{previous declaration is here}}
 export template <typename T>
-void TemplFunc2() {} // expected-error {{cannot export redeclaration 'TemplFunc2' here since the previous declaration is not exported}}
+void TemplFunc2() {} // expected-error {{cannot export redeclaration 'TemplFunc2' here since the previous declaration has module linkage}}
 template <typename T>
 void TemplFunc3(); // expected-note {{previous declaration is here}}
 } // namespace A
 
 export template <typename T>
-void A::TemplFunc3() {} // expected-error {{cannot export redeclaration 'TemplFunc3' here since the previous declaration is not exported}}
+void A::TemplFunc3() {} // expected-error {{cannot export redeclaration 'TemplFunc3' here since the previous declaration has module linkage}}
 
 int var;        // expected-note {{previous declaration is here}}
-export int var; // expected-error {{cannot export redeclaration 'var' here since the previous declaration is not exported}}
+export int var; // expected-error {{cannot export redeclaration 'var' here since the previous declaration has module linkage}}
 
 template <typename T>
 T TemplVar; // expected-note {{previous declaration is here}}
 export template <typename T>
-T TemplVar; // expected-error {{cannot export redeclaration 'TemplVar' here since the previous declaration is not exported}}
+T TemplVar; // expected-error {{cannot export redeclaration 'TemplVar' here since the previous declaration has module linkage}}
 
 // Test the compiler wouldn't complain about the redeclaration of friend in exported class.
 namespace Friend {
 template <typename T>
 class bar;
 class gua;
 template <typename T>
 void hello();

clang/test/Modules/cxx20-10-2-ex1.cpp

+// Based on C++20 10.2 example 1.
+
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std-10-2-ex1-tu1.cpp \
+// RUN: -pedantic-errors -verify -o %t/m1.pcm
+
+//--- std-10-2-ex1.h
+export int x;
+
+//--- std-10-2-ex1-tu1.cpp
+module;
+
+#include "std-10-2-ex1.h"
+// expected-error@std-10-2-ex1.h:* {{export declaration can only be used within a module interface unit after the module declaration}}
+
+export module M1;
+export namespace {} // expected-error {{declaration does not introduce any names to be exported}}
+export namespace {
+int a1; // expected-error {{declaration of 'a1' with internal linkage cannot be exported}}
+}
+namespace {    // expected-note {{anonymous namespace begins here}}
+export int a2; // expected-error {{export declaration appears within anonymous namespace}}
+}
+export static int b; // expected-error {{declaration of 'b' with internal linkage cannot be exported}}
+export int f();      // OK
+
+export namespace N {}     // namespace N
+export using namespace N; // expected-error {{ISO C++20 does not permit using directive to be exported}}

clang/test/Modules/cxx20-10-2-ex3.cpp

+// Based on C++20 10.2 example 3.
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %s -o M.pcm
+
+export module M;
+struct S;
+export using T = S; // OK, exports name T denoting type S
+
+// expected-no-diagnostics

clang/test/Modules/cxx20-10-2-ex4.cpp

+// Based on C++20 10.2 example 4.
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %s -verify -o M.pcm
+
+export module M;
+
+struct S { // expected-note {{previous declaration is here}}
+  int n;
+};
+typedef S S;
+export typedef S S; // OK, does not redeclare an entity
+export struct S;    // expected-error {{cannot export redeclaration 'S' here since the previous declaration has module linkage}}

clang/test/Modules/cxx20-10-2-ex5.cpp

+// Based on C++20 10.2 example 5.
+
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std-10-2-ex5-tu1.cpp \
+// RUN:  -o  %t/M.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-obj %t/std-10-2-ex5-tu2.cpp \
+// RUN:  -fmodule-file=%t/M.pcm -o  %t/tu-2.o
+
+// RUN: %clang_cc1 -std=c++20 -emit-obj %t/std-10-2-ex5-tu3.cpp \
+// RUN:  -fmodule-file=%t/M.pcm -verify -o %t/main.o
+
+//--- std-10-2-ex5-tu1.cpp
+export module M;
+export struct X {
+  static void f();
+  struct Y {};
+};
+namespace {
+struct S {};
+} // namespace
+export void f(S); // OK
+struct T {};
+export T id(T);  // OK
+export struct A; // A exported as incomplete
+
+export auto rootFinder(double a) {
+  return [=](double x) { return (x + a / x) / 2; };
+}
+export const int n = 5; // OK, n has external linkage
+
+//--- std-10-2-ex5-tu2.cpp
+
+module M;
+struct A {
+  int value;
+};
+
+//--- std-10-2-ex5-tu3.cpp
+
+import M;
+
+int main() {
+  X::f();                 // OK, X is exported and definition of X is reachable
+  X::Y y;                 // OK, X::Y is exported as a complete type
+  auto f = rootFinder(2); // OK
+                          // error: A is incomplete
+  return A{45}.value;     // expected-error {{invalid use of incomplete type 'A'}}
+                          // expected-error@-1 {{member access into incomplete type 'A'}}
+                          // [e-mail]:12 2{{forward declaration of 'A'}}
+}

clang/test/Modules/cxx20-10-2-ex6.cpp

+// Based on C++20 10.2 example 6.
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %s -verify -o M.pcm
+
+export module M;
+
+static int f();  // expected-note {{previous declaration is here}} #1
+                 // error: #1 gives internal linkage
+export int f();  // expected-error {{cannot export redeclaration 'f' here since the previous declaration has internal linkage}}
+struct S;        // expected-note {{previous declaration is here}} #2
+                 // error: #2 gives module linkage
+export struct S; // expected-error {{cannot export redeclaration 'S' here since the previous declaration has module linkage}}
+
+namespace {
+namespace N {
+extern int x; // expected-note {{previous declaration is here}} #3
+}
+} // namespace
+  // error: #3 gives internal linkage
+export int N::x; // expected-error {{cannot export redeclaration 'x' here since the previous declaration has internal linkage}}
+                 // expected-error@-1 {{declaration of 'x' with internal linkage cannot be exported}}

clang/test/Modules/cxx20-10-2-ex7.cpp

+// Based on C++20 10.2 example 6.
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %s -verify -o M.pcm
+
+export module M;
+export namespace N {
+int x;                 // OK
+static_assert(1 == 1); // expected-error {{static_assert declaration cannot be exported}}
+} // namespace N