[ASTStructuralEquivalence] Add support for comparing ObjCCategoryDecl.

[vsapsai]

Summary

Will post shortly another patch that relies on comparing ObjCCategoryDecl.

[shafik]

This make sense to me at a first pass, please make sure you run check-lldb as well.

clang/lib/AST/ASTStructuralEquivalence.cpp

1979

I am curious what case are we catching here? Does NumArgs ever have the value 1?

[a_sidorin]

Hi Volodymyr,
Unfortunately, I'm not familiar with Objective-C and its frontend but I have a question.

clang/lib/AST/ASTStructuralEquivalence.cpp

1997

Should we check if the parameter count is different?

[vsapsai]

Thanks for the reviews! I'm going to address the comments, check-lldb, check tests failing on Debian.

clang/lib/AST/ASTStructuralEquivalence.cpp

1979

Here I'm trying to handle the case with argument-less methods. For example, -(void)test; has 0 arguments but we still want to compare the first slot. At the moment I don't know how to clarify the code to make the intention clearer. Can add a comment explaining the intention (though there is a test that should catch breaking code accidentally).

And to answer your question, NumArgs can have value 1.

1997

Mismatch in the number of parameters should be caught by NumArgs != Selector2.getNumArgs() earlier. But I think it makes sense to add an assertion verifying param_size is equal at this point.

[vsapsai]

clang/lib/AST/ASTStructuralEquivalence.cpp

1248

By the way, the alternative to introducing parameter Owner2Type was to use ...Owner2 = cast<TypeDecl>(...). But that would work only for ObjCInterfaceDecl and would require making ObjCInterfaceDecl TypeDecl. Conceptually, it makes sense for ObjCInterfaceDecl to be TypeDecl as @interface does represent a type. But I've decided that such invasive change is not justified.

[vsapsai]

Add a comment and an assertion.

[vsapsai]

check-lldb has the following tests failing

lldb-shell :: Expr/TestIRMemoryMap.test
lldb-shell :: Process/TestEnvironment.test
lldb-shell :: Register/x86-64-gp-read.test
lldb-shell :: Register/x86-64-read.test
lldb-shell :: Register/x86-64-ymm-read.test
lldb-shell :: Register/x86-multithread-read.test
lldb-shell :: Register/x86-multithread-write.test

All of them look irrelevant as they are failing with various "file not found" errors, e.g., cstdlib, cstdint, cinttypes. I guess my local toolchain configuration differs from LLDB expectations.

clang/lib/AST/ASTStructuralEquivalence.cpp

1979

Added a comment.

1997

Added an assertion for param_size (not triggered during running the test suite).

[martong]

Basically, this looks good to me. But my confidence with ObjC is low, so, I'd like @shafik as well to approve.
Besides, seems like the pre-merge check fails with the new tests on Debian, could you please address that?

[vsapsai]

Fix tests on Debian by using -fobjc-nonfragile-abi explicitly as declaring ivars in extensions is supported only with non-fragile ABI.

[vsapsai]

Fix clang-format error.

[vsapsai]

In D121176#3372193, @martong wrote:

Basically, this looks good to me. But my confidence with ObjC is low, so, I'd like @shafik as well to approve.
Besides, seems like the pre-merge check fails with the new tests on Debian, could you please address that?

Thanks for the review! My confidence with the structural equivalence is low and I appreciate your expertise in this area.

Fixed the tests by using non-fragile ABI explicitly. The only remaining failing test is Clang :: Driver/clang_f_opts.c which is failing for unrelated reasons.

[vsapsai]

@shafik, can you please check the patch? Or maybe recommend somebody who worked both on ASTStructuralEquivalence and Objective-C part of clang?

[vsapsai]

Ping.

[vsapsai]

Ping.

[vsapsai]

Ping.

[martong]

Ok, still looks good to me, thanks!

[vsapsai]

Thanks for the review, Gabor! Now I'll work on rebasing the patch and testing one final time.

[vsapsai]

Rebase and trigger pre-commit tests.

clang/include/clang/Testing/CommandLineArgs.h

