vsapsai created this revision.
vsapsai added reviewers: martong, shafik, a_sidorin.
Herald added subscribers: ributzka, rnkovacs.
Herald added a project: All.
vsapsai requested review of this revision.
Herald added a project: clang.
Will post shortly another patch that relies on comparing ObjCCategoryDecl.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D121176
Files:
clang/lib/AST/ASTStructuralEquivalence.cpp
clang/unittests/AST/StructuralEquivalenceTest.cpp
Index: clang/unittests/AST/StructuralEquivalenceTest.cpp
===================================================================
--- clang/unittests/AST/StructuralEquivalenceTest.cpp
+++ clang/unittests/AST/StructuralEquivalenceTest.cpp
@@ -1120,6 +1120,182 @@
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_OBJCXX, 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_OBJCXX, 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_OBJCXX, 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_OBJCXX, 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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX, 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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX, 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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX,
+ objcCategoryDecl());
+ EXPECT_FALSE(testStructuralMatch(t));
+}
+
+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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX, 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_OBJCXX,
+ 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_OBJCXX,
+ 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_OBJCXX,
+ objcCategoryDecl());
+ EXPECT_FALSE(testStructuralMatch(t));
+}
+
struct StructuralEquivalenceTemplateTest : StructuralEquivalenceTest {};
TEST_F(StructuralEquivalenceTemplateTest, ExactlySameTemplates) {
Index: clang/lib/AST/ASTStructuralEquivalence.cpp
===================================================================
--- clang/lib/AST/ASTStructuralEquivalence.cpp
+++ clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -1234,10 +1234,10 @@
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
@@ -1257,7 +1257,7 @@
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)
@@ -1272,7 +1272,7 @@
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)
@@ -1288,6 +1288,14 @@
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,
@@ -1602,6 +1610,7 @@
}
// 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(),
@@ -1620,7 +1629,7 @@
return false;
}
- if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
+ if (!IsStructurallyEquivalent(Context, *Field1, *Field2, D2Type))
return false;
}
@@ -1926,6 +1935,121 @@
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;
+ 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;
+ 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) {
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
