[ASTImporter] Added ability to import AtomicType nodes

[khazem]

Summary

This patch fixes an issue where attempting to import code containing atomic type declarations would result in the error "cannot import unsupported AST node Atomic".

[spyffe]

Looks good to me. Thanks, Kareem!

[khazem]

Thank you Sean! I've asked Petr Hosek to commit this change.

[xazax.hun]

Can he commit this? In case he is too busy, I can also commit this for you.

[khazem]

Thanks, Gábor! Please do commit this (it's currently Thanksgiving week in the US).

cfe/trunk/lib/AST/ASTImporter.cpp

public:
     explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
     
     using TypeVisitor<ASTNodeImporter, QualType>::Visit;
     using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
     using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
 
     // Importing types
     QualType VisitType(const Type *T);
+    QualType VisitAtomicType(const AtomicType *T);
     QualType VisitBuiltinType(const BuiltinType *T);
     QualType VisitDecayedType(const DecayedType *T);
     QualType VisitComplexType(const ComplexType *T);
     QualType VisitPointerType(const PointerType *T);
     QualType VisitBlockPointerType(const BlockPointerType *T);
     QualType VisitLValueReferenceType(const LValueReferenceType *T);
     QualType VisitRValueReferenceType(const RValueReferenceType *T);
     QualType VisitMemberPointerType(const MemberPointerType *T);

 //----------------------------------------------------------------------------
 
 QualType ASTNodeImporter::VisitType(const Type *T) {
   Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
     << T->getTypeClassName();
   return QualType();
 }
 
+QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
+  QualType UnderlyingType = Importer.Import(T->getValueType());
+  if(UnderlyingType.isNull())
+    return QualType();
+
+  return Importer.getToContext().getAtomicType(UnderlyingType);
+}
+
 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
   switch (T->getKind()) {
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   case BuiltinType::Id: \
     return Importer.getToContext().SingletonId;
 #include "clang/Basic/OpenCLImageTypes.def"
 #define SHARED_SINGLETON_TYPE(Expansion)
 #define BUILTIN_TYPE(Id, SingletonId) \

cfe/trunk/unittests/AST/ASTImporterTest.cpp

EXPECT_TRUE(
               compoundStmt(
                 has(
                   cStyleCastExpr(
                     hasSourceExpression(
                       vaArgExpr()))))))));
 }
 
 
+TEST(ImportType, ImportAtomicType) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(testImport("void declToImport() { typedef _Atomic(int) a_int; }",
+                         Lang_CXX11, "", Lang_CXX11, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 declStmt(
+                                   has(
+                                     typedefDecl(
+                                       has(atomicType()))))))))));
+}
+
+
 } // end namespace ast_matchers
 } // end namespace clang