enum TestLanguage {
   Lang_C89,
   Lang_C99,
   Lang_CXX03,
   Lang_CXX11,
   Lang_CXX14,
   Lang_CXX17,
   Lang_CXX20,
   Lang_OpenCL,
+  Lang_OBJC,
   Lang_OBJCXX
 };
 
 std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang);
 std::vector<std::string> getCC1ArgsForTesting(TestLanguage Lang);
 
 StringRef getFilenameForTesting(TestLanguage Lang);
 
 } // end namespace clang
 
 #endif

clang/lib/AST/ASTStructuralEquivalence.cpp

if (Int1->isUnsigned() != Int2->isUnsigned() ||
                                   Int2->getNumBitsExpr()))
       return false;
   }
   } // end switch
 
   return true;
 }
 
-/// Determine structural equivalence of two fields.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
-                                     FieldDecl *Field1, FieldDecl *Field2) {
-  const auto *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
+                                     FieldDecl *Field1, FieldDecl *Field2,
+                                     QualType Owner2Type) {
+  const auto *Owner2 = cast<Decl>(Field2->getDeclContext());
 
   // For anonymous structs/unions, match up the anonymous struct/union type
   // declarations directly, so that we don't go off searching for anonymous
   // types
   if (Field1->isAnonymousStructOrUnion() &&
       Field2->isAnonymousStructOrUnion()) {
     RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
     RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
     return IsStructurallyEquivalent(Context, D1, D2);
   }
 
   // Check for equivalent field names.
   IdentifierInfo *Name1 = Field1->getIdentifier();
   IdentifierInfo *Name2 = Field2->getIdentifier();
   if (!::IsStructurallyEquivalent(Name1, Name2)) {
     if (Context.Complain) {
       Context.Diag2(
           Owner2->getLocation(),
           Context.getApplicableDiagnostic(diag::err_odr_tag_type_inconsistent))
-          << Context.ToCtx.getTypeDeclType(Owner2);
+          << Owner2Type;
       Context.Diag2(Field2->getLocation(), diag::note_odr_field_name)
           << Field2->getDeclName();
       Context.Diag1(Field1->getLocation(), diag::note_odr_field_name)
           << Field1->getDeclName();
     }
     return false;
   }
 
   if (!IsStructurallyEquivalent(Context, Field1->getType(),
                                 Field2->getType())) {
     if (Context.Complain) {
       Context.Diag2(
           Owner2->getLocation(),
           Context.getApplicableDiagnostic(diag::err_odr_tag_type_inconsistent))
-          << Context.ToCtx.getTypeDeclType(Owner2);
+          << Owner2Type;
       Context.Diag2(Field2->getLocation(), diag::note_odr_field)
           << Field2->getDeclName() << Field2->getType();
       Context.Diag1(Field1->getLocation(), diag::note_odr_field)
           << Field1->getDeclName() << Field1->getType();
     }
     return false;
   }
 
   if (Field1->isBitField())
     return IsStructurallyEquivalent(Context, Field1->getBitWidth(),
                                     Field2->getBitWidth());
 
   return true;
 }
 
+/// Determine structural equivalence of two fields.
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     FieldDecl *Field1, FieldDecl *Field2) {
+  const auto *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
+  return IsStructurallyEquivalent(Context, Field1, Field2,
+                                  Context.ToCtx.getTypeDeclType(Owner2));
+}
+
 /// Determine structural equivalence of two methods.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      CXXMethodDecl *Method1,
                                      CXXMethodDecl *Method2) {
   bool PropertiesEqual =
       Method1->getDeclKind() == Method2->getDeclKind() &&
       Method1->getRefQualifier() == Method2->getRefQualifier() &&
       Method1->getAccess() == Method2->getAccess() &&
if (auto *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
             << Base1->getType() << Base1->getSourceRange();
         Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
       }
       return false;
     }
   }
 
   // Check the fields for consistency.
