[clang][NFC] rename getOwningModuleForLinkage to getModuleAttachment

[urnathan]

Summary

The name 'getOwningModuleForLinkage' is a little confusing, now that the standard defines the term 'attachment' to mean the same thing. Renames the function to match the latter.

Note, the ModuleInternalLinkage concept will go away (and hence the defaulted argument) once p1815 is implemented. This is already noted in the body of the function.

This is based on top of the new mangling patch, but I could rebase it before if that's prefered.

[ChuanqiXu]

The new name is confusing to me. According to my understanding, Decl::getOwningModule() already defines the semantic of attached module. And for the new name, here is an example:

C++
module;
void foo() { ... }
export module m;
...

Now the getOwningModuleForLinkage would return nullptr for foo since it lives in global module fragment and it is external so we decide to not break its ABI. But it is attached to global module fragment indeed. So I might be surprising if found Decl::getModuleAttachment return nullptr for the similar example above.

[urnathan]

In D119833#3325088, @ChuanqiXu wrote:

The new name is confusing to me. According to my understanding, Decl::getOwningModule() already defines the semantic of attached module. And for the new name, here is an example:

C++
module;
void foo() { ... }
export module m;
...

Now the getOwningModuleForLinkage would return nullptr for foo since it lives in global module fragment and it is external so we decide to not break its ABI. But it is attached to global module fragment indeed. So I might be surprising if found Decl::getModuleAttachment return nullptr for the similar example above.

Hm, what about:

C++
export module Foo;
extern "C++" { export void Baz (); }

Baz is visible by name to importers of Foo, but it is attached to the global module. Is it owned by Foo or a global module fragment? If the former, then getOwningModule is not telling you about attachment.

[ChuanqiXu]

In D119833#3325967, @urnathan wrote:

In D119833#3325088, @ChuanqiXu wrote:

The new name is confusing to me. According to my understanding, Decl::getOwningModule() already defines the semantic of attached module. And for the new name, here is an example:

C++
module;
void foo() { ... }
export module m;
...

Now the getOwningModuleForLinkage would return nullptr for foo since it lives in global module fragment and it is external so we decide to not break its ABI. But it is attached to global module fragment indeed. So I might be surprising if found Decl::getModuleAttachment return nullptr for the similar example above.

Hm, what about:

C++
export module Foo;
extern "C++" { export void Baz (); }

Baz is visible by name to importers of Foo, but it is attached to the global module. Is it owned by Foo or a global module fragment? If the former, then getOwningModule is not telling you about attachment.

It is owned by global module fragment. I am sure about this.

[ChuanqiXu]

Could we abandon this one?

clang/include/clang/AST/Decl.h

public:
 
   bool isExternallyVisible() const {
     return clang::isExternallyVisible(getLinkageInternal());
   }
 
   /// Determine whether this declaration can be redeclared in a
   /// different translation unit.
   bool isExternallyDeclarable() const {
-    return isExternallyVisible() && !getOwningModuleForLinkage();
+    return isExternallyVisible() && !getModuleAttachment();
   }
 
   /// Determines the visibility of this entity.
   Visibility getVisibility() const {
     return getLinkageAndVisibility().getVisibility();
   }
 
   /// Determines the linkage and visibility of this entity.

clang/include/clang/AST/DeclBase.h

bool hasOwningModule() const {
     return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned;
   }
 
   /// Get the module that owns this declaration (for visibility purposes).
   Module *getOwningModule() const {
     return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule();
   }
 
-  /// Get the module that owns this declaration for linkage purposes.
-  /// There only ever is such a module under the C++ Modules TS.
+  /// Get the module that this declaration is attached to.
   ///
