[ODRHash] Hash type-as-written

[ChuanqiXu]

Summary

This is suggested by @rsmith in https://reviews.llvm.org/D154324#inline-1508868.

The intention of the review page is to get a feeling about the suggestion. And this may be helpful to discuss the direction.

[ChuanqiXu]

There is two kinds of regression in the current patch. One is false negative and one is false positive.

The first one is as:

#if defined(FIRST)
typedef int T;
struct S3 {
  typedef T a;
};
#elif defined(SECOND)
typedef double T;
struct S3 {
  typedef T a;
};
#else
S3 s3;
#endif

Previously we are able to diagnose that the type T in the translation units are different. But now we don't.

The second one is:

#if defined(FIRST)
struct T1;
class S1 {
  T1* t;
};
#elif defined(SECOND)
typedef struct T1 {} T1;
class S1 {
  T1* t;
};
#else
S1 s1;
#endif

Now we think S1 have different definitions in different TU due to we don't strip the TypeDef decls too.

So we can think these two problems come from the same underlying issue: how to get the underlying type from type-def-types. This is also the motivation issue for the series of patches.

From what @rsmith said:

If we want to include the underlying type of the typedef here, we'll need a new kind of hashing to capture only the value of the typedef and not how it was written. I don't think it's worth it; let's just not include the definition of a referenced typedef in the hash for now.

So now it looks like the only path we can forward? Or can we accept the regressions described in the patch?

clang/test/Modules/odr_hash.cpp

1049

The regression should come from we don't try to find the underlying type of a typedef type anymore. So we failed to find the real type of T is different (one is int and another is double)

4897–4898

The regression should come from that we don't strip typedefs in this patch. (See ODRTypeVisitor::Visit)

[rsmith]

In D156210#4531000, @ChuanqiXu wrote:

From what @rsmith said:

If we want to include the underlying type of the typedef here, we'll need a new kind of hashing to capture only the value of the typedef and not how it was written. I don't think it's worth it; let's just not include the definition of a referenced typedef in the hash for now.

So now it looks like the only path we can forward? Or can we accept the regressions described in the patch?

The cases where we used to diagnose and don't diagnose any more seem acceptable to me, even though ideally we'd still want to catch those problems. It's much more important that we don't reject valid programs here than that we catch all the ODR violations that we possibly can.

However, the new diagnostic for valid code doesn't seem OK -- that's adding a false positive. I think there are a few ways we could handle that; maybe the easiest would be to add back in the typedef stripping logic, but strip typedefs *only* in situation where a typedef resolves to a tag type with the same name.

There's also another really awkward but valid case:

typedef int T;
namespace A {
  #ifdef INNER_T
  typedef int T;
  #endif
  struct X { T n; };
}

According to the ODR, it's OK to have this header twice in the same program with different definitions for INNER_T, because the name T resolves to the same entity either way (the type int). I think we will not reject that case, because ODRHash::AddDecl only considers the name of the declaration, not the scope that it was declared in, but it'd be good to add that as a testcase too.

If we want to avoid the regressions here, I think we could add an additional mechanism to hash the resolved value of a type, in a way that's careful to only hash things that are part of the value of the type, not part of the way the type was written. But I'd consider that to be a lower priority than getting to the point where we don't have false positives.

[ChuanqiXu]

Address comments:

• add back in the typedef stripping logic, but strip typedefs *only* in situation where a typedef resolves to a tag type with the same name. Note that this is exactly what it does.
• Add a test:

C++
typedef int T;
namespace A {
  #ifdef INNER_T
  typedef int T;
  #endif
  struct X { T n; };
}

[ChuanqiXu]

Update the correct patch.

[ChuanqiXu]

@rsmith thanks for the suggestion. I prefer to handle things simply.

clang/lib/AST/ODRHash.cpp

901

So it looks like we've originally done this. I added a test for it too.

[ChuanqiXu]

Remove redundant FIXME in the test.

[rsmith]

Looks good, thanks!

Please can you add TODO comments to the invalid cases that we are now accepting, to say ideally we should reject them? I've left comments on a few of them where I think the original diagnostics weren't actually what we wanted.

