[C++20] [Modules] Don't complain about duplicated default template argument across modules

[ChuanqiXu]

Summary

See https://github.com/cplusplus/draft/pull/5204 for a detailed background.

Simply, the test redundant-template-default-arg.cpp attached to this patch should be accepted instead of being complained about the redefinition.

[urnathan]

clang/lib/Sema/SemaTemplate.cpp

2740–2756

while I do approve of good commenting, this is a little wordy and I think misleading. It is only from global module fragments that you can get duplicate declarations and those must match default parameters (I think). so perhaps 'IsGlobalModule'? or somehting like that.

Perhaps all of this comment shoould be at the point of checking? After all the preceding comment mentions 'variables used to ...'?

2931

Yes, I think this is a better place for the comment. If there are duplicates we need to check they are the same -- pedantically the same tokens, but at least AST equivalence?

[ChuanqiXu]

clang/lib/Sema/SemaTemplate.cpp

2931

Yeah, it should be necessary to check the ODR. I found it is not trivial to do so. It needs more work. I sent https://reviews.llvm.org/D118223 as a forward patch.

[ChuanqiXu]

Address comment to check if the duplicated default template arguments are the same and add tests to address the negative cases.

[urnathan]

clang/lib/Sema/SemaTemplate.cpp

2672–2674

Can this ever trigger and the below expression test not trigger, given the above type comparison?

2676–2700

I'm kind of surprised how complex this check is. Isn't there an AST comparator available somewhere?

[ChuanqiXu]

Use ODRHash to simplify code.

clang/lib/Sema/SemaTemplate.cpp

2676–2700

I found ODRHash. I think it is much better now.

[urnathan]

clang/lib/Sema/SemaTemplate.cpp

2676–2700

hm that suggests there there must be a comparator too -- this isn't a cryptographically strong hash is it? How would the compiler currently make use of 'definitely different' and 'probably the same' without such a comparator?

[ChuanqiXu]

clang/lib/Sema/SemaTemplate.cpp

2676–2700

Yeah, I am sure there is not an such comparator. Or it has some methods like: ASTContext::hasSameType for type and ASTContext::isSameEntity() for Decl. But it lacks such methods now for Stmt and Expr.

How would the compiler currently make use of 'definitely different' and 'probably the same' without such a comparator?

Now it uses the two methods I listed above and ODRHash to compare. I think the two methods works for 'definitely different' and ODRHash works for 'probably the same'. So it's the reason why my previous implementation looks lengthy. Since I want to handle it by hand. (The previous method only works for simple Expr. I think it would be large work to implement comparator for whole Expr or Stmt).

[urnathan]

clang/lib/Sema/SemaTemplate.cpp

2676–2700

Hm, how do template instantations work -- there must be some way of determining 'is this instantation just here the same as one I've already seen'

[urnathan]

clang/lib/Sema/SemaTemplate.cpp

2676–2700

also, the same functionality (with more generality) is needed for comparing regular function default arguments with multiple definitions in the GM. How is that done (or is it yet to be implemented?)

[ChuanqiXu]

clang/lib/Sema/SemaTemplate.cpp

2676–2700

also, the same functionality (with more generality) is needed for comparing regular function default arguments with multiple definitions in the GM. How is that done (or is it yet to be implemented?)

We implemented ODR check in ASTReader by ODRHash.

Hm, how do template instantations work -- there must be some way of determining 'is this instantation just here the same as one I've already seen'

First, previously we don't allow the redefinition of template default argument. And for the case without template default argument, previously we would try find the definition for the synthesized type, if we could find one, use it. And if we couldn't find one, initialize one.

---

Given we already checks ODR by ODRHash in ASTReader, I think what we do here might not be bad. I agree that it is odd at the first sight to use Hash to detect difference from the perspective of CS. But if this is what we used to do, I think it is acceptable.

[urnathan]

clang/lib/Sema/SemaTemplate.cpp

2676–2700

indeed. I would be more comfortable with a comment by someone more familiar with this @rsmith ?

[ChuanqiXu]

@rsmith gentle ping~

[ChuanqiXu]

@urnathan It looks @rsmith is not available this time. Would you like to accept this one?

