[clang][ASTImporter]Skip check depth of friend template parameter

[jcsxky]

Summary

Depth of the parameter of friend template class declaration in a template class is 1, while in the specialization the depth is 0. This will cause failure on 'IsStructurallyEquivalent' as a name conflict in 'VisitClassTemplateDecl'(see testcase of 'SkipComparingFriendTemplateDepth'). The patch fix it by ignore the depth only in this special case.

[jcsxky]

update patch

[jcsxky]

update patch for passing unittest

[jcsxky]

update patch for passing unittest and test

[jcsxky]

format code

[jcsxky]

add unittest

[Michael137]

Could you please elaborate in the commit message what exactly the issue currently is and how the patch addresses it?

[jcsxky]

In D156693#4560023, @Michael137 wrote:

Could you please elaborate in the commit message what exactly the issue currently is and how the patch addresses it?

In D156693#4560023, @Michael137 wrote:

Could you please elaborate in the commit message what exactly the issue currently is and how the patch addresses it?

details are added to commit message

[balazske]

The summary tells nothing about what is the real problem to fix here. In the lit test I see that an error message is displayed, this causes the test failure. The problem is that the structural equivalence check is not good for this special case. The imported AST contains a class template specialization for A, in this specialization the friend class template A has a previous decl that points to the original friend class template that is in a ClassTemplateDecl. In the specialization the "depth" of template arguments is 0, but in the original template it is 1 (the "to" code at import contains only the "original template", no specialization). This difference in the "depth" causes the type mismatch when the specialization is imported.
AST dump of this code can show the problem:

template<class T, T U>
class A;

template<class T, T U>
class A {
public:
  template<class P, P Q>
  friend class A;

  A(T x):x(x){}
	
private:
  T x;
};

A<int,3> a1(0);

It is really interesting that at friend templates the depth is 1 but friend declarations point to objects outside the class, so really the depth should not increase in a friend template from this point of view. But this is an AST issue.

clang/lib/AST/ASTImporter.cpp

5857

It is not good to use ParentMap in the AST importer because it does AST traversal, even worse if this is done on the To context where the AST is modified and may be in incomplete state.
This way of fix is probably not good for a case when there is a real structural in-equivalence, this would be not detected. And the current solution skips this FoundDecl but (at least in the used test code) this should be found, not skipped. (But we can create code where the skip is correct, if there is a real structural in-equivalence.)

clang/unittests/AST/ASTImporterTest.cpp

4252

I think the namespace __1 is not important for reproduction of this problem.

4268

Functions foo, bar, main are not required. It is only important to have a variable of type A like A<int, 3> a1(0); in the imported code at getTuDecl.

4281

The coding format should be aligned to the format of other test codes in this file, and this is normally same as the clang format guidelines (automatic reformatting does not work in the test code).

4318

Definition is misleading because this is not the definition, it matches the first declaration of A in the AST. Better name is like FromA like in the other tests, or FromXxx.

4320

The imported name can be ToA or ToXxx or ImportedXxx, this makes real distinction between the from and to objects.

4322

This cast is not needed, type of Template is already ClassTemplateDecl*.

[jcsxky]

In D156693#4560110, @balazske wrote:

The summary tells nothing about what is the real problem to fix here. In the lit test I see that an error message is displayed, this causes the test failure. The problem is that the structural equivalence check is not good for this special case. The imported AST contains a class template specialization for A, in this specialization the friend class template A has a previous decl that points to the original friend class template that is in a ClassTemplateDecl. In the specialization the "depth" of template arguments is 0, but in the original template it is 1 (the "to" code at import contains only the "original template", no specialization). This difference in the "depth" causes the type mismatch when the specialization is imported.
AST dump of this code can show the problem:

template<class T, T U>
class A;

template<class T, T U>
class A {
public:
  template<class P, P Q>
  friend class A;

  A(T x):x(x){}
	
private:
  T x;
};

A<int,3> a1(0);

It is really interesting that at friend templates the depth is 1 but friend declarations point to objects outside the class, so really the depth should not increase in a friend template from this point of view. But this is an AST issue.