clang/test/Modules/odr_hash-gnu.cpp

54

We should issue a diagnostic here, not for Invalid2, because we can't merge the two declarations of global. (We should also diagnose that global has two definitions...)

clang/test/Modules/odr_hash.cpp

3602

We should diagnose the mismatched declaration of global, not the mismatched definitions of invalid2.

clang/test/Modules/odr_hash.mm

287–295

I think it's better that we're not diagnosing these ones :) These were follow-on diagnostics from the mismatch in Interface4 / Interface5 / Interface6.

[ChuanqiXu]

Address comments.

[ChuanqiXu]

Thanks for the reviewing!

clang/lib/AST/ODRHash.cpp

public:
   }
 
   void VisitNamedDecl(const NamedDecl *D) {
     Hash.AddDeclarationName(D->getDeclName());
     Inherited::VisitNamedDecl(D);
   }
 
   void VisitValueDecl(const ValueDecl *D) {
-    if (!isa<FunctionDecl>(D)) {
-      AddQualType(D->getType());
-    }
+    if (auto *DD = dyn_cast<DeclaratorDecl>(D); DD && DD->getTypeSourceInfo())
+      AddQualType(DD->getTypeSourceInfo()->getType());
+
     Inherited::VisitValueDecl(D);
   }
 
   void VisitVarDecl(const VarDecl *D) {
     Hash.AddBoolean(D->isStaticLocal());
     Hash.AddBoolean(D->isConstexpr());
     const bool HasInit = D->hasInit();
     Hash.AddBoolean(HasInit);
public:
   void VisitObjCIvarDecl(const ObjCIvarDecl *D) {
     ID.AddInteger(D->getCanonicalAccessControl());
     Inherited::VisitObjCIvarDecl(D);
   }
 
   void VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
     ID.AddInteger(D->getPropertyAttributes());
     ID.AddInteger(D->getPropertyImplementation());
-    AddQualType(D->getType());
+    AddQualType(D->getTypeSourceInfo()->getType());
     AddDecl(D);
 
     Inherited::VisitObjCPropertyDecl(D);
   }
 
   void VisitFunctionDecl(const FunctionDecl *D) {
     // Handled by the ODRHash for FunctionDecl
     ID.AddInteger(D->getODRHash());
void VisitObjCMethodDecl(const ObjCMethodDecl *Method) {
 
     ImplicitParamDecl *Self = Method->getSelfDecl();
     Hash.AddBoolean(Self);
     if (Self)
       ID.AddInteger(Self->getParameterKind());
 
     AddDecl(Method);
 
-    AddQualType(Method->getReturnType());
+    if (Method->getReturnTypeSourceInfo())
+      AddQualType(Method->getReturnTypeSourceInfo()->getType());
+
     ID.AddInteger(Method->param_size());
     for (auto Param : Method->parameters())
       Hash.AddSubDecl(Param);
 
     if (Method->hasBody()) {
       const bool IsDefinition = Method->isThisDeclarationADefinition();
       Hash.AddBoolean(IsDefinition);
       if (IsDefinition) {
void ODRHash::AddCXXRecordDecl(const CXXRecordDecl *Record) {
   AddBoolean(TD);
   if (TD) {
     AddTemplateParameterList(TD->getTemplateParameters());
   }
 
   ID.AddInteger(Record->getNumBases());
   auto Bases = Record->bases();
   for (const auto &Base : Bases) {
-    AddQualType(Base.getType());
+    AddQualType(Base.getTypeSourceInfo()->getType());
     ID.AddInteger(Base.isVirtual());
     ID.AddInteger(Base.getAccessSpecifierAsWritten());
   }
 }
 
 void ODRHash::AddRecordDecl(const RecordDecl *Record) {
   assert(!isa<CXXRecordDecl>(Record) &&
          "For CXXRecordDecl should call AddCXXRecordDecl.");
static const Type *RemoveTypedef(const Type *T) {
     const auto *RecordT = dyn_cast<RecordType>(NamedType);
     if (!RecordT) {
       return T;
     }
 
     const IdentifierInfo *TypedefII = TypedefT->getDecl()->getIdentifier();
     const IdentifierInfo *RecordII = RecordT->getDecl()->getIdentifier();
     if (!TypedefII || !RecordII ||
         TypedefII->getName() != RecordII->getName()) {
       return T;
     }
 
     return RecordT;
   }
 
   void Visit(const Type *T) {
     T = RemoveTypedef(T);
     ID.AddInteger(T->getTypeClass());
     Inherited::Visit(T);
   }
 
   void VisitType(const Type *T) {}
 
   void VisitAdjustedType(const AdjustedType *T) {
-    QualType Original = T->getOriginalType();
-    QualType Adjusted = T->getAdjustedType();
-
-    // The original type and pointee type can be the same, as in the case of
-    // function pointers decaying to themselves.  Set a bool and only process
-    // the type once, to prevent doubling the work.
-    SplitQualType split = Adjusted.split();
-    if (auto Pointer = dyn_cast<PointerType>(split.Ty)) {
-      if (Pointer->getPointeeType() == Original) {
-        Hash.AddBoolean(true);
-        ID.AddInteger(split.Quals.getAsOpaqueValue());
-        AddQualType(Original);
-        VisitType(T);
-        return;
-      }
-    }
-
-    // The original type and pointee type are different, such as in the case
-    // of a array decaying to an element pointer.  Set a bool to false and
-    // process both types.
-    Hash.AddBoolean(false);
-    AddQualType(Original);
-    AddQualType(Adjusted);
+    AddQualType(T->getOriginalType());
 
     VisitType(T);
   }
 
   void VisitDecayedType(const DecayedType *T) {
     // getDecayedType and getPointeeType are derived from getAdjustedType
     // and don't need to be separately processed.
     VisitAdjustedType(T);
public:
   void VisitVariableArrayType(const VariableArrayType *T) {
     AddStmt(T->getSizeExpr());
     VisitArrayType(T);
   }
 
   void VisitAttributedType(const AttributedType *T) {
     ID.AddInteger(T->getAttrKind());
     AddQualType(T->getModifiedType());
-    AddQualType(T->getEquivalentType());
 
     VisitType(T);
   }
 
   void VisitBlockPointerType(const BlockPointerType *T) {
     AddQualType(T->getPointeeType());
     VisitType(T);
   }
 
   void VisitBuiltinType(const BuiltinType *T) {
     ID.AddInteger(T->getKind());
     VisitType(T);
   }
 
   void VisitComplexType(const ComplexType *T) {
     AddQualType(T->getElementType());
     VisitType(T);
   }
 
   void VisitDecltypeType(const DecltypeType *T) {
     AddStmt(T->getUnderlyingExpr());
-    AddQualType(T->getUnderlyingType());
     VisitType(T);
   }
 
   void VisitDependentDecltypeType(const DependentDecltypeType *T) {
     VisitDecltypeType(T);
   }
 
   void VisitDeducedType(const DeducedType *T) {
void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
     ID.AddInteger(T->getDepth());
     ID.AddInteger(T->getIndex());
     Hash.AddBoolean(T->isParameterPack());
     AddDecl(T->getDecl());
   }
 
   void VisitTypedefType(const TypedefType *T) {
     AddDecl(T->getDecl());
-    QualType UnderlyingType = T->getDecl()->getUnderlyingType();
-    VisitQualifiers(UnderlyingType.getQualifiers());
-    while (true) {
-      if (const TypedefType *Underlying =
-              dyn_cast<TypedefType>(UnderlyingType.getTypePtr())) {
-        UnderlyingType = Underlying->getDecl()->getUnderlyingType();
-        continue;
-      }
-      if (const ElaboratedType *Underlying =
-              dyn_cast<ElaboratedType>(UnderlyingType.getTypePtr())) {
-        UnderlyingType = Underlying->getNamedType();
-        continue;
-      }
-
-      break;
-    }
-    AddType(UnderlyingType.getTypePtr());
     VisitType(T);
   }
 
   void VisitTypeOfExprType(const TypeOfExprType *T) {
     AddStmt(T->getUnderlyingExpr());
     Hash.AddBoolean(T->isSugared());
-    if (T->isSugared())
-      AddQualType(T->desugar());
 
     VisitType(T);
   }
   void VisitTypeOfType(const TypeOfType *T) {
     AddQualType(T->getUnmodifiedType());
     VisitType(T);
   }
 

clang/test/Modules/odr_hash-gnu.cpp

struct Valid {
   typeof(3) x;
   typeof(x) y;
   typeof(Valid*) self;
 };
 #elif defined(SECOND)
 struct Invalid1 {
   typeof(3) x;
 };
 int global;
 struct Invalid2 {
   typeof(global) x;
 };
 struct Valid {
   typeof(3) x;
   typeof(x) y;
   typeof(Valid*) self;
 };
 #else
 Invalid1 i1;
 // expected-error@first.h:* {{'Types::TypeOfExpr::Invalid1' has different definitions in different modules; first difference is definition in module 'FirstModule' found field 'x' with type 'typeof (1 + 2)' (aka 'int')}}
 // expected-note@second.h:* {{but in 'SecondModule' found field 'x' with type 'typeof (3)' (aka 'int')}}
 Invalid2 i2;
-// expected-error@second.h:* {{'Types::TypeOfExpr::Invalid2::x' from module 'SecondModule' is not present in definition of 'Types::TypeOfExpr::Invalid2' in module 'FirstModule'}}
-// expected-note@first.h:* {{declaration of 'x' does not match}}
+
 Valid v;
+
+// FIXME: We should diagnose the different definitions of `global`.
 #endif
 }  // namespace TypeOfExpr
 
 namespace TypeOf {
 #if defined(FIRST)
 struct Invalid1 {
   typeof(int) x;
 };

 #else
 Invalid1 i1;
 // expected-error@second.h:* {{'Types::TypeOf::Invalid1::x' from module 'SecondModule' is not present in definition of 'Types::TypeOf::Invalid1' in module 'FirstModule'}}
 // expected-note@first.h:* {{declaration of 'x' does not match}}
 Invalid2 i2;
 // expected-error@first.h:* {{'Types::TypeOf::Invalid2' has different definitions in different modules; first difference is definition in module 'FirstModule' found field 'x' with type 'typeof(int)' (aka 'int')}}
 // expected-note@second.h:* {{but in 'SecondModule' found field 'x' with type 'typeof(I)' (aka 'int')}}
 Invalid3 i3;
-// expected-error@second.h:* {{'Types::TypeOf::Invalid3::x' from module 'SecondModule' is not present in definition of 'Types::TypeOf::Invalid3' in module 'FirstModule'}}
-// expected-note@first.h:* {{declaration of 'x' does not match}}
+
+// FIXME: We should reject the `Invalid3` due to the inconsistent definition of `T`.
+
 Valid v;
 #endif
 }  // namespace TypeOf
 }  // namespace Types
 
 // Keep macros contained to one file.
 #ifdef FIRST
 #undef FIRST
 #endif
 
 #ifdef SECOND
 #undef SECOND
 #endif

clang/test/Modules/odr_hash.cpp

 };
 #elif defined(SECOND)
 typedef double T;
 struct S3 {
   typedef T a;
 };
 #else
 S3 s3;
-// expected-error@first.h:* {{'TypeDef::S3::a' from module 'FirstModule' is not present in definition of 'TypeDef::S3' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'a' does not match}}
+// FIXME: We should reject the merge of `S3` due to the inconsistent definition of `T`.
 #endif
 
 #if defined(FIRST)
 struct S4 {
   typedef int a;
   typedef int b;
 };
 #elif defined(SECOND)

 };
 #elif defined(SECOND)
 typedef double T;
 struct S3 {
   using a = T;
 };
 #else
 S3 s3;
-// expected-error@first.h:* {{'Using::S3::a' from module 'FirstModule' is not present in definition of 'Using::S3' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'a' does not match}}
+// FIXME: We should reject the merge of `S3` due to the inconsistent definition of `T`.
 #endif
 
 #if defined(FIRST)
 struct S4 {
   using a = int;
   using b = int;
 };
 #elif defined(SECOND)

 };
 #elif defined(SECOND)
 namespace N1 { using type = int; }
 struct S1 {
   N1::type x;
 };
 #else
 S1 s1;
-// expected-error@first.h:* {{'ElaboratedType::S1::x' from module 'FirstModule' is not present in definition of 'ElaboratedType::S1' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'x' does not match}}
 #endif
 
 #define DECLS \
   NS::type x;
 
 #if defined(FIRST) || defined(SECOND)
 namespace NS { using type = float; }
 #endif

 void valid() {
   decltype(1.5) x;
   decltype(x) y;
 }
 #elif defined(SECOND)
 void invalid1() {
   decltype(2) x;
 }
 float global;
 void invalid2() {
   decltype(global) x;
 }
 void valid() {
   decltype(1.5) x;
   decltype(x) y;
 }
 #else
 auto function1 = invalid1;
 // expected-error@second.h:* {{'Types::Decltype::invalid1' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}}
 // expected-note@first.h:* {{but in 'FirstModule' found a different body}}
 auto function2 = invalid2;
-// expected-error@second.h:* {{'Types::Decltype::invalid2' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}}
-// expected-note@first.h:* {{but in 'FirstModule' found a different body}}
+// FIXME: We should reject the merge of `invalid2` and diagnose about the
+// inconsistent definition of `global`.
 auto function3 = valid;
 #endif
 }  // namespace Decltype
 
 namespace Auto {
 #if defined(FIRST)
 void invalid1() {
   decltype(auto) x = 1;

 void invalid2() {
   B a{};
 }
 void valid() {
   B b{};
 }
 #else
 auto function1 = invalid1;
-// expected-error@second.h:* {{'Types::DeducedTemplateSpecialization::invalid1' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}}
-// expected-note@first.h:* {{but in 'FirstModule' found a different body}}
+// FIXME: We should reject the merge of `invalid1` due to the inconsistent definition.
 auto function2 = invalid2;
 // expected-error@second.h:* {{'Types::DeducedTemplateSpecialization::invalid2' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}}
 // expected-note@first.h:* {{but in 'FirstModule' found a different body}}
 auto function3 = valid;
 #endif
 }  // namespace DeducedTemplateSpecialization
 
 namespace DependentAddressSpace {

 };
 #elif defined(SECOND)
 typedef struct T1 {} T1;
 class S1 {
   T1* t;
 };
 #else
 S1 s1;
 #endif
 
 #if defined(FIRST)
 struct T2;
 class S2 {
   const T2* t = nullptr;
 };
 #elif defined(SECOND)
 typedef struct T2 {} T2;
 class S2 {

 typedef struct T4 {} T4;
 } // namespace NS4
 class S4 {
   NS4::T4* t = 0;
 };
 #else
 S4 s4;
 #endif
+
+#if defined(FIRST)
+namespace NS5 {
+struct T5;
+} // namespace NS5
+class S5 {
+  NS5::T5* t = 0;
+};
+#elif defined(SECOND)
+namespace NS5 {
+typedef struct T5_Other {} T5;
+} // namespace NS4
+class S5 {
+  NS5::T5* t = 0;
+};
+#else
+S5 s5;
+// expected-error@first.h:* {{'TypedefStruct::S5::t' from module 'FirstModule' is not present in definition of 'TypedefStruct::S5' in module 'SecondModule'}}
+// expected-note@second.h:* {{declaration of 't' does not match}}
+#endif
 } // namespace TypedefStruct
 