-  /// \param IgnoreLinkage Ignore the linkage of the entity; assume that
-  /// all declarations in a global module fragment are unowned.
-  Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;
+  /// \param IgnoreLinkage Ignore ModuleInternalLinkage of the entity; assume
+  /// that all declarations in a global module fragment attached to the GM.
+  Module *getModuleAttachment(bool IgnoreLinkage = false) const;
 
   /// Determine whether this declaration is definitely visible to name lookup,
   /// independent of whether the owning module is visible.
   /// Note: The declaration may be visible even if this returns \c false if the
   /// owning module is visible within the query context. This is a low-level
   /// helper function; most code should be calling Sema::isVisible() instead.
   bool isUnconditionallyVisible() const {
     return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;

clang/include/clang/Sema/Sema.h

enum RedeclarationKind {
     ForExternalRedeclaration
   };
 
   RedeclarationKind forRedeclarationInCurContext() {
     // A declaration with an owning module for linkage can never link against
     // anything that is not visible. We don't need to check linkage here; if
     // the context has internal linkage, redeclaration lookup won't find things
     // from other TUs, and we can't safely compute linkage yet in general.
-    if (cast<Decl>(CurContext)
-            ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))
+    if (cast<Decl>(CurContext)->getModuleAttachment(/*IgnoreLinkage*/true))
       return ForVisibleRedeclaration;
     return ForExternalRedeclaration;
   }
 
   /// The possible outcomes of name lookup for a literal operator.
   enum LiteralOperatorLookupResult {
     /// The lookup resulted in an error.
     LOLR_Error,

clang/lib/AST/Decl.cpp

NamedDecl::ExplicitVisibilityKind EK = usesTypeVisibility(D)
                                              ? NamedDecl::VisibilityForType
                                              : NamedDecl::VisibilityForValue;
   LVComputationKind CK(EK);
   return getLVForDecl(D, D->getASTContext().getLangOpts().IgnoreXCOFFVisibility
                              ? CK.forLinkageOnly()
                              : CK);
 }
 
-Module *Decl::getOwningModuleForLinkage(bool IgnoreLinkage) const {
+Module *Decl::getModuleAttachment(bool IgnoreLinkage) const {
   if (isa<NamespaceDecl>(this))
-    // Namespaces never have module linkage.  It is the entities within them
-    // that [may] do.
+    // External namespaces are always attached to the global module.
     return nullptr;
 
   Module *M = getOwningModule();
   if (!M)
     return nullptr;
 
   switch (M->Kind) {
   case Module::ModuleMapModule:

clang/lib/AST/ItaniumMangle.cpp

if (const auto *VD = dyn_cast<VarDecl>(D)) {
     // linkage or are specializations or are attached to a named module.
     const DeclContext *DC = getEffectiveDeclContext(D);
     // Check for extern variable declared locally.
     if (DC->isFunctionOrMethod() && D->hasLinkage())
       while (!DC->isFileContext())
         DC = getEffectiveParentContext(DC);
     if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage &&
         !CXXNameMangler::shouldHaveAbiTags(*this, VD) &&
         !isa<VarTemplateSpecializationDecl>(VD) &&
-        !VD->getOwningModuleForLinkage())
+        !VD->getModuleAttachment())
       return false;
   }
 
   return true;
 }
 
 void CXXNameMangler::writeAbiTags(const NamedDecl *ND,
                                   const AbiTagList *AdditionalAbiTags) {
if (DC->isTranslationUnit() || isStdNamespace(DC)) {
     return;
   }
 
   mangleNestedName(GD, DC, AdditionalAbiTags);
 }
 
 void CXXNameMangler::mangleModuleName(const NamedDecl *ND) {
   if (ND->isExternallyVisible())
-    if (Module *M = ND->getOwningModuleForLinkage())
+    if (Module *M = ND->getModuleAttachment())
       mangleModuleNamePrefix(M->Name);
 }
 
 // <module-name> ::= <module-subname>
 //     ::= <module-name> <module-subname>
 //     ::= <substitution>
 // <module-subname> ::= W <source-name>
 //        ::= W P <source-name>