Depth of specialization friend template is 0 while it is 1 in class declaration is reasonable, because after template class specialization there not exists template parameter and the friend template becomes outermost scope, thus depth is 0. Thanks to the different of depth causes the non equivalence of the two 'NonTypeTemplateParm', I think there should ignore comparing the depth in this special case to make two types equivalence.

[jcsxky]

update diff: ignore comparing depth in friend class template

[jcsxky]

clean unittest

[balazske]

This fix can cause problems because the depth comparison is omitted all times. It would be better to omit depth check if the imported template is a friend, and has a ClassTemplateSpecializationDecl as context. Probably even then it is possible to construct cases where the checked template has references to other templates with different "depth" which should not omitted in the check. But I have no idea of a better solution, only to pass a ClassTemplateDecl or ClassTemplateSpecializationDecl to StructuralEquivalenceContext and omit the depth check only at this object.

[jcsxky]

update diff: add more conditions on when to ignore comparing depth of two template classes to minimize influence to others and fix name of test case to make easy understanding

[jcsxky]

In D156693#4568941, @balazske wrote:

This fix can cause problems because the depth comparison is omitted all times. It would be better to omit depth check if the imported template is a friend, and has a ClassTemplateSpecializationDecl as context. Probably even then it is possible to construct cases where the checked template has references to other templates with different "depth" which should not omitted in the check. But I have no idea of a better solution, only to pass a ClassTemplateDecl or ClassTemplateSpecializationDecl to StructuralEquivalenceContext and omit the depth check only at this object.

Thanks for your advice. More conditions are added to check when to ignore the comparison and minimize the influence to other.
Also I have tried to not increase depth in friend declaration in the template class, but the code affects others a lot. Only to skip the comparison can pass this special case.

[balazske]

A simple test should be added to StructuralEquivalenceTest.cpp too to check if ignore (and not ignore) depth works.

I think this solution is not always correct, but is still an improvement.

clang/include/clang/AST/ASTStructuralEquivalence.h

80

bool IgnoreTemplateParmDepth = false)

clang/lib/AST/ASTImporter.cpp

512

This should be false to have the original behavior if not specified.

5857

Probably add IsFriendTemplate?

clang/unittests/AST/ASTImporterTest.cpp

4292

Probably add hasDefinition() to the matcher.

[jcsxky]

fixed according to the review and add testcase to StructuralEquivalenceTest.cpp.

[jcsxky]

clang/lib/AST/ASTImporter.cpp

5857

I think this is not needed because D is not always a friend template class according to the testcase (IsFriendTemplate is false in testcase).

[balazske]

clang/unittests/AST/StructuralEquivalenceTest.cpp

1700

IgnoreTemplateParmDepth) {

1735

It should work with more simple code like:

makeDecls<ClassTemplateDecl>(
  R"(
    template<class> struct A;
  )",
  R"(
    template<class> struct S {
      template<class> friend struct A;
    };
  )",
  Lang_CXX03, classTemplateDecl(hasName("A")), classTemplateDecl(hasName("A"))
);

[jcsxky]

Add more simple testcase to StructuralEquivalenceTest.cpp.

[balazske]

clang/unittests/AST/StructuralEquivalenceTest.cpp

1711

The intent was to have EXPECT_FALSE without ignore depth, and the next test would be not needed. If it does not work with this code a different code can be found. The depth of the (unnamed) template parameter is really different in these cases too, but it is probably not detected by structural equivalence. Maybe template<int U> or template<class T, T U> is needed. But to document this behavior the current test can be added too, with name IgnoreTemplateParmDepthAtTemplateTypeParmDecl, and the new one with name IgnoreTemplateParmDepthAtNonTypeTemplateParmDecl.

[jcsxky]

clang/unittests/AST/StructuralEquivalenceTest.cpp

1711

1. The reason why it's true without ignore depth is that template parameter is 'TemplateTypeParm' in this case. So

IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                     TemplateTypeParmDecl *D1,
                                     TemplateTypeParmDecl *D2)

will be called and return true.

2. When process 'NonTypeTemplateParm',

IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                     QualType T1, QualType T2)

