[clang][ASTImporter] Add import of 'DependentSizedExtVectorType'

[danix800]

Summary

Add import of 'DependentSizedExtVectorType'.

Depends on https://reviews.llvm.org/D157237

[danix800]

Apply git-clang-format

[balazske]

ASTImporter part looks good, I did not check the generated documentation for correctness.

[danix800]

In D157238#4565051, @balazske wrote:

ASTImporter part looks good, I did not check the generated documentation for correctness.

Matcher part will be committed in https://reviews.llvm.org/D157237, these code is added here only to support this revision.

[balazske]

In D157238#4565260, @danix800 wrote:

In D157238#4565051, @balazske wrote:

ASTImporter part looks good, I did not check the generated documentation for correctness.

Matcher part will be committed in https://reviews.llvm.org/D157237, these code is added here only to support this revision.

It is possible to add D157237 as parent revision (and upload code here without changes in D157237). It is more safe to have the exact same code in the review that will be committed.

[danix800]

Cleanup since D157237 is landed.

[danix800]

In D157238#4565442, @balazske wrote:

In D157238#4565260, @danix800 wrote:

In D157238#4565051, @balazske wrote:

ASTImporter part looks good, I did not check the generated documentation for correctness.

Matcher part will be committed in https://reviews.llvm.org/D157237, these code is added here only to support this revision.

It is possible to add D157237 as parent revision (and upload code here without changes in D157237). It is more safe to have the exact same code in the review that will be committed.

This revision is cleaned up since D157237 is already landed. For future revison I'll try these techniques to reduce reviewing burden. Thanks for reminding.

clang/lib/AST/ASTImporter.cpp

public:
     ExpectedType VisitBlockPointerType(const BlockPointerType *T);
     ExpectedType VisitLValueReferenceType(const LValueReferenceType *T);
     ExpectedType VisitRValueReferenceType(const RValueReferenceType *T);
     ExpectedType VisitMemberPointerType(const MemberPointerType *T);
     ExpectedType VisitConstantArrayType(const ConstantArrayType *T);
     ExpectedType VisitIncompleteArrayType(const IncompleteArrayType *T);
     ExpectedType VisitVariableArrayType(const VariableArrayType *T);
     ExpectedType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
-    // FIXME: DependentSizedExtVectorType
+    ExpectedType
+    VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T);
     ExpectedType VisitVectorType(const VectorType *T);
     ExpectedType VisitExtVectorType(const ExtVectorType *T);
     ExpectedType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
     ExpectedType VisitFunctionProtoType(const FunctionProtoType *T);
     ExpectedType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
     ExpectedType VisitParenType(const ParenType *T);
     ExpectedType VisitTypedefType(const TypedefType *T);
     ExpectedType VisitTypeOfExprType(const TypeOfExprType *T);
ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
   // SizeExpr may be null if size is not specified directly.
   // For example, 'int a[]'.
 
   return Importer.getToContext().getDependentSizedArrayType(
       ToElementType, ToSizeExpr, T->getSizeModifier(),
       T->getIndexTypeCVRQualifiers(), ToBracketsRange);
 }
 
+ExpectedType ASTNodeImporter::VisitDependentSizedExtVectorType(
+    const DependentSizedExtVectorType *T) {
+  Error Err = Error::success();
+  QualType ToElementType = importChecked(Err, T->getElementType());
+  Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
+  SourceLocation ToAttrLoc = importChecked(Err, T->getAttributeLoc());
+  if (Err)
+    return std::move(Err);
+  return Importer.getToContext().getDependentSizedExtVectorType(
+      ToElementType, ToSizeExpr, ToAttrLoc);
+}
+
 ExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) {
   ExpectedType ToElementTypeOrErr = import(T->getElementType());
   if (!ToElementTypeOrErr)
     return ToElementTypeOrErr.takeError();
 
   return Importer.getToContext().getVectorType(*ToElementTypeOrErr,
                                                T->getNumElements(),
                                                T->getVectorKind());

clang/unittests/AST/ASTImporterFixtures.h

testImport(const std::string &FromCode,
 
     ASTContext &FromCtx = FromAST->getASTContext(),
                &ToCtx = ToAST->getASTContext();
 
     ASTImporter Importer(ToCtx, ToAST->getFileManager(), FromCtx,
                          FromAST->getFileManager(), false);
 
     auto FoundNodes = match(SearchMatcher, FromCtx);
+    if (FoundNodes.empty())
+      return testing::AssertionFailure() << "No node was found!";
     if (FoundNodes.size() != 1)
       return testing::AssertionFailure()
              << "Multiple potential nodes were found!";
 
     auto ToImport = selectFirst<NodeType>(DeclToImportID, FoundNodes);
     if (!ToImport)
       return testing::AssertionFailure() << "Node type mismatch!";
 

clang/unittests/AST/ASTImporterTest.cpp

TEST_P(ImportExpr, DependentSizedArrayType) {
   testImport("template<typename T, int Size> class declToImport {"
              "  T data[Size];"
              "};",
              Lang_CXX03, "", Lang_CXX03, Verifier,
              classTemplateDecl(has(cxxRecordDecl(
                  has(fieldDecl(hasType(dependentSizedArrayType())))))));
 }
 
+TEST_P(ImportExpr, DependentSizedExtVectorType) {
+  MatchVerifier<Decl> Verifier;
+  testImport("template<typename T, int Size>"
+             "class declToImport {"
+             "  typedef T __attribute__((ext_vector_type(Size))) type;"
+             "};",
+             Lang_CXX03, "", Lang_CXX03, Verifier,
+             classTemplateDecl(has(cxxRecordDecl(
+                 has(typedefDecl(hasType(dependentSizedExtVectorType())))))));
+}
+
 TEST_P(ASTImporterOptionSpecificTestBase, ImportUsingPackDecl) {
   Decl *FromTU = getTuDecl(
       "struct A { int operator()() { return 1; } };"
       "struct B { int operator()() { return 2; } };"
       "template<typename ...T> struct C : T... { using T::operator()...; };"
       "C<A, B> Var;",
       Lang_CXX20);