[DRAFT] [C++20] [Module] Don't export entities not in namespace scope nor exported enetities

[ChuanqiXu]

Summary

This is an alternative to D112903. This is not completed to work or review the details yet.
The intention is to visit the overall ideas for how to implement https://eel.is/c++draft/module.interface#6

[ChuanqiXu]

Now this should be unneeded.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 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_for_non_namespace_entities : Error <
+    "We couldn't export %0 which is not in namespace scopes.">;
+def err_export_entites_which_is_exported : Error <
+    "We couldn't export %0 which is exported already. "
+    "It was exported already at %0.">;
 
 def err_no_typeid_with_fno_rtti : Error<
   "use of typeid requires -frtti">;
 def err_no_dynamic_cast_with_fno_rtti : Error<
   "use of dynamic_cast requires -frtti">;
 def warn_no_dynamic_cast_with_rtti_disabled: Warning<
   "dynamic_cast will not work since RTTI data is disabled by "
   "%select{-fno-rtti-data|/GR-}0">, InGroup<RTTI>;

clang/lib/Sema/SemaDecl.cpp

else if (isa<TranslationUnitDecl>(DC))
       Diag(Loc, diag::err_invalid_declarator_global_scope)
         << Name << SS.getRange();
     else if (isa<FunctionDecl>(Cur))
       Diag(Loc, diag::err_invalid_declarator_in_function)
         << Name << SS.getRange();
     else if (isa<BlockDecl>(Cur))
       Diag(Loc, diag::err_invalid_declarator_in_block)
         << Name << SS.getRange();
-    else
+    else if (isa<ExportDecl>(Cur)) {
+
+    } else
       Diag(Loc, diag::err_invalid_declarator_scope)
       << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
 
     return true;
   }
 
   if (Cur->isRecord()) {
     // Cannot qualify members within a class.
if (!DC || isa<EnumDecl>(DC)) {
       // class template, or class template partial specialization. Complain
       // and return early, to avoid the coming semantic disaster.
       Diag(D.getIdentifierLoc(),
            diag::err_template_qualified_declarator_no_match)
         << D.getCXXScopeSpec().getScopeRep()
         << D.getCXXScopeSpec().getRange();
       return nullptr;
     }
+
+    if (auto *ED = dyn_cast<ExportDecl>(CurContext)) {
+      if (!isa<NamespaceDecl>(DC)) {
+        Diag(ED->getExportLoc(), diag::err_export_for_non_namespace_entities)
+          << Name;
+      } else {
+        auto *TmpDC = DC;
+        while (TmpDC && !isa<ExportDecl>(TmpDC))
+          TmpDC = TmpDC->getParent();
+        if (TmpDC && isa<ExportDecl>(TmpDC)) {
+          Diag(ED->getExportLoc(), diag::err_export_entites_which_is_exported)
+            << Name << NameInfo.getLoc();;
+        }
+      }
+    }
+
     bool IsDependentContext = DC->isDependentContext();
 
     if (!IsDependentContext &&
         RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
       return nullptr;
 
     // If a class is incomplete, do not parse entities inside it.
     if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
CreateNewDecl:
 
   if (!Invalid && getLangOpts().CPlusPlus && TUK == TUK_Definition &&
       DC->getDeclKind() == Decl::Enum) {
     Diag(New->getLocation(), diag::err_type_defined_in_enum)
       << Context.getTagDeclType(New);
     Invalid = true;
   }
 
+  if (isa<ExportDecl>(CurContext) && PrevDecl) {
+    auto *PrevDC = PrevDecl->getDeclContext();
+    if (!isa<NamespaceDecl>(PrevDC)) {
+      Diag(New->getLocation(), diag::err_export_for_non_namespace_entities)
+        << OrigName;
+      Invalid = true;
+    } else {
+      while (PrevDC && !isa<ExportDecl>(PrevDC))
+        PrevDC = PrevDC->getParent();
+      if (PrevDC && isa<ExportDecl>(PrevDC)) {
+        Diag(New->getLocation(), diag::err_export_entites_which_is_exported)
+          << OrigName << PrevDecl->getLocation();
+        Invalid = true;
+      }
+    }
+  }
+
   // Maybe add qualifier info.
   if (SS.isNotEmpty()) {
     if (SS.isSet()) {
       // If this is either a declaration or a definition, check the
       // nested-name-specifier against the current context.
       if ((TUK == TUK_Definition || TUK == TUK_Declaration) &&
           diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc,
                                        isMemberSpecialization))

clang/lib/Sema/SemaDeclCXX.cpp

if (isInstField) {
 
     if (SS.isSet() && !SS.isInvalid()) {
       // The user provided a superfluous scope specifier inside a class
       // definition:
       //
       // class X {
       //   int X::member;
       // };
-      if (DeclContext *DC = computeDeclContext(SS, false))
+      if (DeclContext *DC = computeDeclContext(SS, false)) {
         diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc(),
                                      D.getName().getKind() ==
                                          UnqualifiedIdKind::IK_TemplateId);
-      else
+      } else
         Diag(D.getIdentifierLoc(), diag::err_member_qualification)
           << Name << SS.getRange();
 
       SS.clear();
     }
 
     if (MSPropertyAttr) {
       Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,

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

+
+// RUN: %clang_cc1 -std=c++20 %s -verify
+
+export module X;
+
+export template <typename T>
+struct X {
+  struct iterator {
+    T node;
+  };
+};
+
+export template <typename T> X<T>::iterator; // expected-error {{We couldn't export 'iterator' which is not in namespace scopes.}}
+export template <typename T> typename X<T>::iterator; //expected-error {{declaration does not declare anything}}
+
+export struct Y {
+  struct iterator { int Node; };
+};
+
+export struct Y::iterator; // expected-error {{We couldn't export 'iterator' which is not in namespace scopes.}}
+
+struct S { int n; };
+typedef S S;
+export typedef S S;             // OK, does not redeclare an entity
+export struct S; // expected-error {{We couldn't export 'S' which is not in namespace scopes.}}