is called and return false as the different depth.
I will add IgnoreTemplateParmDepthAtNonTypeTemplateParmDecl to illustrate the difference. Also, next test will be removed.

[jcsxky]

Add testcase to illustrate the difference between TemplateTypeParm and NonTypeTemplateParm in detecting by structural equivalence.

[balazske]

clang/unittests/AST/StructuralEquivalenceTest.cpp

1718

The convention is to start variable names with uppercase, for example "Decls".

[jcsxky]

Fix variable names according to the convention.

[jcsxky]

In D156693#4584657, @balazske wrote:

A simple test should be added to StructuralEquivalenceTest.cpp too to check if ignore (and not ignore) depth works.

I think this solution is not always correct, but is still an improvement.

As a friend template declaration, compared to the template class definition, the only difference is the depth of the NonTypeTemplateParam. If the template class definition is equivalent to the class in From context, there is no probelm. Otherwise, the friend template declaration is also can't equivalent to it. Because the friend template declaration is equivalent to its definition when ignore the depth. To make a counterexample, we should put the friend declaration in different depth, but they are all equivalent in these cases.

[balazske]

My concern was related to nested namespaces or nested classes with friend declarations that are equivalent and differ only in the nesting level. It may be possible to construct code where a declaration at an inner (nested) level is found to be equivalent with a similar looking class at an outer level. But I now do not have time to look for an example to test it, and I am not fully familiar with exact rules of friend declarations, so I accept this fix.

[jcsxky]

In D156693#4603537, @balazske wrote:

My concern was related to nested namespaces or nested classes with friend declarations that are equivalent and differ only in the nesting level. It may be possible to construct code where a declaration at an inner (nested) level is found to be equivalent with a similar looking class at an outer level. But I now do not have time to look for an example to test it, and I am not fully familiar with exact rules of friend declarations, so I accept this fix.

• The same declcontext will make the template class and friend template class in the same namespace.
• Namespace will not change the depth of template class parameter. So, the equvalence will not be changed whether ignore the depth or not.
• Declcontext of friend tempalte class is outer namespace (if exists), So, classes in this declcontext are equvalent with identical name.

According the the conclusion above, the nested namespace or nested class will not affect the equvalence of the two classes (as far as I concerned).

[shafik]

clang/unittests/AST/StructuralEquivalenceTest.cpp

140

See bugprone-argument-comment for details of this format.

We use this everywhere we have literals without clear meaning being used as arguments.

145

[jcsxky]

add argument comment according to bugprone-argument-comment.

[jcsxky]

clang/unittests/AST/StructuralEquivalenceTest.cpp

140

argument comment has been added.

clang/include/clang/AST/ASTStructuralEquivalence.h

struct StructuralEquivalenceContext {
   bool ErrorOnTagTypeMismatch;
 
   /// Whether to complain about failures.
   bool Complain;
 
   /// \c true if the last diagnostic came from ToCtx.
   bool LastDiagFromC2 = false;
 
+  /// Whether to ignore comparing the depth of template param(TemplateTypeParm)
+  bool IgnoreTemplateParmDepth;
+
   StructuralEquivalenceContext(
       ASTContext &FromCtx, ASTContext &ToCtx,
       llvm::DenseSet<std::pair<Decl *, Decl *>> &NonEquivalentDecls,
-      StructuralEquivalenceKind EqKind,
-      bool StrictTypeSpelling = false, bool Complain = true,
-      bool ErrorOnTagTypeMismatch = false)
+      StructuralEquivalenceKind EqKind, bool StrictTypeSpelling = false,
+      bool Complain = true, bool ErrorOnTagTypeMismatch = false,
+      bool IgnoreTemplateParmDepth = false)
       : FromCtx(FromCtx), ToCtx(ToCtx), NonEquivalentDecls(NonEquivalentDecls),
         EqKind(EqKind), StrictTypeSpelling(StrictTypeSpelling),