+#if defined (FIRST)
+typedef int T;
+namespace A {
+  struct X { T n; };
+}
+#elif defined(SECOND)
+namespace A {
+  typedef int T;
+  struct X { T n; };
+}
+#else
+A::X x;
+#endif
+
 // Keep macros contained to one file.
 #ifdef FIRST
 #undef FIRST
 #endif
 
 #ifdef SECOND
 #undef SECOND
 #endif
 
 #ifdef ACCESS
 #undef ACCESS
 #endif

clang/test/Modules/odr_hash.mm

 void valid() {
   static int __attribute((objc_gc(strong))) *x;
 }
 #else
 auto function1 = invalid1;
 // expected-error@second.h:* {{Types::Attributed::invalid1' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}}
 // expected-note@first.h:* {{but in 'FirstModule' found a different body}}
 auto function2 = invalid2;
-// expected-error@second.h:* {{'Types::Attributed::invalid2' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}}
-// expected-note@first.h:* {{but in 'FirstModule' found a different body}}
+
 auto function3 = valid;
 #endif
 }  // namespace Attributed
 
 namespace BlockPointer {
 #if defined(FIRST)
 void invalid1() {
   void (^x)(int);

 }
 @end
 @interface Interface6 <T1 : I1 *, T2 : I2 *> {
 @public
   T2 z;
 }
 @end
 #else
-// expected-error@first.h:* {{'Interface4::x' from module 'FirstModule' is not present in definition of 'Interface4' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'x' does not match}}
-// expected-error@first.h:* {{'Interface5::y' from module 'FirstModule' is not present in definition of 'Interface5' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'y' does not match}}
-// expected-error@first.h:* {{'Interface6::z' from module 'FirstModule' is not present in definition of 'Interface6' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'z' does not match}}
+
 #endif
 
 namespace Types {
 namespace ObjCTypeParam {
 #if defined(FIRST) || defined(SECOND)
 struct Invalid1 {
   Interface4 *I;
   decltype(I->x) x;
 };
 struct Invalid2 {
   Interface5 *I;
   decltype(I->y) y;
 };
 struct Invalid3 {
   Interface6 *I;
   decltype(I->z) z;
 };
 #else
 Invalid1 i1;
-// expected-error@first.h:* {{'Types::ObjCTypeParam::Invalid1::x' from module 'FirstModule' is not present in definition of 'Types::ObjCTypeParam::Invalid1' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'x' does not match}}
+
 Invalid2 i2;
-// expected-error@first.h:* {{'Types::ObjCTypeParam::Invalid2::y' from module 'FirstModule' is not present in definition of 'Types::ObjCTypeParam::Invalid2' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'y' does not match}}
+
 Invalid3 i3;
-// expected-error@first.h:* {{'Types::ObjCTypeParam::Invalid3::z' from module 'FirstModule' is not present in definition of 'Types::ObjCTypeParam::Invalid3' in module 'SecondModule'}}
-// expected-note@second.h:* {{declaration of 'z' does not match}}
+
+// FIXME: We should reject to merge these structs and diagnose for the
+// different definitions for Interface4/Interface5/Interface6.
+
 #endif
 
 }  // namespace ObjCTypeParam
 }  // namespace Types
 
 namespace CallMethods {
 #if defined(FIRST)
 void invalid1(EmptySelectorSlot *obj) {

clang/test/Modules/pr63595.cppm

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -I%t %t/module1.cppm -o %t/module1.pcm
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -I%t %t/module2.cppm -o %t/module2.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/merge.cpp -verify -fsyntax-only
+
+//--- header.h
+namespace NS {
+template <int I>
+class A {
+};
+
+template <template <int I_> class T>
+class B {
+};
+}
+
+//--- module1.h
+namespace NS {
+using C = B<A>;
+}
+struct D : NS::C {
+    using Type = NS::C;
+};
+
+//--- module1.cppm
+// inside NS, using C = B<A>
+module;
+#include "header.h"
+#include "module1.h"
+export module module1;
+export using ::D;
+
+//--- module2.h
+namespace NS {
+using C = B<NS::A>;
+}
+struct D : NS::C {
+    using Type = NS::C;
+};
+
+//--- module2.cppm
+// inside NS, using C = B<NS::A>
+module;
+#include "header.h"
+#include "module2.h"
+export module module2;
+export using ::D;
+
+//--- merge.cpp
+// expected-no-diagnostics
+import module1;
+import module2;
+D d;