+  QualType D2Type = Context.ToCtx.getTypeDeclType(D2);
   RecordDecl::field_iterator Field2 = D2->field_begin(),
                              Field2End = D2->field_end();
   for (RecordDecl::field_iterator Field1 = D1->field_begin(),
                                   Field1End = D1->field_end();
        Field1 != Field1End; ++Field1, ++Field2) {
     if (Field2 == Field2End) {
       if (Context.Complain) {
         Context.Diag2(D2->getLocation(),
                       Context.getApplicableDiagnostic(
                           diag::err_odr_tag_type_inconsistent))
             << Context.ToCtx.getTypeDeclType(D2);
         Context.Diag1(Field1->getLocation(), diag::note_odr_field)
             << Field1->getDeclName() << Field1->getType();
         Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
       }
       return false;
     }
 
-    if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
+    if (!IsStructurallyEquivalent(Context, *Field1, *Field2, D2Type))
       return false;
   }
 
   if (Field2 != Field2End) {
     if (Context.Complain) {
       Context.Diag2(D2->getLocation(), Context.getApplicableDiagnostic(
                                            diag::err_odr_tag_type_inconsistent))
           << Context.ToCtx.getTypeDeclType(D2);
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 
   // FIXME: Consider checking for function attributes as well.
   if (!IsStructurallyEquivalent(Context, D1->getType(), D2->getType()))
     return false;
 
   return true;
 }
 
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ObjCIvarDecl *D1, ObjCIvarDecl *D2,
+                                     QualType Owner2Type) {
+  if (D1->getAccessControl() != D2->getAccessControl())
+    return false;
+
+  return IsStructurallyEquivalent(Context, cast<FieldDecl>(D1),
+                                  cast<FieldDecl>(D2), Owner2Type);
+}
+
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ObjCIvarDecl *D1, ObjCIvarDecl *D2) {
+  QualType Owner2Type =
+      Context.ToCtx.getObjCInterfaceType(D2->getContainingInterface());
+  return IsStructurallyEquivalent(Context, D1, D2, Owner2Type);
+}
+
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ObjCMethodDecl *Method1,
+                                     ObjCMethodDecl *Method2) {
+  bool PropertiesEqual =
+      Method1->isInstanceMethod() == Method2->isInstanceMethod() &&
+      Method1->isVariadic() == Method2->isVariadic() &&
+      Method1->isDirectMethod() == Method2->isDirectMethod();
+  if (!PropertiesEqual)
+    return false;
+
+  // Compare selector slot names.
+  Selector Selector1 = Method1->getSelector(),
+           Selector2 = Method2->getSelector();
+  unsigned NumArgs = Selector1.getNumArgs();
+  if (NumArgs != Selector2.getNumArgs())
+    return false;
+  // Compare all selector slots. For selectors with arguments it means all arg
+  // slots. And if there are no arguments, compare the first-and-only slot.
+  unsigned SlotsToCheck = NumArgs > 0 ? NumArgs : 1;
+  for (unsigned I = 0; I < SlotsToCheck; ++I) {
+    if (!IsStructurallyEquivalent(Selector1.getIdentifierInfoForSlot(I),
+                                  Selector2.getIdentifierInfoForSlot(I)))
+      return false;
+  }
+
+  // Compare types.
+  if (!IsStructurallyEquivalent(Context, Method1->getReturnType(),
+                                Method2->getReturnType()))
+    return false;
+  assert(
+      Method1->param_size() == Method2->param_size() &&
+      "Same number of arguments should be already enforced in Selector checks");
+  for (ObjCMethodDecl::param_type_iterator
+           ParamT1 = Method1->param_type_begin(),
+           ParamT1End = Method1->param_type_end(),
+           ParamT2 = Method2->param_type_begin(),
+           ParamT2End = Method2->param_type_end();
+       (ParamT1 != ParamT1End) && (ParamT2 != ParamT2End);
+       ++ParamT1, ++ParamT2) {
+    if (!IsStructurallyEquivalent(Context, *ParamT1, *ParamT2))
+      return false;
+  }
+
+  return true;
+}
+
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ObjCCategoryDecl *D1,
+                                     ObjCCategoryDecl *D2) {
+  if (!IsStructurallyEquivalent(D1->getIdentifier(), D2->getIdentifier()))
+    return false;
+
+  if (!IsStructurallyEquivalent(D1->getClassInterface()->getIdentifier(),
+                                D2->getClassInterface()->getIdentifier()))
+    return false;
+
+  // Compare protocols.
+  ObjCCategoryDecl::protocol_iterator Protocol2 = D2->protocol_begin(),
+                                      Protocol2End = D2->protocol_end();
+  for (ObjCCategoryDecl::protocol_iterator Protocol1 = D1->protocol_begin(),
+                                           Protocol1End = D1->protocol_end();
+       Protocol1 != Protocol1End; ++Protocol1, ++Protocol2) {
+    if (Protocol2 == Protocol2End)
+      return false;
+    if (!IsStructurallyEquivalent((*Protocol1)->getIdentifier(),
+                                  (*Protocol2)->getIdentifier()))
+      return false;
+  }
+  if (Protocol2 != Protocol2End)
+    return false;
+
+  // Compare ivars.
+  QualType D2Type = Context.ToCtx.getObjCInterfaceType(D2->getClassInterface());
+  ObjCCategoryDecl::ivar_iterator Ivar2 = D2->ivar_begin(),
+                                  Ivar2End = D2->ivar_end();
+  for (ObjCCategoryDecl::ivar_iterator Ivar1 = D1->ivar_begin(),
+                                       Ivar1End = D1->ivar_end();
+       Ivar1 != Ivar1End; ++Ivar1, ++Ivar2) {
+    if (Ivar2 == Ivar2End)
+      return false;
+    if (!IsStructurallyEquivalent(Context, *Ivar1, *Ivar2, D2Type))
+      return false;
+  }
+  if (Ivar2 != Ivar2End)
+    return false;
+
+  // Compare methods.
+  ObjCCategoryDecl::method_iterator Method2 = D2->meth_begin(),
+                                    Method2End = D2->meth_end();
+  for (ObjCCategoryDecl::method_iterator Method1 = D1->meth_begin(),
+                                         Method1End = D1->meth_end();
+       Method1 != Method1End; ++Method1, ++Method2) {
+    if (Method2 == Method2End)
+      return false;
+    if (!IsStructurallyEquivalent(Context, *Method1, *Method2))
+      return false;
+  }
+  if (Method2 != Method2End)
+    return false;
+
+  return true;
+}
+
 /// Determine structural equivalence of two declarations.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      Decl *D1, Decl *D2) {
   // FIXME: Check for known structural equivalences via a callback of some sort.
 
   D1 = D1->getCanonicalDecl();
   D2 = D2->getCanonicalDecl();
   std::pair<Decl *, Decl *> P{D1, D2};