-        ErrorOnTagTypeMismatch(ErrorOnTagTypeMismatch), Complain(Complain) {}
+        ErrorOnTagTypeMismatch(ErrorOnTagTypeMismatch), Complain(Complain),
+        IgnoreTemplateParmDepth(IgnoreTemplateParmDepth) {}
 
   DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID);
   DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID);
 
   /// Determine whether the two declarations are structurally
   /// equivalent.
   /// Implementation functions (all static functions in
   /// ASTStructuralEquivalence.cpp) must never call this function because that

clang/lib/AST/ASTImporter.cpp

Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam,
                                         ParmVarDecl *ToParam);
 
     Expected<InheritedConstructor>
     ImportInheritedConstructor(const InheritedConstructor &From);
 
     template <typename T>
     bool hasSameVisibilityContextAndLinkage(T *Found, T *From);
 
-    bool IsStructuralMatch(Decl *From, Decl *To, bool Complain = true);
+    bool IsStructuralMatch(Decl *From, Decl *To, bool Complain = true,
+                           bool IgnoreTemplateParmDepth = false);
     ExpectedDecl VisitDecl(Decl *D);
     ExpectedDecl VisitImportDecl(ImportDecl *D);
     ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
     ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
     ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
     ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
     ExpectedDecl VisitBindingDecl(BindingDecl *D);
     ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);

 }
 
 static StructuralEquivalenceKind
 getStructuralEquivalenceKind(const ASTImporter &Importer) {
   return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
                                     : StructuralEquivalenceKind::Default;
 }
 
-bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
+bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain,
+                                        bool IgnoreTemplateParmDepth) {
   // Eliminate a potential failure point where we attempt to re-import
   // something we're trying to import while completing ToRecord.
   Decl *ToOrigin = Importer.GetOriginalDecl(To);
   if (ToOrigin) {
     To = ToOrigin;
   }
 
   StructuralEquivalenceContext Ctx(
       Importer.getFromContext(), Importer.getToContext(),
       Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
-      false, Complain);
+      /*StrictTypeSpelling=*/false, Complain, /*ErrorOnTagTypeMismatch=*/false,
+      IgnoreTemplateParmDepth);
   return Ctx.IsEquivalent(From, To);
 }
 
 ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
     << D->getDeclKindName();
   return make_error<ASTImportError>(ASTImportError::UnsupportedConstruct);
 }
