balazske created this revision.
Herald added subscribers: whisperity, martong, teemperor, gamesh411, Szelethus,
dkrupp.
Herald added a reviewer: a.sidorin.
Herald added a reviewer: shafik.
balazske requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
Import of Attr objects was incomplete in ASTImporter.
This change introduces support for a generic way of importing an attribute.
For an usage example import of the attribute AssertCapability is
added to ASTImporter.
Updating the old attribute import code and adding new attributes or extending
the generic functions (if needed) is future work.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D109608
Files:
clang/lib/AST/ASTImporter.cpp
clang/unittests/AST/ASTImporterTest.cpp
Index: clang/unittests/AST/ASTImporterTest.cpp
===================================================================
--- clang/unittests/AST/ASTImporterTest.cpp
+++ clang/unittests/AST/ASTImporterTest.cpp
@@ -6406,6 +6406,82 @@
ToSM.getBufferOrFake(ImportedID, SourceLocation()).getBuffer());
}
+struct ImportAttributes : public ASTImporterOptionSpecificTestBase {
+ void checkAttrImportCommon(const Attr *From, const Attr *To,
+ const Decl *ToD) {
+
+ // Verify that dump does not crash because invalid data.
+ ToD->dump();
+
+ EXPECT_EQ(From->getParsedKind(), To->getParsedKind());
+ EXPECT_EQ(From->getSyntax(), To->getSyntax());
+ if (From->getAttrName()) {
+ EXPECT_TRUE(To->getAttrName());
+ EXPECT_STREQ(From->getAttrName()->getNameStart(),
+ To->getAttrName()->getNameStart());
+ } else {
+ EXPECT_FALSE(To->getAttrName());
+ }
+ if (From->getScopeName()) {
+ EXPECT_TRUE(To->getScopeName());
+ EXPECT_STREQ(From->getScopeName()->getNameStart(),
+ To->getScopeName()->getNameStart());
+ } else {
+ EXPECT_FALSE(To->getScopeName());
+ }
+ EXPECT_EQ(From->getSpellingListIndex(), To->getSpellingListIndex());
+ EXPECT_STREQ(From->getSpelling(), To->getSpelling());
+ EXPECT_EQ(From->isInherited(), To->isInherited());
+ EXPECT_EQ(From->isImplicit(), To->isImplicit());
+ EXPECT_EQ(From->isPackExpansion(), To->isPackExpansion());
+ EXPECT_EQ(From->isLateParsed(), To->isLateParsed());
+ }
+
+ template <class DT, class AT>
+ void importAttr(const char *Code, AT *&FromAttr, AT *&ToAttr) {
+ static_assert(std::is_base_of<Attr, AT>::value, "AT should be an Attr");
+ static_assert(std::is_base_of<Decl, DT>::value, "DT should be a Decl");
+
+ Decl *FromTU = getTuDecl(Code, Lang_CXX11, "input.cc");
+ DT *FromD =
+ FirstDeclMatcher<DT>().match(FromTU, namedDecl(hasName("test")));
+ ASSERT_TRUE(FromD);
+
+ DT *ToD = Import(FromD, Lang_CXX11);
+ ASSERT_TRUE(ToD);
+
+ FromAttr = FromD->template getAttr<AT>();
+ ToAttr = ToD->template getAttr<AT>();
+ ASSERT_TRUE(FromAttr);
+ EXPECT_TRUE(ToAttr);
+
+ checkAttrImportCommon(FromAttr, ToAttr, ToD);
+ }
+
+ template <class T> void checkImported(const T *From, const T *To) {
+ EXPECT_TRUE(To);
+ EXPECT_NE(From, To);
+ }
+
+ template <class T>
+ void checkImportVariadicArg(const llvm::iterator_range<T **> &From,
+ const llvm::iterator_range<T **> &To) {
+ for (auto FromI = From.begin(), ToI = To.begin(); FromI != From.end();
+ ++FromI, ++ToI) {
+ ASSERT_NE(ToI, To.end());
+ checkImported(*FromI, *ToI);
+ }
+ }
+};
+
+template <>
+void ImportAttributes::checkImported<Decl>(const Decl *From, const Decl *To) {
+ EXPECT_TRUE(To);
+ EXPECT_NE(From, To);
+ EXPECT_EQ(To->getTranslationUnitDecl(),
+ ToAST->getASTContext().getTranslationUnitDecl());
+}
+
TEST_P(ASTImporterOptionSpecificTestBase, ImportExprOfAlignmentAttr) {
// Test if import of these packed and aligned attributes does not trigger an
// error situation where source location from 'From' context is referenced in
@@ -6466,6 +6542,17 @@
ToAttr->getAttributeSpellingListIndex());
EXPECT_EQ(FromAttr->getType()->getName(), ToAttr->getType()->getName());
}
+
+TEST_P(ImportAttributes, ImportAssertCapability) {
+ AssertCapabilityAttr *FromAttr, *ToAttr;
+ importAttr<FunctionDecl>(
+ R"(
+ void test(int A1, int A2) __attribute__((assert_capability(A1, A2)));
+ )",
+ FromAttr, ToAttr);
+ checkImportVariadicArg(FromAttr->args(), ToAttr->args());
+}
+
template <typename T>
auto ExtendWithOptions(const T &Values, const std::vector<std::string> &Args) {
auto Copy = Values;
@@ -6849,5 +6936,8 @@
INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportWithExternalSource,
DefaultTestValuesForRunOptions);
+INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportAttributes,
+ DefaultTestValuesForRunOptions);
+
} // end namespace ast_matchers
} // end namespace clang
Index: clang/lib/AST/ASTImporter.cpp
===================================================================
--- clang/lib/AST/ASTImporter.cpp
+++ clang/lib/AST/ASTImporter.cpp
@@ -186,22 +186,6 @@
return import(*From);
}
- // Helper for chaining together multiple imports. If an error is detected,
- // subsequent imports will return default constructed nodes, so that failure
- // can be detected with a single conditional branch after a sequence of
- // imports.
- template <typename T> T importChecked(Error &Err, const T &From) {
- // Don't attempt to import nodes if we hit an error earlier.
- if (Err)
- return T{};
- Expected<T> MaybeVal = import(From);
- if (!MaybeVal) {
- Err = MaybeVal.takeError();
- return T{};
- }
- return *MaybeVal;
- }
-
ExplicitSpecifier importExplicitSpecifier(Error &Err,
ExplicitSpecifier ESpec);
@@ -669,6 +653,22 @@
ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E);
+ // Helper for chaining together multiple imports. If an error is detected,
+ // subsequent imports will return default constructed nodes, so that failure
+ // can be detected with a single conditional branch after a sequence of
+ // imports.
+ template <typename T> T importChecked(Error &Err, const T &From) {
+ // Don't attempt to import nodes if we hit an error earlier.
+ if (Err)
+ return T{};
+ Expected<T> MaybeVal = import(From);
+ if (!MaybeVal) {
+ Err = MaybeVal.takeError();
+ return T{};
+ }
+ return *MaybeVal;
+ }
+
template<typename IIter, typename OIter>
Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
using ItemT = std::remove_reference_t<decltype(*Obegin)>;
@@ -707,6 +707,11 @@
// that type is declared inside the body of the function.
// E.g. auto f() { struct X{}; return X(); }
bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D);
+
+ /*template<typename T>
+ friend struct AttrArgImporter;
+ template<typename T>
+ friend struct AttrArgArrayImporter;*/
};
template <typename InContainerTy>
@@ -8408,8 +8413,91 @@
return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
}
+template <typename T> struct AttrArgImporter {
+ AttrArgImporter<T>(const AttrArgImporter<T> &) = delete;
+ AttrArgImporter<T>(AttrArgImporter<T> &&) = default;
+
+ T To;
+
+ AttrArgImporter(ASTNodeImporter &I, Error &Err, const T &From)
+ : To(I.importChecked(Err, From)) {}
+
+ const T &value() { return To; }
+};
+
+template <typename T> struct AttrArgArrayImporter {
+ AttrArgArrayImporter<T>(const AttrArgArrayImporter<T> &) = delete;
+ AttrArgArrayImporter<T>(AttrArgArrayImporter<T> &&) = default;
+
+ llvm::SmallVector<T, 2> To;
+
+ AttrArgArrayImporter(ASTNodeImporter &I, Error &Err,
+ const llvm::iterator_range<T *> &From,
+ unsigned ArraySize) {
+ if (Err) {
+ return;
+ } else {
+ To.reserve(ArraySize);
+ Err = I.ImportContainerChecked(From, To);
+ }
+ }
+
+ T *value() { return To.data(); }
+};
+
+class AttrImporter {
+ Error Err = Error::success();
+ ASTImporter &Importer;
+ ASTNodeImporter NImporter;
+
+public:
+ AttrImporter(ASTImporter &I) : Importer(I), NImporter(I) {}
+
+ template <class AT> AttrArgImporter<AT> importArg(const AT &From) {
+ return AttrArgImporter<AT>(NImporter, Err, From);
+ }
+
+ template <class AT>
+ AttrArgArrayImporter<AT>
+ importArrayArg(const llvm::iterator_range<AT *> &From, unsigned ArraySize) {
+ return AttrArgArrayImporter<AT>(NImporter, Err, From, ArraySize);
+ }
+
+ template <class T, typename... Arg>
+ Expected<Attr *> createImportedAttr(const T *FromAttr, Arg &&...ImportedArg) {
+ const IdentifierInfo *ToAttrName;
+ const IdentifierInfo *ToScopeName;
+ SourceRange ToAttrRange;
+ SourceLocation ToScopeLoc;
+
+ ToAttrName = Importer.Import(FromAttr->getAttrName());
+ ToScopeName = Importer.Import(FromAttr->getScopeName());
+ ToAttrRange = NImporter.importChecked(Err, FromAttr->getRange());
+ ToScopeLoc = NImporter.importChecked(Err, FromAttr->getScopeLoc());
+
+ if (Err)
+ return std::move(Err);
+
+ AttributeCommonInfo ToI(ToAttrName, ToScopeName, ToAttrRange, ToScopeLoc,
+ FromAttr->getParsedKind(), FromAttr->getSyntax(),
+ FromAttr->getAttributeSpellingListIndex());
+ T *ToAttr = T::Create(Importer.getToContext(), ImportedArg..., ToI);
+ // T *ToAttr = new (Importer.getToContext()) T(Importer.getToContext(), ToI,
+ // ImportedArg...);
+
+ ToAttr->setImplicit(FromAttr->isImplicit());
+ ToAttr->setPackExpansion(FromAttr->isPackExpansion());
+ if (auto *ToInheritableAttr = dyn_cast<InheritableAttr>(ToAttr))
+ ToInheritableAttr->setInherited(FromAttr->isInherited());
+
+ return ToAttr;
+ }
+};
+
Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
Attr *ToAttr = nullptr;
+ // FIXME: Use AttrImporter as much as possible, try to remove the import
+ // of range from here.
SourceRange ToRange;
if (Error Err = importInto(ToRange, FromAttr->getRange()))
return std::move(Err);
@@ -8451,6 +8539,20 @@
ToAttr = To;
break;
}
+
+ case attr::AssertCapability: {
+ const auto *From = cast<AssertCapabilityAttr>(FromAttr);
+ AttrImporter AI(*this);
+ Expected<Attr *> ToAttrOrErr = AI.createImportedAttr(
+ From, AI.importArrayArg(From->args(), From->args_size()).value(),
+ From->args_size());
+ if (ToAttrOrErr)
+ ToAttr = *ToAttrOrErr;
+ else
+ return ToAttrOrErr.takeError();
+ break;
+ }
+
default:
// FIXME: 'clone' copies every member but some of them should be imported.
// Handle other Attrs that have parameters that should be imported.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