clang/lib/Testing/CommandLineArgs.cpp

case Lang_CXX14:
     Args = {"-std=c++14", "-frtti"};
     break;
   case Lang_CXX17:
     Args = {"-std=c++17", "-frtti"};
     break;
   case Lang_CXX20:
     Args = {"-std=c++20", "-frtti"};
     break;
+  case Lang_OBJC:
+    Args = {"-x", "objective-c", "-frtti", "-fobjc-nonfragile-abi"};
+    break;
   case Lang_OBJCXX:
     Args = {"-x", "objective-c++", "-frtti"};
     break;
   case Lang_OpenCL:
     llvm_unreachable("Not implemented yet!");
   }
   return Args;
 }
StringRef getFilenameForTesting(TestLanguage Lang) {
   case Lang_CXX14:
   case Lang_CXX17:
   case Lang_CXX20:
     return "input.cc";
 
   case Lang_OpenCL:
     return "input.cl";
 
+  case Lang_OBJC:
+    return "input.m";
+
   case Lang_OBJCXX:
     return "input.mm";
   }
   llvm_unreachable("Unhandled TestLanguage enum");
 }
 
 } // end namespace clang

clang/unittests/AST/MatchVerifier.h

MatchVerifier<NodeType>::match(const std::string &Code,
   case Lang_CXX20:
     Args.push_back("-std=c++20");
     FileName = "input.cc";
     break;
   case Lang_OpenCL:
     Args.push_back("-cl-no-stdinc");
     FileName = "input.cl";
     break;
+  case Lang_OBJC:
+    Args.push_back("-fobjc-nonfragile-abi");
+    FileName = "input.m";
+    break;
   case Lang_OBJCXX:
     FileName = "input.mm";
     break;
   }
 
   // Default to failure in case callback is never called
   setFailure("Could not find match");
   if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))

