martong created this revision.
martong added reviewers: a.sidorin, xazax.hun, szepet.
Herald added subscribers: cfe-commits, dkrupp, rnkovacs, mgorny.
This patch add new tests for structural equivalence. For that a new common
header is created which holds the test related language specific types and
functions.
Repository:
rC Clang
https://reviews.llvm.org/D46867
Files:
unittests/AST/ASTImporterTest.cpp
unittests/AST/CMakeLists.txt
unittests/AST/Language.h
unittests/AST/MatchVerifier.h
unittests/AST/StructuralEquivalenceTest.cpp
Index: unittests/AST/StructuralEquivalenceTest.cpp
===================================================================
--- /dev/null
+++ unittests/AST/StructuralEquivalenceTest.cpp
@@ -0,0 +1,211 @@
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTImporter.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/AST/ASTStructuralEquivalence.h"
+#include "clang/Frontend/ASTUnit.h"
+#include "clang/Tooling/Tooling.h"
+
+#include "Language.h"
+#include "DeclMatcher.h"
+
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace ast_matchers {
+
+struct StructuralEquivalenceTest : ::testing::Test {
+ 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") {
+
+ this->Code0 = SrcCode0;
+ this->Code1 = SrcCode1;
+ ArgVector Args = getBasicRunOptionsForLanguage(Lang);
+
+ const char *const InputFileName = "input.cc";
+
+ AST0 = tooling::buildASTFromCodeWithArgs(Code0, Args, InputFileName);
+ AST1 = tooling::buildASTFromCodeWithArgs(Code1, Args, InputFileName);
+
+ ASTContext &Ctx0 = AST0->getASTContext(), &Ctx1 = AST1->getASTContext();
+
+ auto getDecl = [](ASTContext &Ctx, const std::string &Name) -> NamedDecl * {
+ IdentifierInfo *ImportedII = &Ctx.Idents.get(Name);
+ assert(ImportedII && "Declaration with the identifier "
+ "should be specified in test!");
+ DeclarationName ImportDeclName(ImportedII);
+ SmallVector<NamedDecl *, 4> FoundDecls;
+ Ctx.getTranslationUnitDecl()->localUncachedLookup(ImportDeclName,
+ FoundDecls);
+
+ // We should find one Decl but one only
+ assert(FoundDecls.size() > 0);
+ assert(FoundDecls.size() < 2);
+
+ return FoundDecls[0];
+ };
+
+ NamedDecl *d0 = getDecl(Ctx0, Identifier);
+ NamedDecl *d1 = getDecl(Ctx1, Identifier);
+ assert(d0);
+ assert(d1);
+ return std::make_tuple(d0, d1);
+ }
+
+ bool testStructuralMatch(NamedDecl *d0, NamedDecl *d1) {
+ llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls;
+ StructuralEquivalenceContext Ctx(d0->getASTContext(), d1->getASTContext(),
+ NonEquivalentDecls, false, false);
+ return Ctx.IsStructurallyEquivalent(d0, d1);
+ }
+};
+
+using std::get;
+
+TEST_F(StructuralEquivalenceTest, Int) {
+ auto t = makeNamedDecls("int foo;", "int foo;", Lang_CXX);
+ EXPECT_TRUE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+TEST_F(StructuralEquivalenceTest, IntVsSignedInt) {
+ auto t = makeNamedDecls("int foo;", "signed int foo;", Lang_CXX);
+ EXPECT_TRUE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+TEST_F(StructuralEquivalenceTest, Char) {
+ auto t = makeNamedDecls("char foo;", "char foo;", Lang_CXX);
+ EXPECT_TRUE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+// This test is disabled for now.
+// FIXME Whether this is equivalent is dependendant on the target.
+TEST_F(StructuralEquivalenceTest, DISABLED_CharVsSignedChar) {
+ auto t = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX);
+ EXPECT_FALSE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+TEST_F(StructuralEquivalenceTest, ForwardRecordDecl) {
+ auto t = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX);
+ EXPECT_TRUE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+TEST_F(StructuralEquivalenceTest, IntVsSignedIntInStruct) {
+ auto t = makeNamedDecls("struct foo { int x; };",
+ "struct foo { signed int x; };", Lang_CXX);
+ EXPECT_TRUE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+TEST_F(StructuralEquivalenceTest, CharVsSignedCharInStruct) {
+ auto t = makeNamedDecls("struct foo { char x; };",
+ "struct foo { signed char x; };", Lang_CXX);
+ EXPECT_FALSE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+TEST_F(StructuralEquivalenceTest, IntVsSignedIntTemplateSpec) {
+ auto t = 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>(t))->spec_begin();
+ ClassTemplateSpecializationDecl *Spec1 =
+ *cast<ClassTemplateDecl>(get<1>(t))->spec_begin();
+ ASSERT_TRUE(Spec0 != nullptr);
+ ASSERT_TRUE(Spec1 != nullptr);
+ EXPECT_TRUE(testStructuralMatch(Spec0, Spec1));
+}
+
+TEST_F(StructuralEquivalenceTest, CharVsSignedCharTemplateSpec) {
+ auto t = 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>(t))->spec_begin();
+ ClassTemplateSpecializationDecl *Spec1 =
+ *cast<ClassTemplateDecl>(get<1>(t))->spec_begin();
+ ASSERT_TRUE(Spec0 != nullptr);
+ ASSERT_TRUE(Spec1 != nullptr);
+ EXPECT_FALSE(testStructuralMatch(Spec0, Spec1));
+}
+
+TEST_F(StructuralEquivalenceTest, CharVsSignedCharTemplateSpecWithInheritance) {
+ auto t = makeNamedDecls(
+ R"(
+ struct true_type{};
+ template <class T> struct foo;
+ template<> struct foo<char> : true_type {};
+ )",
+ R"(
+ struct true_type{};
+ template <class T> struct foo;
+ template<> struct foo<signed char> : true_type {};
+ )",
+ Lang_CXX);
+ ClassTemplateSpecializationDecl *Spec0 =
+ *cast<ClassTemplateDecl>(get<0>(t))->spec_begin();
+ ClassTemplateSpecializationDecl *Spec1 =
+ *cast<ClassTemplateDecl>(get<1>(t))->spec_begin();
+ ASSERT_TRUE(Spec0 != nullptr);
+ ASSERT_TRUE(Spec1 != nullptr);
+ EXPECT_FALSE(testStructuralMatch(Spec0, Spec1));
+}
+
+// This test is disabled for now.
+// FIXME Enable it, once the check is implemented.
+TEST_F(StructuralEquivalenceTest, DISABLED_WrongOrderInNamespace) {
+ auto Code0 =
+ R"(
+ namespace NS {
+ template <class T> class Base {
+ int a;
+ };
+ class Derived : Base<Derived> {
+ };
+ }
+ void foo(NS::Derived &);
+ )";
+ auto t = makeNamedDecls( Code0, Code0, Lang_CXX);
+
+ ASSERT_TRUE(get<0>(t) != nullptr);
+ ASSERT_TRUE(get<1>(t) != nullptr);
+
+ NamespaceDecl *NS =
+ LastDeclMatcher<NamespaceDecl>().match(get<1>(t), namespaceDecl());
+ ClassTemplateDecl *TD = LastDeclMatcher<ClassTemplateDecl>().match(
+ get<1>(t), classTemplateDecl(hasName("Base")));
+
+ // Reorder the decls, move the TD to the last place in the DC.
+ NS->removeDecl(TD);
+ NS->addDeclInternal(TD);
+
+ EXPECT_FALSE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+TEST_F(StructuralEquivalenceTest, WrongOrderOfFieldsInClass) {
+ auto Code0 = "class X { int a; int b; };";
+ auto t = makeNamedDecls( Code0, Code0, Lang_CXX, "X");
+
+ ASSERT_TRUE(get<0>(t) != nullptr);
+ ASSERT_TRUE(get<1>(t) != nullptr);
+
+ CXXRecordDecl *RD = FirstDeclMatcher<CXXRecordDecl>().match(
+ get<1>(t), cxxRecordDecl(hasName("X")));
+ FieldDecl *FD =
+ FirstDeclMatcher<FieldDecl>().match(get<1>(t), fieldDecl(hasName("a")));
+
+ // Reorder the FieldDecls
+ RD->removeDecl(FD);
+ RD->addDeclInternal(FD);
+
+ EXPECT_FALSE(testStructuralMatch(get<0>(t), get<1>(t)));
+}
+
+} // end namespace ast_matchers
+} // end namespace clang
Index: unittests/AST/MatchVerifier.h
===================================================================
--- unittests/AST/MatchVerifier.h
+++ unittests/AST/MatchVerifier.h
@@ -23,20 +23,12 @@
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/Tooling.h"
+#include "Language.h"
#include "gtest/gtest.h"
namespace clang {
namespace ast_matchers {
-enum Language {
- Lang_C,
- Lang_C89,
- Lang_CXX,
- Lang_CXX11,
- Lang_OpenCL,
- Lang_OBJCXX
-};
-
/// \brief Base class for verifying some property of nodes found by a matcher.
template <typename NodeType>
class MatchVerifier : public MatchFinder::MatchCallback {
@@ -113,6 +105,10 @@
Args.push_back("-std=c++11");
FileName = "input.cc";
break;
+ case Lang_CXX14:
+ Args.push_back("-std=c++14");
+ FileName = "input.cc";
+ break;
case Lang_OpenCL:
FileName = "input.cl";
break;
Index: unittests/AST/Language.h
===================================================================
--- /dev/null
+++ unittests/AST/Language.h
@@ -0,0 +1,81 @@
+//===- unittest/AST/Language.h - AST unit test support ---------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_UNITTESTS_AST_LANGUAGE_H
+#define LLVM_CLANG_UNITTESTS_AST_LANGUAGE_H
+
+#include <vector>
+#include <string>
+#include "llvm/Support/ErrorHandling.h"
+
+namespace clang {
+namespace ast_matchers {
+
+typedef std::vector<std::string> ArgVector;
+typedef std::vector<ArgVector> RunOptions;
+
+enum Language {
+ Lang_C,
+ Lang_C89,
+ Lang_CXX,
+ Lang_CXX11,
+ Lang_CXX14,
+ Lang_OpenCL,
+ Lang_OBJCXX
+};
+
+inline bool isCXX(Language Lang) {
+ return Lang == Lang_CXX || Lang == Lang_CXX11 || Lang == Lang_CXX14;
+}
+
+inline ArgVector getBasicRunOptionsForLanguage(Language Lang) {
+ ArgVector BasicArgs;
+ // Test with basic arguments.
+ switch (Lang) {
+ case Lang_C:
+ BasicArgs = {"-x", "c", "-std=c99"};
+ break;
+ case Lang_C89:
+ BasicArgs = {"-x", "c", "-std=c89"};
+ break;
+ case Lang_CXX:
+ BasicArgs = {"-std=c++98", "-frtti"};
+ break;
+ case Lang_CXX11:
+ BasicArgs = {"-std=c++11", "-frtti"};
+ break;
+ case Lang_CXX14:
+ BasicArgs = {"-std=c++14", "-frtti"};
+ break;
+ case Lang_OpenCL:
+ case Lang_OBJCXX:
+ llvm_unreachable("Not implemented yet!");
+ }
+ return BasicArgs;
+}
+
+inline RunOptions getRunOptionsForLanguage(Language Lang) {
+ ArgVector BasicArgs = getBasicRunOptionsForLanguage(Lang);
+
+ // For C++, test with "-fdelayed-template-parsing" enabled to handle MSVC
+ // default behaviour.
+ if (isCXX(Lang)) {
+ ArgVector ArgsForDelayedTemplateParse = BasicArgs;
+ ArgsForDelayedTemplateParse.emplace_back("-fdelayed-template-parsing");
+ return {BasicArgs, ArgsForDelayedTemplateParse};
+ }
+
+ return {BasicArgs};
+}
+
+
+} // end namespace ast_matchers
+} // end namespace clang
+
+#endif
Index: unittests/AST/CMakeLists.txt
===================================================================
--- unittests/AST/CMakeLists.txt
+++ unittests/AST/CMakeLists.txt
@@ -17,6 +17,7 @@
NamedDeclPrinterTest.cpp
SourceLocationTest.cpp
StmtPrinterTest.cpp
+ StructuralEquivalenceTest.cpp
)
target_link_libraries(ASTTests
Index: unittests/AST/ASTImporterTest.cpp
===================================================================
--- unittests/AST/ASTImporterTest.cpp
+++ unittests/AST/ASTImporterTest.cpp
@@ -19,6 +19,7 @@
#include "clang/Tooling/Tooling.h"
#include "DeclMatcher.h"
+#include "Language.h"
#include "gtest/gtest.h"
#include "llvm/ADT/StringMap.h"
@@ -29,50 +30,6 @@
using internal::BindableMatcher;
using llvm::StringMap;
-typedef std::vector<std::string> ArgVector;
-typedef std::vector<ArgVector> RunOptions;
-
-static bool isCXX(Language Lang) {
- return Lang == Lang_CXX || Lang == Lang_CXX11;
-}
-
-static ArgVector getBasicRunOptionsForLanguage(Language Lang) {
- ArgVector BasicArgs;
- // Test with basic arguments.
- switch (Lang) {
- case Lang_C:
- BasicArgs = {"-x", "c", "-std=c99"};
- break;
- case Lang_C89:
- BasicArgs = {"-x", "c", "-std=c89"};
- break;
- case Lang_CXX:
- BasicArgs = {"-std=c++98", "-frtti"};
- break;
- case Lang_CXX11:
- BasicArgs = {"-std=c++11", "-frtti"};
- break;
- case Lang_OpenCL:
- case Lang_OBJCXX:
- llvm_unreachable("Not implemented yet!");
- }
- return BasicArgs;
-}
-
-static RunOptions getRunOptionsForLanguage(Language Lang) {
- ArgVector BasicArgs = getBasicRunOptionsForLanguage(Lang);
-
- // For C++, test with "-fdelayed-template-parsing" enabled to handle MSVC
- // default behaviour.
- if (isCXX(Lang)) {
- ArgVector ArgsForDelayedTemplateParse = BasicArgs;
- ArgsForDelayedTemplateParse.emplace_back("-fdelayed-template-parsing");
- return {BasicArgs, ArgsForDelayedTemplateParse};
- }
-
- return {BasicArgs};
-}
-
// Creates a virtual file and assigns that to the context of given AST. If the
// file already exists then the file will not be created again as a duplicate.
static void
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