[ChuanqiXu]

@rsmith gentle ping~

[ChuanqiXu]

@rsmith gentle ping~

[rsmith]

clang/lib/Sema/SemaTemplate.cpp

2668

ODR hashing is intended to produce a hash that's stable across compilations (so it can't use pointer comparisons to check types are identical, for example). For use cases that don't need a hash code that's stable across processes, using Stmt::Profile should be preferred. Can you use that here?

2737–2746

Please rephrase these comments to remove the "Variables used to" part and to explain instead what value is stored in the variable. (Eg: "Whether we've seen a duplicate default argument in the same translation unit.")

2778–2786

This is the wrong thing to check -- whether the owning module is imported (from an AST file) is irrelevant. We might parse multiple translation units in the same compilation, and we might split a single translation unit into multiple compilations (eg with a precompiled preamble) resulting in some of the same translation unit being in an AST file. What matters is whether the declaration is in the current translation unit or a different translation unit.

I'm not sure what the best way to detect that is currently. You might be able to just compare getOwningModule() of the two declarations, but I don't think that will properly handle cases in the global module fragment, or cases where one template is in the primary module interface unit and another is in a module implementation unit of the same module.

Ideally I would like for us to create one TranslationUnitDecl per translation unit, rather than shoving all imported code into the translation unit of the importer, but that's a moderately large change, which I'd like to not block this change on if we can avoid it. But I think that's the right longer-term approach. Then here we would just need to find the lexically-enclosing TranslationUnitDecl for each template parameter and see if they're the same.

[ChuanqiXu]

Address comments.

[ChuanqiXu]

clang/lib/Sema/SemaTemplate.cpp

2778–2786

I found we could determine whether the declaration is in the current TU or not by using Sema::ModuleScopes, which contains the modules we're currently parsing.

[ChuanqiXu]

Remove unused header ODRHash.h

[ChuanqiXu]

@rsmith @iains ping

[ChuanqiXu]

@rsmith @iains gentle ping~

[ChuanqiXu]

Add @ilya-biryukov since he did similar things in https://reviews.llvm.org/D128921

[ChuanqiXu]

Given @rsmith and @iains is busy and this revision is relatively small, innocent and looks good to me, I plan to land this in Friday in case there is no further comments.

[ChuanqiXu]

Minor changes.

[ChuanqiXu]

Minor changes.

[ChuanqiXu]

Committed in https://reviews.llvm.org/rG354a597b9f3aad2a6a37518d47351adb99688cd2

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx17_compat_template_nontype_parm_type : Warning<
   "C++ standards before C++20">,
   DefaultIgnore, InGroup<CXXPre20Compat>;
 def warn_cxx14_compat_template_nontype_parm_auto_type : Warning<
   "non-type template parameters declared with %0 are incompatible with C++ "
   "standards before C++17">,
   DefaultIgnore, InGroup<CXXPre17Compat>;
 def err_template_param_default_arg_redefinition : Error<
   "template parameter redefines default argument">;
+def err_template_param_default_arg_inconsistent_redefinition : Error<
+  "template parameter default argument is inconsistent with previous definition">;
 def note_template_param_prev_default_arg : Note<
   "previous default template argument defined here">;
+def note_template_param_prev_default_arg_in_other_module : Note<
+  "previous default template argument defined in module %0">;
 def err_template_param_default_arg_missing : Error<
   "template parameter missing a default argument">;
 def ext_template_parameter_default_in_function_template : ExtWarn<
   "default template arguments for a function template are a C++11 extension">,
   InGroup<CXX11>;
 def warn_cxx98_compat_template_parameter_default_in_function_template : Warning<
   "default template arguments for a function template are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;

clang/include/clang/Sema/Sema.h

private:
 
   VisibleModuleSet VisibleModules;
 
   /// Cache for module units which is usable for current module.
   llvm::DenseSet<const Module *> UsableModuleUnitsCache;
 
   bool isUsableModule(const Module *M);
 