for (auto *FoundDecl : FoundDecls) {
         continue;
 
       Decl *Found = FoundDecl;
       auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found);
       if (FoundTemplate) {
         if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
           continue;
 
-        if (IsStructuralMatch(D, FoundTemplate)) {
+        // FIXME: sufficient conditon for 'IgnoreTemplateParmDepth'?
+        bool IgnoreTemplateParmDepth =
+            FoundTemplate->getFriendObjectKind() != Decl::FOK_None &&
+            !D->specializations().empty();
+        if (IsStructuralMatch(D, FoundTemplate, /*Complain=*/true,
+                              IgnoreTemplateParmDepth)) {
           ClassTemplateDecl *TemplateWithDef =
               getTemplateDefinition(FoundTemplate);
           if (D->isThisDeclarationADefinition() && TemplateWithDef)
             return Importer.MapImported(D, TemplateWithDef);
           if (!FoundByLookup)
             FoundByLookup = FoundTemplate;
           // Search in all matches because there may be multiple decl chains,
           // see ASTTests test ImportExistingFriendClassTemplateDef.

clang/lib/AST/ASTStructuralEquivalence.cpp

case Type::Enum:
     if (!IsStructurallyEquivalent(Context, cast<TagType>(T1)->getDecl(),
                                   cast<TagType>(T2)->getDecl()))
       return false;
     break;
 
   case Type::TemplateTypeParm: {
     const auto *Parm1 = cast<TemplateTypeParmType>(T1);
     const auto *Parm2 = cast<TemplateTypeParmType>(T2);
-    if (Parm1->getDepth() != Parm2->getDepth())
+    if (!Context.IgnoreTemplateParmDepth &&
+        Parm1->getDepth() != Parm2->getDepth())
       return false;
     if (Parm1->getIndex() != Parm2->getIndex())
       return false;
     if (Parm1->isParameterPack() != Parm2->isParameterPack())
       return false;
 
     // Names of template type parameters are never significant.
     break;

clang/unittests/AST/ASTImporterTest.cpp

TEST_P(ImportFriendClasses, DeclsFromFriendsShouldBeInRedeclChains) {
   std::tie(From, To) =
       getImportedDecl("class declToImport {};", Lang_CXX03,
                       "class Y { friend class declToImport; };", Lang_CXX03);
   auto *Imported = cast<CXXRecordDecl>(To);
 
   EXPECT_TRUE(Imported->getPreviousDecl());
 }
 
+TEST_P(ImportFriendClasses, SkipComparingFriendTemplateDepth) {
+  Decl *ToTU = getToTuDecl(
+      R"(
+      template <class T, T U>
+      class A;
+
+      template <class T, T U>
+      class A {
+      public:
+        template <class P, P Q>
+        friend class A;
+
+        A(T x)  :x(x) {}
+
+      private:
+        T x;
+      };
+      )",
+      Lang_CXX11);
+
+  auto *Fwd = FirstDeclMatcher<ClassTemplateDecl>().match(
+      ToTU,
+      classTemplateDecl(has(cxxRecordDecl(hasDefinition(), hasName("A")))));
+  Decl *FromTU = getTuDecl(
+      R"(
+      template <class T, T U>
+      class A;
+
+      template <class T, T U>
+      class A {
+      public:
+        template <class P, P Q>
+        friend class A;
+
+        A(T x) : x(x) {}
+
+      private:
+        T x;
+      };
+
+      A<int,3> a1(0);
+      )",
+      Lang_CXX11, "input1.cc");
+  auto *FromA = FirstDeclMatcher<ClassTemplateDecl>().match(
+      FromTU,
+      classTemplateDecl(has(cxxRecordDecl(hasDefinition(), hasName("A")))));
+  auto *ToA = Import(FromA, Lang_CXX11);
+  EXPECT_TRUE(ToA);
+  EXPECT_EQ(Fwd->getTemplatedDecl()->getTypeForDecl(),
+            ToA->getTemplatedDecl()->getTypeForDecl());
+}
+
 TEST_P(ImportFriendClasses,
        ImportOfClassTemplateDefinitionShouldConnectToFwdFriend) {
   Decl *ToTU = getToTuDecl(
       R"(
       class X {
         class Y;
       };
       class X::Y {
         template <typename T>
         friend class F; // The decl context of F is the global namespace.
       };
       )",
       Lang_CXX03);
   auto *ToDecl = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("F")));
   Decl *FromTU = getTuDecl(
       R"(
       template <typename T>
       class F {};
       )",
       Lang_CXX03, "input0.cc");
   auto *Definition = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU, classTemplateDecl(hasName("F")));
   auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX03));
   EXPECT_TRUE(ImportedDef->getPreviousDecl());
   EXPECT_EQ(ToDecl, ImportedDef->getPreviousDecl());
   EXPECT_EQ(ToDecl->getTemplatedDecl(),
             ImportedDef->getTemplatedDecl()->getPreviousDecl());
 }
 

clang/unittests/AST/StructuralEquivalenceTest.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTStructuralEquivalence.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Testing/CommandLineArgs.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/TargetParser/Host.h"
 
 #include "DeclMatcher.h"
 
