r336776 - [AST] Structural equivalence of methods
Balázs Kéri via cfe-commits
cfe-commits at lists.llvm.org
Wed Jul 11 11:50:39 PDT 2018
Hi,
I am aware of the problem, there should be already a commit to (hopefully)
correct the failure.
Balázs Kéri
Galina Kistanova <gkistanova at gmail.com> ezt írta (időpont: 2018. júl. 11.,
Sze, 20:01):
> Hello Balazs,
>
> This commit broke at least one of our builders:
>
> http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/10897
>
> . . .
> Failing Tests (1):
> Clang-Unit :: AST/./ASTTests.exe/StructuralEquivalenceRecordTest.Name
>
> Please have a look?
> It is not good idea to keep the bot red for too long. This hides new
> problem which later hard to track down.
>
> Thanks
>
> Galina
>
>
> On Wed, Jul 11, 2018 at 2:37 AM, Balazs Keri via cfe-commits <
> cfe-commits at lists.llvm.org> wrote:
>
>> Author: balazske
>> Date: Wed Jul 11 02:37:24 2018
>> New Revision: 336776
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=336776&view=rev
>> Log:
>> [AST] Structural equivalence of methods
>>
>> Summary:
>> Added structural equivalence check for C++ methods.
>> Improved structural equivalence tests.
>> Added related ASTImporter tests.
>>
>> Reviewers: a.sidorin, szepet, xazax.hun, martong, a_sidorin
>>
>> Reviewed By: martong, a_sidorin
>>
>> Subscribers: a_sidorin, rnkovacs, cfe-commits
>>
>> Differential Revision: https://reviews.llvm.org/D48628
>>
>> Modified:
>> cfe/trunk/lib/AST/ASTImporter.cpp
>> cfe/trunk/lib/AST/ASTStructuralEquivalence.cpp
>> cfe/trunk/unittests/AST/ASTImporterTest.cpp
>> cfe/trunk/unittests/AST/StructuralEquivalenceTest.cpp
>>
>> Modified: cfe/trunk/lib/AST/ASTImporter.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ASTImporter.cpp?rev=336776&r1=336775&r2=336776&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/ASTImporter.cpp (original)
>> +++ cfe/trunk/lib/AST/ASTImporter.cpp Wed Jul 11 02:37:24 2018
>> @@ -230,6 +230,7 @@ namespace clang {
>> bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl
>> *ToEC);
>> bool IsStructuralMatch(FunctionTemplateDecl *From,
>> FunctionTemplateDecl *To);
>> + bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
>> bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl
>> *To);
>> bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
>> Decl *VisitDecl(Decl *D);
>> @@ -1525,6 +1526,13 @@ bool ASTNodeImporter::IsStructuralMatch(
>> return Ctx.IsStructurallyEquivalent(From, To);
>> }
>>
>> +bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl
>> *To) {
>> + StructuralEquivalenceContext Ctx(
>> + Importer.getFromContext(), Importer.getToContext(),
>> + Importer.getNonEquivalentDecls(), false, false);
>> + return Ctx.IsStructurallyEquivalent(From, To);
>> +}
>> +
>> bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
>> EnumConstantDecl *ToEC) {
>> const llvm::APSInt &FromVal = FromEC->getInitVal();
>> @@ -2433,13 +2441,15 @@ Decl *ASTNodeImporter::VisitFunctionDecl
>> if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
>> if (FoundFunction->hasExternalFormalLinkage() &&
>> D->hasExternalFormalLinkage()) {
>> - if (Importer.IsStructurallyEquivalent(D->getType(),
>> -
>> FoundFunction->getType())) {
>> - if (D->doesThisDeclarationHaveABody() &&
>> - FoundFunction->hasBody())
>> - return Importer.Imported(D, FoundFunction);
>> - FoundByLookup = FoundFunction;
>> - break;
>> + if (IsStructuralMatch(D, FoundFunction)) {
>> + const FunctionDecl *Definition = nullptr;
>> + if (D->doesThisDeclarationHaveABody() &&
>> + FoundFunction->hasBody(Definition)) {
>> + return Importer.Imported(
>> + D, const_cast<FunctionDecl *>(Definition));
>> + }
>> + FoundByLookup = FoundFunction;
>> + break;
>> }
>>
>> // FIXME: Check for overloading more carefully, e.g., by
>> boosting
>>
>> Modified: cfe/trunk/lib/AST/ASTStructuralEquivalence.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ASTStructuralEquivalence.cpp?rev=336776&r1=336775&r2=336776&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/ASTStructuralEquivalence.cpp (original)
>> +++ cfe/trunk/lib/AST/ASTStructuralEquivalence.cpp Wed Jul 11 02:37:24
>> 2018
>> @@ -250,6 +250,9 @@ static bool IsStructurallyEquivalent(Str
>> if (T1.isNull() || T2.isNull())
>> return T1.isNull() && T2.isNull();
>>
>> + QualType OrigT1 = T1;
>> + QualType OrigT2 = T2;
>> +
>> if (!Context.StrictTypeSpelling) {
>> // We aren't being strict about token-to-token equivalence of types,
>> // so map down to the canonical type.
>> @@ -422,6 +425,7 @@ static bool IsStructurallyEquivalent(Str
>> case Type::FunctionProto: {
>> const auto *Proto1 = cast<FunctionProtoType>(T1);
>> const auto *Proto2 = cast<FunctionProtoType>(T2);
>> +
>> if (Proto1->getNumParams() != Proto2->getNumParams())
>> return false;
>> for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
>> @@ -431,23 +435,33 @@ static bool IsStructurallyEquivalent(Str
>> }
>> if (Proto1->isVariadic() != Proto2->isVariadic())
>> return false;
>> - if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
>> +
>> + if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
>> + return false;
>> +
>> + // Check exceptions, this information is lost in canonical type.
>> + const auto *OrigProto1 =
>> +
>> cast<FunctionProtoType>(OrigT1.getDesugaredType(Context.FromCtx));
>> + const auto *OrigProto2 =
>> + cast<FunctionProtoType>(OrigT2.getDesugaredType(Context.ToCtx));
>> + auto Spec1 = OrigProto1->getExceptionSpecType();
>> + auto Spec2 = OrigProto2->getExceptionSpecType();
>> +
>> + if (Spec1 != Spec2)
>> return false;
>> - if (Proto1->getExceptionSpecType() == EST_Dynamic) {
>> - if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
>> + if (Spec1 == EST_Dynamic) {
>> + if (OrigProto1->getNumExceptions() !=
>> OrigProto2->getNumExceptions())
>> return false;
>> - for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
>> - if (!IsStructurallyEquivalent(Context,
>> Proto1->getExceptionType(I),
>> - Proto2->getExceptionType(I)))
>> + for (unsigned I = 0, N = OrigProto1->getNumExceptions(); I != N;
>> ++I) {
>> + if (!IsStructurallyEquivalent(Context,
>> OrigProto1->getExceptionType(I),
>> + OrigProto2->getExceptionType(I)))
>> return false;
>> }
>> - } else if (isComputedNoexcept(Proto1->getExceptionSpecType())) {
>> - if (!IsStructurallyEquivalent(Context, Proto1->getNoexceptExpr(),
>> - Proto2->getNoexceptExpr()))
>> + } else if (isComputedNoexcept(Spec1)) {
>> + if (!IsStructurallyEquivalent(Context,
>> OrigProto1->getNoexceptExpr(),
>> + OrigProto2->getNoexceptExpr()))
>> return false;
>> }
>> - if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
>> - return false;
>>
>> // Fall through to check the bits common with FunctionNoProtoType.
>> LLVM_FALLTHROUGH;
>> @@ -830,6 +844,56 @@ static bool IsStructurallyEquivalent(Str
>> return true;
>> }
>>
>> +/// Determine structural equivalence of two methodss.
>> +static bool IsStructurallyEquivalent(StructuralEquivalenceContext
>> &Context,
>> + CXXMethodDecl *Method1,
>> + CXXMethodDecl *Method2) {
>> + bool PropertiesEqual =
>> + Method1->getDeclKind() == Method2->getDeclKind() &&
>> + Method1->getRefQualifier() == Method2->getRefQualifier() &&
>> + Method1->getAccess() == Method2->getAccess() &&
>> + Method1->getOverloadedOperator() ==
>> Method2->getOverloadedOperator() &&
>> + Method1->isStatic() == Method2->isStatic() &&
>> + Method1->isConst() == Method2->isConst() &&
>> + Method1->isVolatile() == Method2->isVolatile() &&
>> + Method1->isVirtual() == Method2->isVirtual() &&
>> + Method1->isPure() == Method2->isPure() &&
>> + Method1->isDefaulted() == Method2->isDefaulted() &&
>> + Method1->isDeleted() == Method2->isDeleted();
>> + if (!PropertiesEqual)
>> + return false;
>> + // FIXME: Check for 'final'.
>> +
>> + if (auto *Constructor1 = dyn_cast<CXXConstructorDecl>(Method1)) {
>> + auto *Constructor2 = cast<CXXConstructorDecl>(Method2);
>> + if (Constructor1->isExplicit() != Constructor2->isExplicit())
>> + return false;
>> + }
>> +
>> + if (auto *Conversion1 = dyn_cast<CXXConversionDecl>(Method1)) {
>> + auto *Conversion2 = cast<CXXConversionDecl>(Method2);
>> + if (Conversion1->isExplicit() != Conversion2->isExplicit())
>> + return false;
>> + if (!IsStructurallyEquivalent(Context,
>> Conversion1->getConversionType(),
>> + Conversion2->getConversionType()))
>> + return false;
>> + }
>> +
>> + const IdentifierInfo *Name1 = Method1->getIdentifier();
>> + const IdentifierInfo *Name2 = Method2->getIdentifier();
>> + if (!::IsStructurallyEquivalent(Name1, Name2)) {
>> + return false;
>> + // TODO: Names do not match, add warning like at check for FieldDecl.
>> + }
>> +
>> + // Check the prototypes.
>> + if (!::IsStructurallyEquivalent(Context,
>> + Method1->getType(),
>> Method2->getType()))
>> + return false;
>> +
>> + return true;
>> +}
>> +
>> /// Determine structural equivalence of two records.
>> static bool IsStructurallyEquivalent(StructuralEquivalenceContext
>> &Context,
>> RecordDecl *D1, RecordDecl *D2) {
>> @@ -1443,6 +1507,14 @@ bool StructuralEquivalenceContext::Finis
>> Equivalent = false;
>> } else {
>> // Kind mismatch.
>> + Equivalent = false;
>> + }
>> + } else if (auto *MD1 = dyn_cast<CXXMethodDecl>(D1)) {
>> + if (auto *MD2 = dyn_cast<CXXMethodDecl>(D2)) {
>> + if (!::IsStructurallyEquivalent(*this, MD1, MD2))
>> + Equivalent = false;
>> + } else {
>> + // Kind mismatch.
>> Equivalent = false;
>> }
>> } else if (FunctionDecl *FD1 = dyn_cast<FunctionDecl>(D1)) {
>>
>> Modified: cfe/trunk/unittests/AST/ASTImporterTest.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/AST/ASTImporterTest.cpp?rev=336776&r1=336775&r2=336776&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/unittests/AST/ASTImporterTest.cpp (original)
>> +++ cfe/trunk/unittests/AST/ASTImporterTest.cpp Wed Jul 11 02:37:24 2018
>> @@ -2243,6 +2243,132 @@ TEST_P(ImportExpr, UnresolvedMemberExpr)
>>
>> compoundStmt(has(callExpr(has(unresolvedMemberExpr())))))))));
>> }
>>
>> +TEST_P(ASTImporterTestBase, ImportOfEquivalentRecord) {
>> + Decl *ToR1;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { };", Lang_CXX, "input0.cc");
>> + auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
>> + FromTU, cxxRecordDecl(hasName("A")));
>> +
>> + ToR1 = Import(FromR, Lang_CXX);
>> + }
>> +
>> + Decl *ToR2;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { };", Lang_CXX, "input1.cc");
>> + auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
>> + FromTU, cxxRecordDecl(hasName("A")));
>> +
>> + ToR2 = Import(FromR, Lang_CXX);
>> + }
>> +
>> + EXPECT_EQ(ToR1, ToR2);
>> +}
>> +
>> +TEST_P(ASTImporterTestBase, ImportOfNonEquivalentRecord) {
>> + Decl *ToR1;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { int x; };", Lang_CXX, "input0.cc");
>> + auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
>> + FromTU, cxxRecordDecl(hasName("A")));
>> + ToR1 = Import(FromR, Lang_CXX);
>> + }
>> + Decl *ToR2;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { unsigned x; };", Lang_CXX, "input1.cc");
>> + auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
>> + FromTU, cxxRecordDecl(hasName("A")));
>> + ToR2 = Import(FromR, Lang_CXX);
>> + }
>> + EXPECT_NE(ToR1, ToR2);
>> +}
>> +
>> +TEST_P(ASTImporterTestBase, ImportOfEquivalentField) {
>> + Decl *ToF1;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { int x; };", Lang_CXX, "input0.cc");
>> + auto *FromF = FirstDeclMatcher<FieldDecl>().match(
>> + FromTU, fieldDecl(hasName("x")));
>> + ToF1 = Import(FromF, Lang_CXX);
>> + }
>> + Decl *ToF2;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { int x; };", Lang_CXX, "input1.cc");
>> + auto *FromF = FirstDeclMatcher<FieldDecl>().match(
>> + FromTU, fieldDecl(hasName("x")));
>> + ToF2 = Import(FromF, Lang_CXX);
>> + }
>> + EXPECT_EQ(ToF1, ToF2);
>> +}
>> +
>> +TEST_P(ASTImporterTestBase, ImportOfNonEquivalentField) {
>> + Decl *ToF1;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { int x; };", Lang_CXX, "input0.cc");
>> + auto *FromF = FirstDeclMatcher<FieldDecl>().match(
>> + FromTU, fieldDecl(hasName("x")));
>> + ToF1 = Import(FromF, Lang_CXX);
>> + }
>> + Decl *ToF2;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { unsigned x; };", Lang_CXX, "input1.cc");
>> + auto *FromF = FirstDeclMatcher<FieldDecl>().match(
>> + FromTU, fieldDecl(hasName("x")));
>> + ToF2 = Import(FromF, Lang_CXX);
>> + }
>> + EXPECT_NE(ToF1, ToF2);
>> +}
>> +
>> +TEST_P(ASTImporterTestBase, ImportOfEquivalentMethod) {
>> + Decl *ToM1;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { void x(); }; void A::x() { }", Lang_CXX,
>> "input0.cc");
>> + auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
>> + FromTU, functionDecl(hasName("x"), isDefinition()));
>> + ToM1 = Import(FromM, Lang_CXX);
>> + }
>> + Decl *ToM2;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { void x(); }; void A::x() { }", Lang_CXX,
>> "input1.cc");
>> + auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
>> + FromTU, functionDecl(hasName("x"), isDefinition()));
>> + ToM2 = Import(FromM, Lang_CXX);
>> + }
>> + EXPECT_EQ(ToM1, ToM2);
>> +}
>> +
>> +TEST_P(ASTImporterTestBase, ImportOfNonEquivalentMethod) {
>> + Decl *ToM1;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { void x(); }; void A::x() { }",
>> + Lang_CXX, "input0.cc");
>> + auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
>> + FromTU, functionDecl(hasName("x"), isDefinition()));
>> + ToM1 = Import(FromM, Lang_CXX);
>> + }
>> + Decl *ToM2;
>> + {
>> + Decl *FromTU = getTuDecl(
>> + "struct A { void x() const; }; void A::x() const { }",
>> + Lang_CXX, "input1.cc");
>> + auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
>> + FromTU, functionDecl(hasName("x"), isDefinition()));
>> + ToM2 = Import(FromM, Lang_CXX);
>> + }
>> + EXPECT_NE(ToM1, ToM2);
>> +}
>> +
>> struct DeclContextTest : ASTImporterTestBase {};
>>
>> TEST_P(DeclContextTest, removeDeclOfClassTemplateSpecialization) {
>>
>> Modified: cfe/trunk/unittests/AST/StructuralEquivalenceTest.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/AST/StructuralEquivalenceTest.cpp?rev=336776&r1=336775&r2=336776&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/unittests/AST/StructuralEquivalenceTest.cpp (original)
>> +++ cfe/trunk/unittests/AST/StructuralEquivalenceTest.cpp Wed Jul 11
>> 02:37:24 2018
>> @@ -18,13 +18,13 @@ struct StructuralEquivalenceTest : ::tes
>> std::unique_ptr<ASTUnit> AST0, AST1;
>> std::string Code0, Code1; // Buffers for SourceManager
>>
>> - // Get a pair of Decl pointers to the synthetised declarations from
>> the given
>> - // code snipets. By default we search for the unique Decl with name
>> 'foo' in
>> - // both snippets.
>> - std::tuple<NamedDecl *, NamedDecl *>
>> - makeNamedDecls(const std::string &SrcCode0, const std::string
>> &SrcCode1,
>> - Language Lang, const char *const Identifier = "foo") {
>> -
>> + // Get a pair of node pointers into the synthesized AST from the given
>> code
>> + // snippets. To determine the returned node, a separate matcher is
>> specified
>> + // for both snippets. The first matching node is returned.
>> + template <typename NodeType, typename MatcherType>
>> + std::tuple<NodeType *, NodeType *> makeDecls(
>> + const std::string &SrcCode0, const std::string &SrcCode1, Language
>> Lang,
>> + const MatcherType &Matcher0, const MatcherType &Matcher1) {
>> this->Code0 = SrcCode0;
>> this->Code1 = SrcCode1;
>> ArgVector Args = getBasicRunOptionsForLanguage(Lang);
>> @@ -34,30 +34,34 @@ struct StructuralEquivalenceTest : ::tes
>> AST0 = tooling::buildASTFromCodeWithArgs(Code0, Args, InputFileName);
>> AST1 = tooling::buildASTFromCodeWithArgs(Code1, Args, InputFileName);
>>
>> - ASTContext &Ctx0 = AST0->getASTContext(), &Ctx1 =
>> AST1->getASTContext();
>> + NodeType *D0 = FirstDeclMatcher<NodeType>().match(
>> + AST0->getASTContext().getTranslationUnitDecl(), Matcher0);
>> + NodeType *D1 = FirstDeclMatcher<NodeType>().match(
>> + AST1->getASTContext().getTranslationUnitDecl(), Matcher1);
>>
>> - auto getDecl = [](ASTContext &Ctx, const std::string &Name) ->
>> NamedDecl * {
>> - IdentifierInfo *SearchedII = &Ctx.Idents.get(Name);
>> - assert(SearchedII && "Declaration with the identifier "
>> - "should be specified in test!");
>> - DeclarationName SearchDeclName(SearchedII);
>> - SmallVector<NamedDecl *, 4> FoundDecls;
>> - Ctx.getTranslationUnitDecl()->localUncachedLookup(SearchDeclName,
>> - FoundDecls);
>> -
>> - // We should find one Decl but one only.
>> - assert(FoundDecls.size() == 1);
>> -
>> - return FoundDecls[0];
>> - };
>> -
>> - NamedDecl *D0 = getDecl(Ctx0, Identifier);
>> - NamedDecl *D1 = getDecl(Ctx1, Identifier);
>> - assert(D0);
>> - assert(D1);
>> return std::make_tuple(D0, D1);
>> }
>>
>> + // Get a pair of node pointers into the synthesized AST from the given
>> code
>> + // snippets. The same matcher is used for both snippets.
>> + template <typename NodeType, typename MatcherType>
>> + std::tuple<NodeType *, NodeType *> makeDecls(
>> + const std::string &SrcCode0, const std::string &SrcCode1, Language
>> Lang,
>> + const MatcherType &AMatcher) {
>> + return makeDecls<NodeType, MatcherType>(
>> + SrcCode0, SrcCode1, Lang, AMatcher, AMatcher);
>> + }
>> +
>> + // Get a pair of Decl pointers to the synthesized declarations from
>> the given
>> + // code snippets. We search for the first NamedDecl with given name in
>> both
>> + // snippets.
>> + std::tuple<NamedDecl *, NamedDecl *> makeNamedDecls(
>> + const std::string &SrcCode0, const std::string &SrcCode1,
>> + Language Lang, const char *const Identifier = "foo") {
>> + auto Matcher = namedDecl(hasName(Identifier));
>> + return makeDecls<NamedDecl>(SrcCode0, SrcCode1, Lang, Matcher);
>> + }
>> +
>> bool testStructuralMatch(NamedDecl *D0, NamedDecl *D1) {
>> llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls;
>> StructuralEquivalenceContext Ctx(D0->getASTContext(),
>> D1->getASTContext(),
>> @@ -110,35 +114,29 @@ TEST_F(StructuralEquivalenceTest, CharVs
>> }
>>
>> TEST_F(StructuralEquivalenceTest, IntVsSignedIntTemplateSpec) {
>> - auto Decls = makeNamedDecls(
>> - "template <class T> struct foo; template<> struct foo<int>{};",
>> - "template <class T> struct foo; template<> struct foo<signed
>> int>{};",
>> - Lang_CXX);
>> - ClassTemplateSpecializationDecl *Spec0 =
>> - *cast<ClassTemplateDecl>(get<0>(Decls))->spec_begin();
>> - ClassTemplateSpecializationDecl *Spec1 =
>> - *cast<ClassTemplateDecl>(get<1>(Decls))->spec_begin();
>> - ASSERT_TRUE(Spec0 != nullptr);
>> - ASSERT_TRUE(Spec1 != nullptr);
>> + auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
>> + R"(template <class T> struct foo; template<> struct foo<int>{};)",
>> + R"(template <class T> struct foo; template<> struct foo<signed
>> int>{};)",
>> + Lang_CXX,
>> + classTemplateSpecializationDecl());
>> + auto Spec0 = get<0>(Decls);
>> + auto Spec1 = get<1>(Decls);
>> EXPECT_TRUE(testStructuralMatch(Spec0, Spec1));
>> }
>>
>> TEST_F(StructuralEquivalenceTest, CharVsSignedCharTemplateSpec) {
>> - auto Decls = makeNamedDecls(
>> - "template <class T> struct foo; template<> struct foo<char>{};",
>> - "template <class T> struct foo; template<> struct foo<signed
>> char>{};",
>> - Lang_CXX);
>> - ClassTemplateSpecializationDecl *Spec0 =
>> - *cast<ClassTemplateDecl>(get<0>(Decls))->spec_begin();
>> - ClassTemplateSpecializationDecl *Spec1 =
>> - *cast<ClassTemplateDecl>(get<1>(Decls))->spec_begin();
>> - ASSERT_TRUE(Spec0 != nullptr);
>> - ASSERT_TRUE(Spec1 != nullptr);
>> + auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
>> + R"(template <class T> struct foo; template<> struct foo<char>{};)",
>> + R"(template <class T> struct foo; template<> struct foo<signed
>> char>{};)",
>> + Lang_CXX,
>> + classTemplateSpecializationDecl());
>> + auto Spec0 = get<0>(Decls);
>> + auto Spec1 = get<1>(Decls);
>> EXPECT_FALSE(testStructuralMatch(Spec0, Spec1));
>> }
>>
>> TEST_F(StructuralEquivalenceTest,
>> CharVsSignedCharTemplateSpecWithInheritance) {
>> - auto Decls = makeNamedDecls(
>> + auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
>> R"(
>> struct true_type{};
>> template <class T> struct foo;
>> @@ -149,14 +147,9 @@ TEST_F(StructuralEquivalenceTest, CharVs
>> template <class T> struct foo;
>> template<> struct foo<signed char> : true_type {};
>> )",
>> - Lang_CXX);
>> - ClassTemplateSpecializationDecl *Spec0 =
>> - *cast<ClassTemplateDecl>(get<0>(Decls))->spec_begin();
>> - ClassTemplateSpecializationDecl *Spec1 =
>> - *cast<ClassTemplateDecl>(get<1>(Decls))->spec_begin();
>> - ASSERT_TRUE(Spec0 != nullptr);
>> - ASSERT_TRUE(Spec1 != nullptr);
>> - EXPECT_FALSE(testStructuralMatch(Spec0, Spec1));
>> + Lang_CXX,
>> + classTemplateSpecializationDecl());
>> + EXPECT_FALSE(testStructuralMatch(Decls));
>> }
>>
>> // This test is disabled for now.
>> @@ -203,5 +196,350 @@ TEST_F(StructuralEquivalenceTest, WrongO
>> EXPECT_FALSE(testStructuralMatch(Decls));
>> }
>>
>> +struct StructuralEquivalenceFunctionTest : StructuralEquivalenceTest {
>> +};
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ParamConstWithRef) {
>> + auto t = makeNamedDecls("void foo(int&);",
>> + "void foo(const int&);", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ParamConstSimple) {
>> + auto t = makeNamedDecls("void foo(int);",
>> + "void foo(const int);", Lang_CXX);
>> + EXPECT_TRUE(testStructuralMatch(t));
>> + // consider this OK
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, Throw) {
>> + auto t = makeNamedDecls("void foo();",
>> + "void foo() throw();", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, Noexcept) {
>> + auto t = makeNamedDecls("void foo();",
>> + "void foo() noexcept;", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ThrowVsNoexcept) {
>> + auto t = makeNamedDecls("void foo() throw();",
>> + "void foo() noexcept;", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ThrowVsNoexceptFalse) {
>> + auto t = makeNamedDecls("void foo() throw();",
>> + "void foo() noexcept(false);", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ThrowVsNoexceptTrue) {
>> + auto t = makeNamedDecls("void foo() throw();",
>> + "void foo() noexcept(true);", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, DISABLED_NoexceptNonMatch) {
>> + // The expression is not checked yet.
>> + auto t = makeNamedDecls("void foo() noexcept(false);",
>> + "void foo() noexcept(true);", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, NoexceptMatch) {
>> + auto t = makeNamedDecls("void foo() noexcept(false);",
>> + "void foo() noexcept(false);", Lang_CXX11);
>> + EXPECT_TRUE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, NoexceptVsNoexceptFalse) {
>> + auto t = makeNamedDecls("void foo() noexcept;",
>> + "void foo() noexcept(false);", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, NoexceptVsNoexceptTrue) {
>> + auto t = makeNamedDecls("void foo() noexcept;",
>> + "void foo() noexcept(true);", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ReturnType) {
>> + auto t = makeNamedDecls("char foo();",
>> + "int foo();", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ReturnConst) {
>> + auto t = makeNamedDecls("char foo();",
>> + "const char foo();", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ReturnRef) {
>> + auto t = makeNamedDecls("char &foo();",
>> + "char &&foo();", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ParamCount) {
>> + auto t = makeNamedDecls("void foo(int);",
>> + "void foo(int, int);", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ParamType) {
>> + auto t = makeNamedDecls("void foo(int);",
>> + "void foo(char);", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ParamName) {
>> + auto t = makeNamedDecls("void foo(int a);",
>> + "void foo(int b);", Lang_CXX);
>> + EXPECT_TRUE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, Variadic) {
>> + auto t = makeNamedDecls("void foo(int x...);",
>> + "void foo(int x);", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, ParamPtr) {
>> + auto t = makeNamedDecls("void foo(int *);",
>> + "void foo(int);", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, NameInParen) {
>> + auto t = makeNamedDecls(
>> + "void ((foo))();",
>> + "void foo();",
>> + Lang_CXX);
>> + EXPECT_TRUE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, NameInParenWithExceptionSpec) {
>> + auto t = makeNamedDecls(
>> + "void (foo)() throw(int);",
>> + "void (foo)() noexcept;",
>> + Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceFunctionTest, NameInParenWithConst) {
>> + auto t = makeNamedDecls(
>> + "struct A { void (foo)() const; };",
>> + "struct A { void (foo)(); };",
>> + Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +struct StructuralEquivalenceCXXMethodTest : StructuralEquivalenceTest {
>> +};
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Virtual) {
>> + auto t = makeDecls<CXXMethodDecl>(
>> + "struct X { void foo(); };",
>> + "struct X { virtual void foo(); };", Lang_CXX,
>> + cxxMethodDecl(hasName("foo")));
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Pure) {
>> + auto t = makeNamedDecls("struct X { virtual void foo(); };",
>> + "struct X { virtual void foo() = 0; };",
>> Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, DISABLED_Final) {
>> + // The final-ness is not checked yet.
>> + auto t = makeNamedDecls("struct X { virtual void foo(); };",
>> + "struct X { virtual void foo() final; };",
>> Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Const) {
>> + auto t = makeNamedDecls("struct X { void foo(); };",
>> + "struct X { void foo() const; };", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Static) {
>> + auto t = makeNamedDecls("struct X { void foo(); };",
>> + "struct X { static void foo(); };", Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Ref1) {
>> + auto t = makeNamedDecls("struct X { void foo(); };",
>> + "struct X { void foo() &&; };", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Ref2) {
>> + auto t = makeNamedDecls("struct X { void foo() &; };",
>> + "struct X { void foo() &&; };", Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, AccessSpecifier) {
>> + auto t = makeDecls<CXXMethodDecl>(
>> + "struct X { public: void foo(); };",
>> + "struct X { private: void foo(); };", Lang_CXX,
>> + cxxMethodDecl(hasName("foo")));
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Delete) {
>> + auto t = makeNamedDecls("struct X { void foo(); };",
>> + "struct X { void foo() = delete; };",
>> Lang_CXX11);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Constructor) {
>> + auto t = makeDecls<FunctionDecl>(
>> + "void foo();", "struct foo { foo(); };", Lang_CXX,
>> + functionDecl(), cxxConstructorDecl());
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, ConstructorParam) {
>> + auto t = makeDecls<CXXConstructorDecl>("struct X { X(); };",
>> + "struct X { X(int); };",
>> Lang_CXX,
>> + cxxConstructorDecl());
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, ConstructorExplicit) {
>> + auto t = makeDecls<CXXConstructorDecl>("struct X { X(int); };",
>> + "struct X { explicit X(int);
>> };",
>> + Lang_CXX11,
>> + cxxConstructorDecl());
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, ConstructorDefault) {
>> + auto t = makeDecls<CXXConstructorDecl>("struct X { X(); };",
>> + "struct X { X() = default; };",
>> + Lang_CXX11,
>> + cxxConstructorDecl());
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Conversion) {
>> + auto t = makeDecls<CXXConversionDecl>("struct X { operator bool(); };",
>> + "struct X { operator char(); };",
>> + Lang_CXX11,
>> + cxxConversionDecl());
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, Operator) {
>> + auto t = makeDecls<FunctionDecl>(
>> + "struct X { int operator +(int); };",
>> + "struct X { int operator -(int); };", Lang_CXX,
>> + functionDecl(hasOverloadedOperatorName("+")),
>> + functionDecl(hasOverloadedOperatorName("-")));
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, OutOfClass1) {
>> + auto t = makeDecls<FunctionDecl>(
>> + "struct X { virtual void f(); }; void X::f() { }",
>> + "struct X { virtual void f() { }; };",
>> + Lang_CXX,
>> + functionDecl(allOf(hasName("f"), isDefinition())));
>> + EXPECT_TRUE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceCXXMethodTest, OutOfClass2) {
>> + auto t = makeDecls<FunctionDecl>(
>> + "struct X { virtual void f(); }; void X::f() { }",
>> + "struct X { void f(); }; void X::f() { }",
>> + Lang_CXX,
>> + functionDecl(allOf(hasName("f"), isDefinition())));
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +struct StructuralEquivalenceRecordTest : StructuralEquivalenceTest {
>> +};
>> +
>> +TEST_F(StructuralEquivalenceRecordTest, Name) {
>> + auto t = makeDecls<CXXRecordDecl>(
>> + "struct A{ };",
>> + "struct B{ };",
>> + Lang_CXX,
>> + cxxRecordDecl());
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceRecordTest, Fields) {
>> + auto t = makeNamedDecls(
>> + "struct foo{ int x; };",
>> + "struct foo{ char x; };",
>> + Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceRecordTest, DISABLED_Methods) {
>> + // Currently, methods of a class are not checked at class equivalence.
>> + auto t = makeNamedDecls(
>> + "struct foo{ int x(); };",
>> + "struct foo{ char x(); };",
>> + Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceRecordTest, Bases) {
>> + auto t = makeNamedDecls(
>> + "struct A{ }; struct foo: A { };",
>> + "struct B{ }; struct foo: B { };",
>> + Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceRecordTest, InheritanceVirtual) {
>> + auto t = makeNamedDecls(
>> + "struct A{ }; struct foo: A { };",
>> + "struct A{ }; struct foo: virtual A { };",
>> + Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceRecordTest, DISABLED_InheritanceType) {
>> + // Access specifier in inheritance is not checked yet.
>> + auto t = makeNamedDecls(
>> + "struct A{ }; struct foo: public A { };",
>> + "struct A{ }; struct foo: private A { };",
>> + Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceRecordTest, Match) {
>> + auto Code = R"(
>> + struct A{ };
>> + struct B{ };
>> + struct foo: A, virtual B {
>> + void x();
>> + int a;
>> + };
>> + )";
>> + auto t = makeNamedDecls(Code, Code, Lang_CXX);
>> + EXPECT_TRUE(testStructuralMatch(t));
>> +}
>> +
>> +TEST_F(StructuralEquivalenceTest, CompareSameDeclWithMultiple) {
>> + auto t = makeNamedDecls(
>> + "struct A{ }; struct B{ }; void foo(A a, A b);",
>> + "struct A{ }; struct B{ }; void foo(A a, B b);",
>> + Lang_CXX);
>> + EXPECT_FALSE(testStructuralMatch(t));
>> +}
>> +
>> } // end namespace ast_matchers
>> } // end namespace clang
>>
>>
>> _______________________________________________
>> cfe-commits mailing list
>> cfe-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20180711/dfbe1e6d/attachment-0001.html>
More information about the cfe-commits
mailing list