static bool isSpecializedAs(QualType S, llvm::StringRef Name, QualType A) {
 
   const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
   if (TemplateArgs.size() != 1)
     return false;
 
   if (TemplateArgs[0].getAsType() != A)
     return false;
 
-  if (SD->getSpecializedTemplate()->getOwningModuleForLinkage())
+  if (SD->getSpecializedTemplate()->getModuleAttachment())
     return false;
 
   return true;
 }
 
 /// Returns whether SD is a template specialization std::Name<char,
 /// std::char_traits<char> [, std::allocator<char>]>
 /// HasAllocator controls whether the 3rd template argument is needed.
static bool isStdCharSpecialization(const ClassTemplateSpecializationDecl *SD,
 
   if (!isSpecializedAs(TemplateArgs[1].getAsType(), "char_traits", A))
     return false;
 
   if (HasAllocator &&
       !isSpecializedAs(TemplateArgs[2].getAsType(), "allocator", A))
     return false;
 
-  if (SD->getSpecializedTemplate()->getOwningModuleForLinkage())
+  if (SD->getSpecializedTemplate()->getModuleAttachment())
     return false;
 
   return true;
 }
 
 bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) {
   // <substitution> ::= St # ::std::
   if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
     if (isStd(NS)) {
       Out << "St";
       return true;
     }
     return false;
   }
 
   if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) {
     if (!isStdNamespace(getEffectiveDeclContext(TD)))
       return false;
 
-    if (TD->getOwningModuleForLinkage())
+    if (TD->getModuleAttachment())
       return false;
 
     // <substitution> ::= Sa # ::std::allocator
     if (TD->getIdentifier()->isStr("allocator")) {
       Out << "Sa";
       return true;
     }
 
     // <<substitution> ::= Sb # ::std::basic_string
     if (TD->getIdentifier()->isStr("basic_string")) {
       Out << "Sb";
       return true;
     }
     return false;
   }
 
   if (const ClassTemplateSpecializationDecl *SD =
         dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
     if (!isStdNamespace(getEffectiveDeclContext(SD)))
       return false;
 
-    if (SD->getSpecializedTemplate()->getOwningModuleForLinkage())
+    if (SD->getSpecializedTemplate()->getModuleAttachment())
       return false;
 
     //    <substitution> ::= Ss # ::std::basic_string<char,
     //                            ::std::char_traits<char>,
     //                            ::std::allocator<char> >
     if (isStdCharSpecialization(SD, "basic_string", /*HasAllocator=*/true)) {
       Out << "Ss";
       return true;

clang/lib/AST/Mangle.cpp

 
 bool MangleContext::shouldMangleDeclName(const NamedDecl *D) {
   const ASTContext &ASTContext = getASTContext();
 
   CCMangling CC = getCallingConvMangling(ASTContext, D);
   if (CC != CCM_Other)
     return true;
 
-  // If the declaration has an owning module for linkage purposes that needs to
-  // be mangled, we must mangle its name.
-  if (!D->hasExternalFormalLinkage() && D->getOwningModuleForLinkage())
+  // If the declaration is attached to a named module, we must mangle its name.
+  if (!D->hasExternalFormalLinkage() && D->getModuleAttachment())
     return true;
 
   // C functions with internal linkage have to be mangled with option
   // -funique-internal-linkage-names.
   if (!getASTContext().getLangOpts().CPlusPlus &&
       isUniqueInternalLinkageDecl(D))
     return true;
 

clang/lib/Sema/SemaDecl.cpp

bool Sema::CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old) {
   // [module.interface]p7:
   // A declaration is attached to a module as follows:
   // - If the declaration is a non-dependent friend declaration that nominates a
   // function with a declarator-id that is a qualified-id or template-id or that
   // nominates a class other than with an elaborated-type-specifier with neither
   // a nested-name-specifier nor a simple-template-id, it is attached to the
   // module to which the friend is attached ([basic.link]).
   if (New->getFriendObjectKind() &&
-      Old->getOwningModuleForLinkage() != New->getOwningModuleForLinkage()) {
+      Old->getModuleAttachment() != New->getModuleAttachment()) {
     New->setLocalOwningModule(Old->getOwningModule());
     makeMergedDefinitionVisible(New);
     return false;
   }
 
   Module *NewM = New->getOwningModule();
   Module *OldM = Old->getOwningModule();