struct StructuralEquivalenceTest : ::testing::Test {
   makeWrappedStmts(const std::string &SrcCode0, const std::string &SrcCode1,
                    TestLanguage Lang, const MatcherType &AMatcher) {
     auto Wrap = [](const std::string &Src) {
       return "void wrapped() {" + Src + ";}";
     };
     return makeStmts(Wrap(SrcCode0), Wrap(SrcCode1), Lang, AMatcher);
   }
 
-  bool testStructuralMatch(Decl *D0, Decl *D1) {
+  bool testStructuralMatch(Decl *D0, Decl *D1,
+                           bool IgnoreTemplateParmDepth = false) {
     llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls01;
     llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls10;
     StructuralEquivalenceContext Ctx01(
-        D0->getASTContext(), D1->getASTContext(),
-        NonEquivalentDecls01, StructuralEquivalenceKind::Default, false, false);
+        D0->getASTContext(), D1->getASTContext(), NonEquivalentDecls01,
+        StructuralEquivalenceKind::Default, /*StrictTypeSpelling=*/false,
+        /*Complain=*/false, /*ErrorOnTagTypeMismatch=*/false,
+        IgnoreTemplateParmDepth);
     StructuralEquivalenceContext Ctx10(
-        D1->getASTContext(), D0->getASTContext(),
-        NonEquivalentDecls10, StructuralEquivalenceKind::Default, false, false);
+        D1->getASTContext(), D0->getASTContext(), NonEquivalentDecls10,
+        StructuralEquivalenceKind::Default, /*StrictTypeSpelling=*/false,
+        /*Complain=*/false, /*ErrorOnTagTypeMismatch=*/false,
+        IgnoreTemplateParmDepth);
     bool Eq01 = Ctx01.IsEquivalent(D0, D1);
     bool Eq10 = Ctx10.IsEquivalent(D1, D0);
     EXPECT_EQ(Eq01, Eq10);
     return Eq01;
   }
 
   bool testStructuralMatch(StmtWithASTContext S0, StmtWithASTContext S1) {
     llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls01;
bool testStructuralMatch(StmtWithASTContext S0, StmtWithASTContext S1) {
     return Eq01;
   }
 
   bool
   testStructuralMatch(std::tuple<StmtWithASTContext, StmtWithASTContext> t) {
     return testStructuralMatch(get<0>(t), get<1>(t));
   }
 
-  bool testStructuralMatch(std::tuple<Decl *, Decl *> t) {
-    return testStructuralMatch(get<0>(t), get<1>(t));
+  bool testStructuralMatch(std::tuple<Decl *, Decl *> t,
+                           bool IgnoreTemplateParmDepth = false) {
+    return testStructuralMatch(get<0>(t), get<1>(t), IgnoreTemplateParmDepth);
   }
 };
 
 TEST_F(StructuralEquivalenceTest, Int) {
   auto Decls = makeNamedDecls("int foo;", "int foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));
 }
 
auto t = makeDecls<ClassTemplateSpecializationDecl>(
       using namespace N;
       // Explicit instantiation with UNqualified name.
       template struct Primary<Arg>;
       )",
       Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
+TEST_F(StructuralEquivalenceTemplateTest,
+       IgnoreTemplateParmDepthAtTemplateTypeParmDecl) {
+  auto Decls = makeDecls<ClassTemplateDecl>(
+      R"(
+        template<class> struct A;
+      )",
+      R"(
+        template<class> struct S {
+          template<class> friend struct A;
+        };
+      )",
+      Lang_CXX03, classTemplateDecl(hasName("A")),
+      classTemplateDecl(hasName("A")));
+  EXPECT_TRUE(testStructuralMatch(Decls));
+  EXPECT_TRUE(testStructuralMatch(Decls, true));
+}
+
+TEST_F(StructuralEquivalenceTemplateTest,
+       IgnoreTemplateParmDepthAtNonTypeTemplateParmDecl) {
+  auto Decls = makeDecls<ClassTemplateDecl>(
+      R"(
+        template<class T, T U> struct A;
+      )",
+      R"(
+        template<class T> struct S {
+          template<class P, P Q> friend struct A;
+        };
+      )",
+      Lang_CXX03, classTemplateDecl(hasName("A")),
+      classTemplateDecl(hasName("A")));
+  EXPECT_FALSE(testStructuralMatch(Decls));
+  EXPECT_TRUE(testStructuralMatch(Decls, /*IgnoreTemplateParmDepth=*/true));
+}
+
 TEST_F(
     StructuralEquivalenceTemplateTest,
     ClassTemplSpecWithInequivalentShadowedTemplArg) {
   auto t = makeDecls<ClassTemplateSpecializationDecl>(
       R"(
       template <template <class> class T> struct Primary {};
       template <class T> struct Arg { int a; };
       // Explicit instantiation with ::Arg
       template struct Primary<Arg>;
       )",
       R"(