+  // Determine whether the module M belongs to the  current TU.
+  bool isModuleUnitOfCurrentTU(const Module *M) const;
+
 public:
   /// Get the module owning an entity.
   Module *getOwningModule(const Decl *Entity) {
     return Entity->getOwningModule();
   }
 
   bool isModuleDirectlyImported(const Module *M) {
     return DirectModuleImports.contains(M);

clang/lib/Sema/SemaModule.cpp

Module *Sema::PushGlobalModuleFragment(SourceLocation BeginLoc,
   return GlobalModuleFragment;
 }
 
 void Sema::PopGlobalModuleFragment() {
   assert(!ModuleScopes.empty() && getCurrentModule()->isGlobalModule() &&
          "left the wrong module scope, which is not global module fragment");
   ModuleScopes.pop_back();
 }
+
+bool Sema::isModuleUnitOfCurrentTU(const Module *M) const {
+  assert(M);
+
+  Module *CurrentModuleUnit = getCurrentModule();
+
+  // If we are not in a module currently, M must not be the module unit of
+  // current TU.
+  if (!CurrentModuleUnit)
+    return false;
+
+  return M->isSubModuleOf(CurrentModuleUnit->getTopLevelModule());
+}

clang/lib/Sema/SemaTemplate.cpp

if (TemplateTemplateParmDecl *InnerTTP
                                         = dyn_cast<TemplateTemplateParmDecl>(P))
       if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
         return true;
   }
 
   return false;
 }
 
+static bool hasSameDefaultTemplateArgument(NamedDecl *X, NamedDecl *Y) {
+  ASTContext &C = X->getASTContext();
+  // If the type parameter isn't the same already, we don't need to check the
+  // default argument further.
+  if (!C.isSameTemplateParameter(X, Y))
+    return false;
+
+  if (auto *TTPX = dyn_cast<TemplateTypeParmDecl>(X)) {
+    auto *TTPY = cast<TemplateTypeParmDecl>(Y);
+    if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
+      return false;
+
+    return C.hasSameType(TTPX->getDefaultArgument(),
+                         TTPY->getDefaultArgument());
+  }
+
+  if (auto *NTTPX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
+    auto *NTTPY = cast<NonTypeTemplateParmDecl>(Y);
+    if (!NTTPX->hasDefaultArgument() || !NTTPY->hasDefaultArgument())
+      return false;
+
+    Expr *DefaultArgumentX = NTTPX->getDefaultArgument()->IgnoreImpCasts();
+    Expr *DefaultArgumentY = NTTPY->getDefaultArgument()->IgnoreImpCasts();
+    llvm::FoldingSetNodeID XID, YID;
+    DefaultArgumentX->Profile(XID, C, /*Canonical=*/true);
+    DefaultArgumentY->Profile(YID, C, /*Canonical=*/true);
+    return XID == YID;
+  }
+
+  auto *TTPX = cast<TemplateTemplateParmDecl>(X);
+  auto *TTPY = cast<TemplateTemplateParmDecl>(Y);
+
+  if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
+    return false;
+
+  const TemplateArgument &TAX = TTPX->getDefaultArgument().getArgument();
+  const TemplateArgument &TAY = TTPY->getDefaultArgument().getArgument();
+  return C.hasSameTemplateName(TAX.getAsTemplate(), TAY.getAsTemplate());
+}
+
 /// Checks the validity of a template parameter list, possibly
 /// considering the template parameter list from a previous
 /// declaration.
 ///
 /// If an "old" template parameter list is provided, it must be
 /// equivalent (per TemplateParameterListsAreEqual) to the "new"
 /// template parameter list.
 ///
 /// \param NewParams Template parameter list for a new template
 /// declaration. This template parameter list will be updated with any
 /// default arguments that are carried through from the previous
 /// template parameter list.
 ///
 /// \param OldParams If provided, template parameter list from a
 /// previous declaration of the same template. Default template
 /// arguments will be merged from the old template parameter list to
 /// the new template parameter list.
 ///
 /// \param TPC Describes the context in which we are checking the given
 /// template parameter list.
 ///
 /// \param SkipBody If we might have already made a prior merged definition
 /// of this template visible, the corresponding body-skipping information.
 /// Default argument redefinition is not an error when skipping such a body,
bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
   TemplateParameterList::iterator OldParam = NewParams->end();
   if (OldParams)
     OldParam = OldParams->begin();
 
   bool RemoveDefaultArguments = false;
   for (TemplateParameterList::iterator NewParam = NewParams->begin(),
                                     NewParamEnd = NewParams->end();
        NewParam != NewParamEnd; ++NewParam) {
-    // Variables used to diagnose redundant default arguments
+    // Whether we've seen a duplicate default argument in the same translation
+    // unit.
     bool RedundantDefaultArg = false;
+    // Whether we've found inconsis inconsitent default arguments in different
+    // translation unit.
+    bool InconsistentDefaultArg = false;
+    // The name of the module which contains the inconsistent default argument.
+    std::string PrevModuleName;
+
     SourceLocation OldDefaultLoc;
     SourceLocation NewDefaultLoc;
 
     // Variable used to diagnose missing default arguments
     bool MissingDefaultArg = false;
 
     // Variable used to diagnose non-final parameter packs
     bool SawParameterPack = false;
 
     if (TemplateTypeParmDecl *NewTypeParm
           = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
       // Check the presence of a default argument here.
       if (NewTypeParm->hasDefaultArgument() &&
           DiagnoseDefaultTemplateArgument(*this, TPC,
                                           NewTypeParm->getLocation(),
                NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
                                                        .getSourceRange()))
         NewTypeParm->removeDefaultArgument();
 
       // Merge default arguments for template type parameters.
       TemplateTypeParmDecl *OldTypeParm
           = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
       if (NewTypeParm->isParameterPack()) {
         assert(!NewTypeParm->hasDefaultArgument() &&
                "Parameter packs can't have a default argument!");
         SawParameterPack = true;
       } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
                  NewTypeParm->hasDefaultArgument() &&
                  (!SkipBody || !SkipBody->ShouldSkip)) {
         OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
         NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
         SawDefaultArgument = true;
+
+        if (!OldTypeParm->getOwningModule() ||
+            isModuleUnitOfCurrentTU(OldTypeParm->getOwningModule()))
           RedundantDefaultArg = true;
+        else if (!hasSameDefaultTemplateArgument(OldTypeParm, NewTypeParm)) {
+          InconsistentDefaultArg = true;
+          PrevModuleName =
+              OldTypeParm->getImportedOwningModule()->getFullModuleName();
+        }
         PreviousDefaultArgLoc = NewDefaultLoc;
       } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
         // Merge the default argument from the old declaration to the
         // new declaration.
         NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
         PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
       } else if (NewTypeParm->hasDefaultArgument()) {
         SawDefaultArgument = true;
if (TemplateTypeParmDecl *NewTypeParm
         if (!NewNonTypeParm->isPackExpansion())
           SawParameterPack = true;
       } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
                  NewNonTypeParm->hasDefaultArgument() &&
                  (!SkipBody || !SkipBody->ShouldSkip)) {
         OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
         NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
         SawDefaultArgument = true;
+        if (!OldNonTypeParm->getOwningModule() ||
+            isModuleUnitOfCurrentTU(OldNonTypeParm->getOwningModule()))
           RedundantDefaultArg = true;
+        else if (!hasSameDefaultTemplateArgument(OldNonTypeParm,
+                                                 NewNonTypeParm)) {
+          InconsistentDefaultArg = true;
+          PrevModuleName =
+              OldNonTypeParm->getImportedOwningModule()->getFullModuleName();
+        }
         PreviousDefaultArgLoc = NewDefaultLoc;
       } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
         // Merge the default argument from the old declaration to the
         // new declaration.
         NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
         PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
       } else if (NewNonTypeParm->hasDefaultArgument()) {
         SawDefaultArgument = true;
if (TemplateTypeParmDecl *NewTypeParm
           SawParameterPack = true;
       } else if (OldTemplateParm &&
                  hasVisibleDefaultArgument(OldTemplateParm) &&
                  NewTemplateParm->hasDefaultArgument() &&
                  (!SkipBody || !SkipBody->ShouldSkip)) {
         OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
         NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
         SawDefaultArgument = true;
+        if (!OldTemplateParm->getOwningModule() ||
+            isModuleUnitOfCurrentTU(OldTemplateParm->getOwningModule()))
           RedundantDefaultArg = true;
+        else if (!hasSameDefaultTemplateArgument(OldTemplateParm,
+                                                 NewTemplateParm)) {
+          InconsistentDefaultArg = true;
+          PrevModuleName =
+              OldTemplateParm->getImportedOwningModule()->getFullModuleName();
+        }
         PreviousDefaultArgLoc = NewDefaultLoc;
       } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
         // Merge the default argument from the old declaration to the
         // new declaration.
         NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
         PreviousDefaultArgLoc
           = OldTemplateParm->getDefaultArgument().getLocation();
       } else if (NewTemplateParm->hasDefaultArgument()) {
for (TemplateParameterList::iterator NewParam = NewParams->begin(),
     if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
         (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
          TPC == TPC_TypeAliasTemplate)) {
       Diag((*NewParam)->getLocation(),
            diag::err_template_param_pack_must_be_last_template_parameter);
       Invalid = true;
     }
 
+    // [basic.def.odr]/13:
+    //     There can be more than one definition of a
+    //     ...
+    //     default template argument
+    //     ...
+    //     in a program provided that each definition appears in a different
+    //     translation unit and the definitions satisfy the [same-meaning
+    //     criteria of the ODR].
+    //
+    // Simply, the design of modules allows the definition of template default
+    // argument to be repeated across translation unit. Note that the ODR is
+    // checked elsewhere. But it is still not allowed to repeat template default
+    // argument in the same translation unit.
     if (RedundantDefaultArg) {
-      // C++ [temp.param]p12:
-      //   A template-parameter shall not be given default arguments
-      //   by two different declarations in the same scope.
       Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
       Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
       Invalid = true;
+    } else if (InconsistentDefaultArg) {
+      // We could only diagnose about the case that the OldParam is imported.
+      // The case NewParam is imported should be handled in ASTReader.
+      Diag(NewDefaultLoc,
+           diag::err_template_param_default_arg_inconsistent_redefinition);
+      Diag(OldDefaultLoc,
+           diag::note_template_param_prev_default_arg_in_other_module)
+          << PrevModuleName;
+      Invalid = true;
     } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
       // C++ [temp.param]p11:
       //   If a template-parameter of a class template has a default
       //   template-argument, each subsequent template-parameter shall either
       //   have a default template-argument supplied or be a template parameter
       //   pack.
       Diag((*NewParam)->getLocation(),
            diag::err_template_param_default_arg_missing);

clang/test/Modules/Inputs/redundant-template-default-arg/foo.h

+template <typename T>
+T u;
+
+template <typename T = int>
+T v;
+
+template <int T = 8>
+int v2;
+
+template <typename T>
+class my_array {};
+
+template <template <typename> typename C = my_array>
+int v3;
+
+template <typename T, int *i = nullptr>
+T v4;
+
+template <typename T, T *i = nullptr>
+T v5;
+
+inline int a = 43;
+template <typename T, int *i = &a>
+T v6;
+
+inline int b = 43;
+template <typename T, T *i = &b>
+T v7;
+
+template <int T = (3 > 2)>
+int v8;
+
+consteval int getInt() {
+  return 55;
+}
+template <int T = getInt()>
+int v9;

clang/test/Modules/Inputs/redundant-template-default-arg/foo.cppm

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

clang/test/Modules/Inputs/redundant-template-default-arg2/foo.cppm

+export module foo;
+export template <typename T = int>
+T v;
+
+export template <int T = 8>
+int v2;
+
+export template <typename T>
+class my_array {};
+
+export template <template <typename> typename C = my_array>
+int v3;

clang/test/Modules/Inputs/redundant-template-default-arg3/foo.h

+template <typename T = int>
+T v;
+
+template <int T = 8>
+int v2;
+
+template <typename T>
+class my_array {};
+
+template <template <typename> typename C = my_array>
+int v3;
+
+template <typename T, int *i = nullptr>
+T v4;
+
+template <typename T, T *i = nullptr>
+T v5;
+
+inline int a = 43;
+template <typename T, int *i = &a>
+T v6;
+
+inline int b = 43;
+template <typename T, T *i = &b>
+T v7;
+
+template <int T = (3 > 2)>
+int v8;
+
+consteval int getInt() {
+  return 55;
+}
+template <int T = getInt()>
+int v9;

clang/test/Modules/Inputs/redundant-template-default-arg3/foo.cppm

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

clang/test/Modules/Inputs/redundant-template-default-arg3/foo_bad.h

+template <typename T = double>
+T v;
+
+template <int T = 9>
+int v2;
+
+template <typename T>
+class others_array {};
+
+template <template <typename> typename C = others_array>
+int v3;
+
+static int a;
+consteval int *getIntPtr() {
+  return &a;
+}
+template <typename T, int *i = getIntPtr()>
+T v4;
+
+consteval void *getVoidPtr() {
+  return &a;
+}
+template <typename T, T *i = getVoidPtr()>
+T v5;
+
+inline int a_ = 43;
+template <typename T, int *i = &a_>
+T v6;
+
+inline int b_ = 43;
+template <typename T, T *i = &b_>
+T v7;
+
+template <int T = -1>
+int v8;
+
+consteval int getInt2() {
+  return 55;
+}
+template <int T = getInt2()>
+int v9;

clang/test/Modules/redundant-template-default-arg.cpp

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clang_cc1  -std=c++20 %S/Inputs/redundant-template-default-arg/foo.cppm -I%S/Inputs/redundant-template-default-arg/. -emit-module-interface -o %t/foo.pcm
+// RUN: %clang_cc1  -fprebuilt-module-path=%t -std=c++20 %s -I%S/Inputs/redundant-template-default-arg/. -fsyntax-only -verify
+// expected-no-diagnostics
+import foo;
+#include "foo.h"

clang/test/Modules/redundant-template-default-arg2.cpp

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clang_cc1  -std=c++20 %S/Inputs/redundant-template-default-arg2/foo.cppm -I%S/Inputs/redundant-template-default-arg2/. -emit-module-interface -o %t/foo.pcm
+// RUN: %clang_cc1  -fprebuilt-module-path=%t -std=c++20 %s -fsyntax-only -verify
+import foo;
+template <typename T = int>
+T v; // expected-error {{declaration of 'v' in the global module follows declaration in module foo}}
+     // expected-note@Inputs/redundant-template-default-arg2/foo.cppm:3 {{previous declaration is here}}
+
+template <int T = 8>
+int v2; // expected-error {{declaration of 'v2' in the global module follows declaration in module foo}}
+        // expected-note@Inputs/redundant-template-default-arg2/foo.cppm:6 {{previous declaration is here}}
+
+template <typename T>
+class my_array {}; // expected-error {{redefinition of 'my_array'}}
+                   // expected-note@Inputs/redundant-template-default-arg2/foo.cppm:9 {{previous definition is here}}
+
+template <template <typename> typename C = my_array>
+int v3; // expected-error {{declaration of 'v3' in the global module follows declaration in module foo}}
+        // expected-note@Inputs/redundant-template-default-arg2/foo.cppm:12 {{previous declaration is here}}

clang/test/Modules/redundant-template-default-arg3.cpp

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clang_cc1  -std=c++20 %S/Inputs/redundant-template-default-arg3/foo.cppm -I%S/Inputs/redundant-template-default-arg3/. -emit-module-interface -o %t/foo.pcm
+// RUN: %clang_cc1  -fprebuilt-module-path=%t -std=c++20 %s -I%S/Inputs/redundant-template-default-arg3/. -fsyntax-only -verify
+
+import foo;
+#include "foo_bad.h"
+
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:1 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:1 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:4 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:4 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:10 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:10 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:17 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:13 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:23 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:16 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:27 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:20 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:31 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:24 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:34 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:27 {{previous default template argument defined in module foo.<global>}}
+// expected-error@Inputs/redundant-template-default-arg3/foo_bad.h:40 {{template parameter default argument is inconsistent with previous definition}}
+// expected-note@Inputs/redundant-template-default-arg3/foo.h:33 {{previous default template argument defined in module foo.<global>}}