[C++20] [Modules] [Concepts] Recognize same concepts more precisely in Serialization

[ChuanqiXu]

Summary

When we use concept in modules, we would meet a curious error. For example:

C++
// foo.h
#ifndef FOO_H
#define FOO_H

template< class T >
concept Range = requires(T& t) {
  t.begin();
};

namespace workspace {
    struct A {
        public:
            template <Range T>
            using range_type = T;
    };
}

#endif
// A.cppm
module;
#include "foo.h"
export module A;
// B.cppm
module;
#include "foo.h"
export module B;
import A;

The compiler would tell us that the definition of workspace::A::range_type in B.cppm is not the same with the one in A.cppm!
The reason here is that the implementation would judge two concepts is same by their addresses. However, when we use modules, the addresses wouldn't be the same all the time since one is parsed in their TU and another is imported in another TU.
This patch fixes this by using isSameEntity to judge the two concepts. I think it should be a good fix.

Test Plan: check-all

[ChuanqiXu]

Clean code.

[ChuanqiXu]

Fix tests under Debug mode. I need to remember run debug tests : (

[ChuanqiXu]

Format codes.

clang/lib/Serialization/ASTReaderDecl.cpp

 
 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset) {
   return LocalOffset + M.GlobalBitOffset;
 }
 
 static bool isSameTemplateParameterList(const ASTContext &C,
                                         const TemplateParameterList *X,
                                         const TemplateParameterList *Y);
+static bool isSameEntity(NamedDecl *X, NamedDecl *Y);
 
 /// Determine whether two template parameters are similar enough
 /// that they may be used in declarations of the same template.
 static bool isSameTemplateParameter(const NamedDecl *X,
                                     const NamedDecl *Y) {
   if (X->getKind() != Y->getKind())
     return false;
 
   if (const auto *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
     const auto *TY = cast<TemplateTypeParmDecl>(Y);
     if (TX->isParameterPack() != TY->isParameterPack())
       return false;
     if (TX->hasTypeConstraint() != TY->hasTypeConstraint())
       return false;
     const TypeConstraint *TXTC = TX->getTypeConstraint();
     const TypeConstraint *TYTC = TY->getTypeConstraint();
     if (!TXTC != !TYTC)
       return false;
     if (TXTC && TYTC) {
-      if (TXTC->getNamedConcept() != TYTC->getNamedConcept())
+      auto *NCX = TXTC->getNamedConcept();
+      auto *NCY = TYTC->getNamedConcept();
+      if (!NCX || !NCY || !isSameEntity(NCX, NCY))
         return false;
       if (TXTC->hasExplicitTemplateArgs() != TYTC->hasExplicitTemplateArgs())
         return false;
       if (TXTC->hasExplicitTemplateArgs()) {
         const auto *TXTCArgs = TXTC->getTemplateArgsAsWritten();
         const auto *TYTCArgs = TYTC->getTemplateArgsAsWritten();
         if (TXTCArgs->NumTemplateArgs != TYTCArgs->NumTemplateArgs)
           return false;
for (auto Pair : zip_longest(AEnableIfAttrs, BEnableIfAttrs)) {
     if (Cand1ID != Cand2ID)
       return false;
   }
   return true;
 }
 
 /// Determine whether the two declarations refer to the same entity.
 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
-  assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
-
   if (X == Y)
     return true;
 
+  if (X->getDeclName() != Y->getDeclName())
+    return false;
+
   // Must be in the same context.
   //
   // Note that we can't use DeclContext::Equals here, because the DeclContexts
   // could be two different declarations of the same function. (We will fix the
   // semantic DC to refer to the primary definition after merging.)
   if (!declaresSameEntity(cast<Decl>(X->getDeclContext()->getRedeclContext()),
                           cast<Decl>(Y->getDeclContext()->getRedeclContext())))
     return false;

clang/test/Modules/Inputs/concept/A.cppm

+module;
+#include "foo.h"
+export module A;

clang/test/Modules/Inputs/concept/foo.h

+#ifndef FOO_H
+#define FOO_H
+
+template <class T>
+concept Range = requires(T &t) { t.begin(); };
+
+struct A {
+public:
+  template <Range T>
+  using range_type = T;
+};
+
+#endif

clang/test/Modules/concept.cppm

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clang -std=c++20 %S/Inputs/concept/A.cppm --precompile -o %t/A.pcm
+// RUN: %clang -std=c++20 -fprebuilt-module-path=%t -I%S/Inputs/concept %s -c -Xclang -verify
+// expected-no-diagnostics
+
+module;
+#include "foo.h"
+export module B;
+import A;