clang/unittests/AST/StructuralEquivalenceTest.cpp

 
 TEST_F(StructuralEquivalenceEnumConstantTest, EnumConstantsWithDifferentName) {
   auto t =
       makeDecls<EnumConstantDecl>("enum e { foo = 1 };", "enum e { bar = 1 };",
                                   Lang_CXX11, enumConstantDecl());
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
+struct StructuralEquivalenceObjCCategoryTest : StructuralEquivalenceTest {};
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, MatchinCategoryNames) {
+  auto t = makeDecls<ObjCCategoryDecl>("@interface A @end @interface A(X) @end",
+                                       "@interface A @end @interface A(X) @end",
+                                       Lang_OBJC, objcCategoryDecl());
+  EXPECT_TRUE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, CategoriesForDifferentClasses) {
+  auto t = makeDecls<ObjCCategoryDecl>("@interface A @end @interface A(X) @end",
+                                       "@interface B @end @interface B(X) @end",
+                                       Lang_OBJC, objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, CategoriesWithDifferentNames) {
+  auto t = makeDecls<ObjCCategoryDecl>("@interface A @end @interface A(X) @end",
+                                       "@interface A @end @interface A(Y) @end",
+                                       Lang_OBJC, objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, CategoryAndExtension) {
+  auto t = makeDecls<ObjCCategoryDecl>("@interface A @end @interface A(X) @end",
+                                       "@interface A @end @interface A() @end",
+                                       Lang_OBJC, objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, MatchingProtocols) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@protocol P @end @interface A @end @interface A(X)<P> @end",
+      "@protocol P @end @interface A @end @interface A(X)<P> @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_TRUE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentProtocols) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@protocol P @end @interface A @end @interface A(X)<P> @end",
+      "@protocol Q @end @interface A @end @interface A(X)<Q> @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentProtocolsOrder) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@protocol P @end @protocol Q @end @interface A @end @interface A(X)<P, "
+      "Q> @end",
+      "@protocol P @end @protocol Q @end @interface A @end @interface A(X)<Q, "
+      "P> @end",
+      Lang_OBJC, objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, MatchingIvars) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A() { int x; } @end",
+      "@interface A @end @interface A() { int x; } @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_TRUE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentIvarName) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A() { int x; } @end",
+      "@interface A @end @interface A() { int y; } @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentIvarType) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A() { int x; } @end",
+      "@interface A @end @interface A() { float x; } @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentIvarBitfieldWidth) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A() { int x: 1; } @end",
+      "@interface A @end @interface A() { int x: 2; } @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentIvarVisibility) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A() { @public int x; } @end",
+      "@interface A @end @interface A() { @protected int x; } @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentIvarNumber) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A() { int x; } @end",
+      "@interface A @end @interface A() {} @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentIvarOrder) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A() { int x; int y; } @end",
+      "@interface A @end @interface A() { int y; int x; } @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, MatchingMethods) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test; @end",
+      "@interface A @end @interface A(X) -(void)test; @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_TRUE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentMethodName) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test; @end",
+      "@interface A @end @interface A(X) -(void)wasd; @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+
+  auto t2 = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test:(int)x more:(int)y; @end",
+      "@interface A @end @interface A(X) -(void)test:(int)x :(int)y; @end",
+      Lang_OBJC, objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t2));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentMethodClassInstance) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test; @end",
+      "@interface A @end @interface A(X) +(void)test; @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentMethodReturnType) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test; @end",
+      "@interface A @end @interface A(X) -(int)test; @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentMethodParameterType) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test:(int)x; @end",
+      "@interface A @end @interface A(X) -(void)test:(float)x; @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentMethodParameterName) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test:(int)x; @end",
+      "@interface A @end @interface A(X) -(void)test:(int)y; @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_TRUE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentMethodNumber) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)test; @end",
+      "@interface A @end @interface A(X) @end", Lang_OBJC, objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
+TEST_F(StructuralEquivalenceObjCCategoryTest, DifferentMethodOrder) {
+  auto t = makeDecls<ObjCCategoryDecl>(
+      "@interface A @end @interface A(X) -(void)u; -(void)v; @end",
+      "@interface A @end @interface A(X) -(void)v; -(void)u; @end", Lang_OBJC,
+      objcCategoryDecl());
+  EXPECT_FALSE(testStructuralMatch(t));
+}
+
 struct StructuralEquivalenceTemplateTest : StructuralEquivalenceTest {};
 
 TEST_F(StructuralEquivalenceTemplateTest, ExactlySameTemplates) {
   auto t = makeNamedDecls("template <class T> struct foo;",
                           "template <class T> struct foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(t));
 }