ASTImporter: expressions, pt.1

[a.sidorin]

Summary

This patch implements some expression-related AST node import. This is the first patch in a series.
http://reviews.llvm.org/D14224 was also partially used.

• Introduce ASTImporter unit test framework
• Support new node kinds:

InjectedClassNameType
TemplateTypeParmType
LabelDecl
GCCAsmStmt
VAArgExpr
GNUNullExpr
PredefinedExpr
InitListExpr
ImplicitValueInitExpr
DesignatedInitExpr
CXXNullPtrLiteralExpr
CXXBoolLiteralExpr
FloatingLiteral
StringLiteral
CompoundLiteralExpr
AtomicExpr
AddrLabelExpr
ParenListExpr
StmtExpr
ConditionalOperator
BinaryConditionalOperator
OpaqueValueExpr
CXXThisExpr

[sepavloff]

The fix must contain tests.

lib/AST/ASTImporter.cpp

35 ↗

(On Diff #39064)

A name started with underscore is a reserved identifier (see C++ standard, [global.names]), so it is better to use something more neutral, like TheImporter or Imp or something else.

43 ↗

(On Diff #39064)

I would propose more descriptive name like containsNullptr and move it into anonymous namespace, or maybe eliminated this function at all, and use std::find directly.

48 ↗

(On Diff #39064)

This function is used in one place only, maybe inline its body in that place?

4642 ↗

(On Diff #39064)

Check for S->getOutputIdentifier(i) seems redundant, output name cannot be omitted in asm statement.

4648 ↗

(On Diff #39064)

Same as above.

4655 ↗

(On Diff #39064)

Again, clobber cannot be null, maybe cast instead of cast_or_null?

4664 ↗

(On Diff #39064)

cast_or_null -> cast?

4672 ↗

(On Diff #39064)

cast_or_null -> cast?

4693 ↗

(On Diff #39064)

cast_or_null -> cast?

5248 ↗

(On Diff #39064)

Check for ILE->getArrayFiller() is useless, as in this branch ILE->hasArrayFiller() is true.

5253–5257 ↗

(On Diff #39064)

Call to setInitializedFieldInUnion will always set type of respective union to declaration, so if it contained an expression, it will be lost. The safer solution is to check the kind of the source union and import either declaration or expression depending on the result.

5301 ↗

(On Diff #39064)

According to LLVM coding standard variable names must start with upper case letter, so i -> I, e->E.

[a.sidorin]

Thank you for your comments. I leaved some replies and will update revision.
Something about lacking tests.

1. We cannot check if expression import is correct until we implement FunctionDecl body import. I was going to upstream Decl-related parts later but maybe it is better to include this small case in the first patch. What do you think?
2. What is the best way to test import of statements? Currently I have no idea how to do this (except of ast-dump). Any suggestions are welcome.

lib/AST/ASTImporter.cpp

35 ↗

(On Diff #39064)

Ouch. I was just trying to unify this with the code already existing in ASTImporter. I'll rename this.
// TODO: refactor std::transform usage in ASTImporter.

48 ↗

(On Diff #39064)

I'll use it in later patches so I'd prefer to keep it.

4655 ↗

(On Diff #39064)

This guard is here because the return result of import may be null. This cast_or_null (and some others) handles such cases.

[a.sidorin]

Some issues pointed on review were fixed.

[a.sidorin]

Seems like I have found a way to test ASTImporter. What about some unit-tests? A sample test using AST matcher is attached. If it is OK, I'll write more tests with it.

[a.sidorin]

Add language-related arguments for compilation.

[sepavloff]

Unit test, of course, checks import facility but i would say this is overkill. You need to create tests for all nodes you implement in imported, this is huge amount of work.

I would propose you to move tests from http://reviews.llvm.org/D14224 for nodes that are implemented there, for remaining nodes create short functions, that have respective node in the body, similar to what is done in D14224. Such test checks that the node is handled in Importer. For regression test it must be enough. More rigorous check must can be done in runtime, or in constexpr function, for some nodes. Unfortunately it looks like constexpr attribute is not preserved correctly by the importer class, so we have no choice here.

[a.sidorin]

I understand your position. However, we cannot check that we don't import BreakStmt as ContinueStmt using just ASTMerge without any verification. As I understand, unit tests is what we need because we need to check that the overall imported type/expression is correct. And I think that we really need to create tests for all nodes with import implemented since that is a target of tests (yes, it can take some time, but I think it is strictly required). With static_assert we can perform only a limited amount of checks so I decided to use ASTMatchers.
But I think I can just use both approaches: I may use your tests and keep this unit test framework as well to perform more strict checks.

[sepavloff]

If you are going to make unit tests, consider alternative approach also. In repository test-suite the directory SingleSource/UnitTests contains runtime tests obtained from single file. You could modify Makefile that runs these tests in such a way that each test runs twice, one as now it runs and the other would run through the sequence compile to ast - compile empty source with with ast-import. Tests for missing nodes could be added into SingleSource/UnitTests, they would be substantially simpler that those using ASTMatchers. More importantly, such tests would make indeed exhaustive testing of importer.

[a.sidorin]

Add AST matcher-based unit tests; add some additional nodes to pass the tests.

[a.sidorin]

Serge Pavlov: I'll enable tests from you patch (http://reviews.llvm.org/D14224) after all node types your patch supports will be supported. If you're agree, of course.

[a.sidorin]

Serge: Sorry, that's because I forgot to add a dependence. There should be a patch implementing these matchers.

[sepavloff]

I still cannot build project with your changes, now compiler cannot find symbol hasSubStmt. When committing the change please make sure that all prerequisites are committed and unit tests run successfully.

I would recommend you to take tests from D14224 for literals. They check imported values as well, not only syntax structure. It is however only a recommendation.

There is no tests for InjectedClassNameType, TemplateTypeParmType, GCCAsmStmt, VAArgExpr and CXXBoolLiteralExpr. Probably these nodes may be moved to next code change?

Provided that the aforementioned nodes get tests of are moved to another change, the patch looks good for me. I do not have authority to approve patches for commit, you need to ask someone with proper rights for the approval.

Thank you!

lib/AST/ASTImporter.cpp

1827–1828 ↗

(On Diff #48487)

Definition of ASTContext::getInjectedClassNameType does not contain comments that would explain why it is unsuitable, so this comment is confusing. Probably you wanted to reference ASTReader::readTypeRecord, it contains similar statement.

4379 ↗

(On Diff #48487)

Comments should be proper English sentences. In this case ending period is missed.

4730 ↗

(On Diff #48487)

According to LLVM coding style (http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly) variable names 'should be camel case, and start with an upper case letter', so i -> I, e -> E.

unittests/AST/ASTImporterTest.cpp

117 ↗

(On Diff #48487)

Disadvantage of using matchers, apart of complexity, is that they check only syntax structure. This test does not check if imported literal has proper value.

[a.sidorin]

Stylish fixes.

Serge: ASTMatcher review is complete so there should be no more build problems. Could you try again?
Also, I'd prefer to add your changes in the next patch, without splitting. About missing tests: they are planned in later patches too.

[a.sidorin]

Serge: BTW, tests for CXXBoolLiteralExpr are presented in this patch. There is no test exactly for it but at least one test uses bool literal and matches it successfully with cxxBoolLiteral() matcher.

[sepavloff]

On Windows (VS2015 update1) two unit tests fail:

[ RUN      ] ImportExpr.ImportGNUNullExpr
input.cc:1:23: warning: expression result unused [-Wunused-value]
void declToImport() { __null; }
                      ^~~~~~
G:\arbeit\llvm2\llvm\tools\clang\unittests\AST\ASTImporterTest.cpp(149):
error: Value of: testImport("void declToImport() { __null; }", Lang_CXX,
"", Lang_CXX,
Verifier, functionDecl( hasBody( compoundStmt( has( gnuNullExpr( hasType(
asString("long"))))))))
  Actual: false (Could not find match)
Expected: true
[  FAILED  ] ImportExpr.ImportGNUNullExpr (61 ms)

[ RUN      ] ImportExpr.ImportParenListExpr
G:\arbeit\llvm2\llvm\tools\clang\unittests\AST\ASTImporterTest.cpp(284):
error: Value of: testImport( "  template<typename T> class declToImport {"
"    void f(
) { declToImport X(*this); } }; ", Lang_CXX, "", Lang_CXX, Verifier,
classTemplateDecl( has( cxxRecordDecl( hasMethod( allOf( hasName("f"),
hasBody( compoundStm
t( has( declStmt( hasSingleDecl( varDecl( hasInitializer( parenListExpr(
has( unaryOperator( hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())
))))))))))))))
))
  Actual: false (Could not find match)
Expected: true
[  FAILED  ] ImportExpr.ImportParenListExpr (59 ms)

[  FAILED  ] 2 tests, listed below:
[  FAILED  ] ImportExpr.ImportGNUNullExpr
[  FAILED  ] ImportExpr.ImportParenListExpr

 2 FAILED TESTS

Thanks,
--Serge

[a.sidorin]

An attempt to fix ParenListExpr test on Windows

[sepavloff]

The last changes didn't help.

AST generated in ImportGNUNullExpr is:

TranslationUnitDecl 0xc46238 <<invalid sloc>> <invalid sloc>
…
|   `-BuiltinType 0xc46290 'char'
`-FunctionDecl 0xc468a0 <input.cc:1:1, col:31> col:6 declToImport 'void (void)'
  `-CompoundStmt 0xc46948 <col:21, col:31>
    `-GNUNullExpr 0xc46938 <col:23> 'int'

Note, type of GNUNullExpr is int but you check for long.
Similarly, source code in the check ImportParenListExpr produces AST:

TranslationUnitDecl 0xc47340 <<invalid sloc>> <invalid sloc>
…
| `-ClassTemplateSpecializationDecl 0xc47d00 <col:1, col:66> col:28 class dummy
|   `-TemplateArgument type 'int'
`-TypedefDecl 0xc47e38 <col:68, col:87> col:87 declToImport 'dummy<int>':'class dummy<int>'
  `-TemplateSpecializationType 0xc47db0 'dummy<int>' sugar dummy
    |-TemplateArgument type 'int'
    `-RecordType 0xc47da0 'class dummy<int>'
      `-ClassTemplateSpecialization 0xc47d00 'dummy'

There is no ParenListExpr, - templates are handled in msvc compatibility mode a bit differently.
Probably the tests could be fixed by hard coding target to Linux64.

[a.sidorin]

Serge, thank you for help!
GNUNullExpr was 'long' on my platform. I weakened a matcher to check only if it has integer type.
ParenListExpr issue was also successfully reproduced with 'fdelayed-template-parsing' and fixed.
I hope this version passes all the tests. Could you recheck? I cannot gain access to MSVC now.

[sepavloff]

With the latest changes unit tests are successfully passed on Windows!
You can go forward in completing the fix.

Thanks,
--Serge

[a.sidorin]

Is this patch OK to submit?

[spyffe]

Overall this is a great improvement and I look forward to taking advantage of this patch in LLDB!

I had one specific nit about NullPtrTy, and one more general comment about your infrastructure that imports multiple things – it seems like we can collaborate and create some combination of ImportArray and your code to handle all cases. Particularly you handle the cases where the array doesn't have to be allocated inside getToContext() – my code doesn't handle that at all.

Thanks for working on this.

lib/AST/ASTImporter.cpp

35 ↗

(On Diff #51027)

I recently added a function, ImportArray, that does something similar. Could it be adapted to your needs?

5462 ↗

(On Diff #51027)

I'm worried about using NullPtrTy here directly, because the type may have been coerced to a typedef or something like that. The fact that the constructor takes a type argument suggests that the type is not implicit – I'd feel much more comfortable just importing the type.

5466 ↗

(On Diff #51027)

I recently committed VisitCXXBoolLiteralExpr. Sorry to step on your toes!

5878 ↗

(On Diff #51027)

Sorry again! I recently committed VisitCXXThisExpr

unittests/AST/ASTImporterTest.cpp

118 ↗

(On Diff #51027)

This is a good point; if you use LLDB to test this (e.g., lldb's test/testcases/expression_command/top-level) then you can verify that these imported entities make it all the way to generated machine code and work as expected.

Ideally there would be a mode in Clang that parses the input file, makes a translation unit out of it, imports everything from that translation unit into another translation unit, and then CodeGens the second translation unit. That is something I'd like to hook up when I get some time. I've also talked to Doug Gregor and he suggested that perhaps .pch files can be abused for this purpose, repurposing some of the functionality in the ASTMerge tests (though those don't do CodeGen).

[a.sidorin]

Update to current master;
Fix a memory leak introduced in cf8ccff5: an array is allocated in ImportArray and never freed.

[spyffe]

Aleksei,

it looks like I might have made a bad assumption in my ImportArray – namely that there were some entities that required arrays of things they’re constructed with to be allocated in the ASTContext. Looking at the constructors for those entities, it looks like most of them actually do the allocation and copying themselves.

Thanks for cleaning that up. I’m going to try running the LLDB testsuite with your patch applied and I’ll let you know what happens.

Sean

[spyffe]

This all looks fine to me, and the LLDB test suite is happy also.

cfe/trunk/include/clang/AST/Type.h

class InjectedClassNameType : public Type {
   /// It is always unqualified, always a template specialization type,
   /// and always dependent.
   QualType InjectedType;
 
   friend class ASTContext; // ASTContext creates these.
   friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
                           // currently suitable for AST reading, too much
                           // interdependencies.
+  friend class ASTNodeImporter;
+
   InjectedClassNameType(CXXRecordDecl *D, QualType TST)
     : Type(InjectedClassName, QualType(), /*Dependent=*/true,
            /*InstantiationDependent=*/true,
            /*VariablyModified=*/false,
            /*ContainsUnexpandedParameterPack=*/false),
       Decl(D), InjectedType(TST) {
     assert(isa<TemplateSpecializationType>(TST));
     assert(!TST.hasQualifiers());

cfe/trunk/lib/AST/ASTImporter.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include <deque>
 
 namespace clang {
   class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
                           public DeclVisitor<ASTNodeImporter, Decl *>,
                           public StmtVisitor<ASTNodeImporter, Stmt *> {
     ASTImporter &Importer;
-    
   public:
     explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
     
     using TypeVisitor<ASTNodeImporter, QualType>::Visit;
     using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
     using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
 
     // Importing types
public:
     QualType VisitParenType(const ParenType *T);
     QualType VisitTypedefType(const TypedefType *T);
     QualType VisitTypeOfExprType(const TypeOfExprType *T);
     // FIXME: DependentTypeOfExprType
     QualType VisitTypeOfType(const TypeOfType *T);
     QualType VisitDecltypeType(const DecltypeType *T);
     QualType VisitUnaryTransformType(const UnaryTransformType *T);
     QualType VisitAutoType(const AutoType *T);
+    QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
     // FIXME: DependentDecltypeType
     QualType VisitRecordType(const RecordType *T);
     QualType VisitEnumType(const EnumType *T);
     QualType VisitAttributedType(const AttributedType *T);
-    // FIXME: TemplateTypeParmType
+    QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
     // FIXME: SubstTemplateTypeParmType
     QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
     QualType VisitElaboratedType(const ElaboratedType *T);
     // FIXME: DependentNameType
     // FIXME: DependentTemplateSpecializationType
     QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
     QualType VisitObjCObjectType(const ObjCObjectType *T);
     QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
                             
     // Importing declarations                            
     bool ImportDeclParts(NamedDecl *D, DeclContext *&DC, 
                          DeclContext *&LexicalDC, DeclarationName &Name, 
                          NamedDecl *&ToD, SourceLocation &Loc);
     void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
     void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
                                   DeclarationNameInfo& To);
     void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
-                        
+    typedef DesignatedInitExpr::Designator Designator;
+    Designator ImportDesignator(const Designator &D);
+
+                        
     /// \brief What we should import from the definition.
     enum ImportDefinitionKind { 
       /// \brief Import the default subset of the definition, which might be
       /// nothing (if minimal import is set) or might be everything (if minimal
       /// import is not set).
       IDK_Default,
       /// \brief Import everything.
       IDK_Everything,
public:
     bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
     Decl *VisitDecl(Decl *D);
     Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
     Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
     Decl *VisitNamespaceDecl(NamespaceDecl *D);
     Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
     Decl *VisitTypedefDecl(TypedefDecl *D);
     Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
+    Decl *VisitLabelDecl(LabelDecl *D);
     Decl *VisitEnumDecl(EnumDecl *D);
     Decl *VisitRecordDecl(RecordDecl *D);
     Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
     Decl *VisitFunctionDecl(FunctionDecl *D);
     Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
     Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
     Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
     Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
Decl *VisitClassTemplateSpecializationDecl(
                                             ClassTemplateSpecializationDecl *D);
     Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
     Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
 
     // Importing statements
     DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
 
     Stmt *VisitStmt(Stmt *S);
+    Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
     Stmt *VisitDeclStmt(DeclStmt *S);
     Stmt *VisitNullStmt(NullStmt *S);
     Stmt *VisitCompoundStmt(CompoundStmt *S);
     Stmt *VisitCaseStmt(CaseStmt *S);
     Stmt *VisitDefaultStmt(DefaultStmt *S);
     Stmt *VisitLabelStmt(LabelStmt *S);
     Stmt *VisitAttributedStmt(AttributedStmt *S);
     Stmt *VisitIfStmt(IfStmt *S);
     Stmt *VisitSwitchStmt(SwitchStmt *S);
     Stmt *VisitWhileStmt(WhileStmt *S);
     Stmt *VisitDoStmt(DoStmt *S);
     Stmt *VisitForStmt(ForStmt *S);
     Stmt *VisitGotoStmt(GotoStmt *S);
     Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
     Stmt *VisitContinueStmt(ContinueStmt *S);
     Stmt *VisitBreakStmt(BreakStmt *S);
     Stmt *VisitReturnStmt(ReturnStmt *S);
-    // FIXME: GCCAsmStmt
     // FIXME: MSAsmStmt
     // FIXME: SEHExceptStmt
     // FIXME: SEHFinallyStmt
     // FIXME: SEHTryStmt
     // FIXME: SEHLeaveStmt
     // FIXME: CapturedStmt
     Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
     Stmt *VisitCXXTryStmt(CXXTryStmt *S);
     Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
     // FIXME: MSDependentExistsStmt
     Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
     Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
     Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
     Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
     Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
     Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
     Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
 
     // Importing expressions
     Expr *VisitExpr(Expr *E);
+    Expr *VisitVAArgExpr(VAArgExpr *E);
+    Expr *VisitGNUNullExpr(GNUNullExpr *E);
+    Expr *VisitPredefinedExpr(PredefinedExpr *E);
     Expr *VisitDeclRefExpr(DeclRefExpr *E);
+    Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
+    Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
+    Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
     Expr *VisitIntegerLiteral(IntegerLiteral *E);
+    Expr *VisitFloatingLiteral(FloatingLiteral *E);
     Expr *VisitCharacterLiteral(CharacterLiteral *E);
+    Expr *VisitStringLiteral(StringLiteral *E);
+    Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
+    Expr *VisitAtomicExpr(AtomicExpr *E);
+    Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
     Expr *VisitParenExpr(ParenExpr *E);
+    Expr *VisitParenListExpr(ParenListExpr *E);
+    Expr *VisitStmtExpr(StmtExpr *E);
     Expr *VisitUnaryOperator(UnaryOperator *E);
     Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
     Expr *VisitBinaryOperator(BinaryOperator *E);
+    Expr *VisitConditionalOperator(ConditionalOperator *E);
+    Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
+    Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
     Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
     Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
     Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
     Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
     Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
     Expr *VisitCXXThisExpr(CXXThisExpr *E);
     Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
     Expr *VisitMemberExpr(MemberExpr *E);
     Expr *VisitCallExpr(CallExpr *E);
     Expr *VisitInitListExpr(InitListExpr *E);
-                            
-    template <typename T, typename Iter> bool ImportArray(Iter B, Iter E, llvm::ArrayRef<T*> &ToArray) {
-      size_t NumElements = E - B;
-      SmallVector<T *, 1> ImportedElements(NumElements);
-      ASTImporter &_Importer = Importer;
-      
+    template<typename IIter, typename OIter>
+    void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
+      typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;
+      ASTImporter &ImporterRef = Importer;
+      std::transform(Ibegin, Iend, Obegin,
+                     [&ImporterRef](ItemT From) -> ItemT {
+                       return ImporterRef.Import(From);
+                     });
+    }
+    template<typename IIter, typename OIter>
+    bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
+      typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT;
+      ASTImporter &ImporterRef = Importer;
       bool Failed = false;
-      std::transform(B, E, ImportedElements.begin(),
-                     [&_Importer, &Failed](T *Element) -> T* {
-                       T *ToElement = _Importer.Import(Element);
-                       if (Element && !ToElement)
+      std::transform(Ibegin, Iend, Obegin,
+                     [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
+                       ItemT *To = ImporterRef.Import(From);
+                       if (!To && From)
                          Failed = true;
-                       return ToElement;
+                       return To;
                      });
-      
-      if (Failed)
-        return false;
-      
-      T **CopiedElements = new (Importer.getToContext()) T*[NumElements];
-      std::copy(ImportedElements.begin(), ImportedElements.end(), &CopiedElements[0]);
-      ToArray = llvm::ArrayRef<T*>(CopiedElements, NumElements);
-      
-      return true;
+      return Failed;
     }
   };
 }
+
 using namespace clang;
 
 //----------------------------------------------------------------------------
 // Structural Equivalence
 //----------------------------------------------------------------------------
 
 namespace {
   struct StructuralEquivalenceContext {
if (!FromDeduced.isNull()) {
     if (ToDeduced.isNull())
       return QualType();
   }
   
   return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
                                              /*IsDependent*/false);
 }
 
+QualType ASTNodeImporter::VisitInjectedClassNameType(
+    const InjectedClassNameType *T) {
+  CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
+  if (!D)
+    return QualType();
+
+  QualType InjType = Importer.Import(T->getInjectedSpecializationType());
+  if (InjType.isNull())
+    return QualType();
+
+  // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
+  // See comments in InjectedClassNameType definition for details
+  // return Importer.getToContext().getInjectedClassNameType(D, InjType);
+  enum {
+    TypeAlignmentInBits = 4,
+    TypeAlignment = 1 << TypeAlignmentInBits
+  };
+
+  return QualType(new (Importer.getToContext(), TypeAlignment)
+                  InjectedClassNameType(D, InjType), 0);
+}
+
 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
   RecordDecl *ToDecl
     = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
   if (!ToDecl)
     return QualType();
 
   return Importer.getToContext().getTagDeclType(ToDecl);
 }
if (!FromEquivalentType.isNull()) {
     if (ToEquivalentType.isNull())
       return QualType();
   }
 
   return Importer.getToContext().getAttributedType(T->getAttrKind(),
     ToModifiedType, ToEquivalentType);
 }
 
+
+QualType ASTNodeImporter::VisitTemplateTypeParmType(
+    const TemplateTypeParmType *T) {
+  TemplateTypeParmDecl *ParmDecl =
+      cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
+  if (!ParmDecl && T->getDecl())
+    return QualType();
+
+  return Importer.getToContext().getTemplateTypeParmType(
+        T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
+}
+
 QualType ASTNodeImporter::VisitTemplateSpecializationType(
                                        const TemplateSpecializationType *T) {
   TemplateName ToTemplate = Importer.Import(T->getTemplateName());
   if (ToTemplate.isNull())
     return QualType();
   
   SmallVector<TemplateArgument, 2> ToTemplateArgs;
   if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))

 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
   return VisitTypedefNameDecl(D, /*IsAlias=*/false);
 }
 
 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
   return VisitTypedefNameDecl(D, /*IsAlias=*/true);
 }
 
+Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
+  // Import the major distinguishing characteristics of this label.
+  DeclContext *DC, *LexicalDC;
+  DeclarationName Name;
+  SourceLocation Loc;
+  NamedDecl *ToD;
+  if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
+    return nullptr;
+  if (ToD)
+    return ToD;
+
+  assert(LexicalDC->isFunctionOrMethod());
+
+  LabelDecl *ToLabel = D->isGnuLocal()
+      ? LabelDecl::Create(Importer.getToContext(),
+                          DC, Importer.Import(D->getLocation()),
+                          Name.getAsIdentifierInfo(),
+                          Importer.Import(D->getLocStart()))
+      : LabelDecl::Create(Importer.getToContext(),
+                          DC, Importer.Import(D->getLocation()),
+                          Name.getAsIdentifierInfo());
+  Importer.Imported(D, ToLabel);
+
+  LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
+  if (!Label)
+    return nullptr;
+
+  ToLabel->setStmt(Label);
+  ToLabel->setLexicalDeclContext(LexicalDC);
+  LexicalDC->addDeclInternal(ToLabel);
+  return ToLabel;
+}
+
 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
   // Import the major distinguishing characteristics of this enum.
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
   NamedDecl *ToD;
   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
     return nullptr;
if (!DC->isFunctionOrMethod()) {
     
     if (!Name)
       return nullptr;
   }
 
   CXXRecordDecl *DTemplated = D->getTemplatedDecl();
   
   // Create the declaration that is being templated.
-  SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
-  SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
-  CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
-                                                     DTemplated->getTagKind(),
-                                                     DC, StartLoc, IdLoc,
-                                                   Name.getAsIdentifierInfo());
-  D2Templated->setAccess(DTemplated->getAccess());
-  D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
-  D2Templated->setLexicalDeclContext(LexicalDC);
-  
+  // Create the declaration that is being templated.
+  CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>(
+        Importer.Import(DTemplated));
+  if (!D2Templated)
+    return nullptr;
+
+  // Resolve possible cyclic import.
+  if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
+    return AlreadyImported;
   // Create the class template declaration itself.
   TemplateParameterList *TemplateParams
     = ImportTemplateParameterList(D->getTemplateParameters());
   if (!TemplateParams)
     return nullptr;
 
   ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC, 
                                                     Loc, Name, TemplateParams, 
return DeclGroupRef::Create(Importer.getToContext(),
                               NumDecls);
 }
 
  Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
    Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
      << S->getStmtClassName();
    return nullptr;
  }
- 
+
+Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
+  SmallVector<IdentifierInfo *, 4> Names;
+  for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
+    IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
+    if (!ToII)
+      return nullptr;
+    Names.push_back(ToII);
+  }
+  for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
+    IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
+    if (!ToII)
+      return nullptr;
+    Names.push_back(ToII);
+  }
+
+  SmallVector<StringLiteral *, 4> Clobbers;
+  for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
+    StringLiteral *Clobber = cast_or_null<StringLiteral>(
+          Importer.Import(S->getClobberStringLiteral(I)));
+    if (!Clobber)
+      return nullptr;
+    Clobbers.push_back(Clobber);
+  }
+
+  SmallVector<StringLiteral *, 4> Constraints;
+  for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
+    StringLiteral *Output = cast_or_null<StringLiteral>(
+          Importer.Import(S->getOutputConstraintLiteral(I)));
+    if (!Output)
+      return nullptr;
+    Constraints.push_back(Output);
+  }
+
+  for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
+    StringLiteral *Input = cast_or_null<StringLiteral>(
+          Importer.Import(S->getInputConstraintLiteral(I)));
+    if (!Input)
+      return nullptr;
+    Constraints.push_back(Input);
+  }
+
+  SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
+  if (ImportArrayChecked(S->begin_outputs(), S->end_outputs(), Exprs.begin()))
+    return nullptr;
+
+  if (ImportArrayChecked(S->begin_inputs(), S->end_inputs(),
+                         Exprs.begin() + S->getNumOutputs()))
+    return nullptr;
+
+  StringLiteral *AsmStr = cast_or_null<StringLiteral>(
+        Importer.Import(S->getAsmString()));
+  if (!AsmStr)
+    return nullptr;
+
+  return new (Importer.getToContext()) GCCAsmStmt(
+        Importer.getToContext(),
+        Importer.Import(S->getAsmLoc()),
+        S->isSimple(),
+        S->isVolatile(),
+        S->getNumOutputs(),
+        S->getNumInputs(),
+        Names.data(),
+        Constraints.data(),
+        Exprs.data(),
+        AsmStr,
+        S->getNumClobbers(),
+        Clobbers.data(),
+        Importer.Import(S->getRParenLoc()));
+}
+
 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
   DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
   for (Decl *ToD : ToDG) {
     if (!ToD)
       return nullptr;
   }
   SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
   SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
   return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
 }
 
 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
   SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
   return new (Importer.getToContext()) NullStmt(ToSemiLoc,
                                                 S->hasLeadingEmptyMacro());
 }
 
 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
-  llvm::ArrayRef<Stmt *> ToStmts;
+  llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
     
-  if (!ImportArray(S->body_begin(), S->body_end(), ToStmts))
+  if (ImportArrayChecked(S->body_begin(), S->body_end(), ToStmts.begin()))
     return nullptr;
 
   SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
   SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
   return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
                                                     ToStmts,
                                                     ToLBraceLoc, ToRBraceLoc);
 }

 // Import Expressions
 //----------------------------------------------------------------------------
 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
   Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
     << E->getStmtClassName();
   return nullptr;
 }
 
+Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *SubExpr = Importer.Import(E->getSubExpr());
+  if (!SubExpr && E->getSubExpr())
+    return nullptr;
+
+  TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
+  if (!TInfo)
+    return nullptr;
+
+  return new (Importer.getToContext()) VAArgExpr(
+        Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
+        Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
+}
+
+
+Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  return new (Importer.getToContext()) GNUNullExpr(
+        T, Importer.Import(E->getExprLoc()));
+}
+
+Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  StringLiteral *SL = cast_or_null<StringLiteral>(
+        Importer.Import(E->getFunctionName()));
+  if (!SL && E->getFunctionName())
+    return nullptr;
+
+  return new (Importer.getToContext()) PredefinedExpr(
+        Importer.Import(E->getExprLoc()), T, E->getIdentType(), SL);
+}
+
 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
   ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
   if (!ToD)
     return nullptr;
 
   NamedDecl *FoundD = nullptr;
   if (E->getDecl() != E->getFoundDecl()) {
     FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
                                          T, E->getValueKind(),
                                          FoundD,
                                          /*FIXME:TemplateArgs=*/nullptr);
   if (E->hadMultipleCandidates())
     DRE->setHadMultipleCandidates(true);
   return DRE;
 }
 
+Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return NULL;
+
+  return new (Importer.getToContext()) ImplicitValueInitExpr(T);
+}
+
+ASTNodeImporter::Designator
+ASTNodeImporter::ImportDesignator(const Designator &D) {
+  if (D.isFieldDesignator()) {
+    IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
+    // Caller checks for import error
+    return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
+                      Importer.Import(D.getFieldLoc()));
+  }
+  if (D.isArrayDesignator())
+    return Designator(D.getFirstExprIndex(),
+                      Importer.Import(D.getLBracketLoc()),
+                      Importer.Import(D.getRBracketLoc()));
+
+  assert(D.isArrayRangeDesignator());
+  return Designator(D.getFirstExprIndex(),
+                    Importer.Import(D.getLBracketLoc()),
+                    Importer.Import(D.getEllipsisLoc()),
+                    Importer.Import(D.getRBracketLoc()));
+}
+
+
+Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
+  Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
+  if (!Init)
+    return nullptr;
+
+  SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
+  // List elements from the second, the first is Init itself
+  for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
+    if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
+      IndexExprs[I - 1] = Arg;
+    else
+      return nullptr;
+  }
+
+  SmallVector<Designator, 4> Designators(DIE->size());
+  std::transform(DIE->designators_begin(), DIE->designators_end(),
+                 Designators.begin(),
+    [this](const Designator &D) -> Designator {
+      return ImportDesignator(D);
+    });
+
+  for (auto I = DIE->designators_begin(), E = DIE->designators_end(); I != E;
+       ++I)
+    if (I->isFieldDesignator() && !I->getFieldName())
+      return nullptr;
+
+  return DesignatedInitExpr::Create(
+        Importer.getToContext(), Designators.data(), Designators.size(),
+        IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
+        DIE->usesGNUSyntax(), Init);
+}
+
+Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  return new (Importer.getToContext())
+      CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
+}
+
 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   return IntegerLiteral::Create(Importer.getToContext(), 
                                 E->getValue(), T,
                                 Importer.Import(E->getLocation()));
 }
 
+Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  return FloatingLiteral::Create(Importer.getToContext(),
+                                E->getValue(), E->isExact(), T,
+                                Importer.Import(E->getLocation()));
+}
+
 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
                                                         E->getKind(), T,
                                           Importer.Import(E->getLocation()));
 }
 
+Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
+  ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
+
+  return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
+                               E->getKind(), E->isPascal(), T,
+                               Locations.data(), Locations.size());
+}
+
+Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
+  if (!TInfo)
+    return nullptr;
+
+  Expr *Init = Importer.Import(E->getInitializer());
+  if (!Init)
+    return nullptr;
+
+  return new (Importer.getToContext()) CompoundLiteralExpr(
+        Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
+        Init, E->isFileScope());
+}
+
+Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
+  if (ImportArrayChecked(
+        E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
+        Exprs.begin()))
+    return nullptr;
+
+  return new (Importer.getToContext()) AtomicExpr(
+        Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
+        Importer.Import(E->getRParenLoc()));
+}
+
+Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
+  if (!ToLabel)
+    return nullptr;
+
+  return new (Importer.getToContext()) AddrLabelExpr(
+        Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
+        ToLabel, T);
+}
+
 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
   Expr *SubExpr = Importer.Import(E->getSubExpr());
   if (!SubExpr)
     return nullptr;
 
   return new (Importer.getToContext()) 
                                   ParenExpr(Importer.Import(E->getLParen()),
                                             Importer.Import(E->getRParen()),
                                             SubExpr);
 }
 
+Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
+  SmallVector<Expr *, 4> Exprs(E->getNumExprs());
+  if (ImportArrayChecked(
+        E->getExprs(), E->getExprs() + E->getNumExprs(), Exprs.begin()))
+    return nullptr;
+
+  return new (Importer.getToContext()) ParenListExpr(
+        Importer.getToContext(), Importer.Import(E->getLParenLoc()),
+        Exprs, Importer.Import(E->getLParenLoc()));
+}
+
+Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
+        Importer.Import(E->getSubStmt()));
+  if (!ToSubStmt && E->getSubStmt())
+    return nullptr;
+
+  return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
+        Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
+}
+
 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *SubExpr = Importer.Import(E->getSubExpr());
   if (!SubExpr)
     return nullptr;
Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
 
   return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
                                                       T, E->getValueKind(),
                                                       E->getObjectKind(),
                                            Importer.Import(E->getOperatorLoc()),
                                                       E->isFPContractable());
 }
 
+Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *ToLHS = Importer.Import(E->getLHS());
+  if (!ToLHS)
+    return nullptr;
+
+  Expr *ToRHS = Importer.Import(E->getRHS());
+  if (!ToRHS)
+    return nullptr;
+
+  Expr *ToCond = Importer.Import(E->getCond());
+  if (!ToCond)
+    return nullptr;
+
+  return new (Importer.getToContext()) ConditionalOperator(
+        ToCond, Importer.Import(E->getQuestionLoc()),
+        ToLHS, Importer.Import(E->getColonLoc()),
+        ToRHS, T, E->getValueKind(), E->getObjectKind());
+}
+
+Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
+    BinaryConditionalOperator *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *Common = Importer.Import(E->getCommon());
+  if (!Common)
+    return nullptr;
+
+  Expr *Cond = Importer.Import(E->getCond());
+  if (!Cond)
+    return nullptr;
+
+  OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
+        Importer.Import(E->getOpaqueValue()));
+  if (!OpaqueValue)
+    return nullptr;
+
+  Expr *TrueExpr = Importer.Import(E->getTrueExpr());
+  if (!TrueExpr)
+    return nullptr;
+
+  Expr *FalseExpr = Importer.Import(E->getFalseExpr());
+  if (!FalseExpr)
+    return nullptr;
+
+  return new (Importer.getToContext()) BinaryConditionalOperator(
+        Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
+        Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
+        T, E->getValueKind(), E->getObjectKind());
+}
+
+Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *SourceExpr = Importer.Import(E->getSourceExpr());
+  if (!SourceExpr && E->getSourceExpr())
+    return nullptr;
+
+  return new (Importer.getToContext()) OpaqueValueExpr(
+        Importer.Import(E->getExprLoc()), T, E->getValueKind(),
+        E->getObjectKind(), SourceExpr);
+}
+
 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   QualType CompLHSType = Importer.Import(E->getComputationLHSType());
   if (CompLHSType.isNull())
     return nullptr;
Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
   if (T.isNull())
     return nullptr;
 
   CXXConstructorDecl *ToCCD =
     dyn_cast<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
   if (!ToCCD && E->getConstructor())
     return nullptr;
 
-  ArrayRef<Expr *> ToArgs;
-  
-  if (!ImportArray(E->arg_begin(), E->arg_end(), ToArgs))
+  SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
+  if (ImportArrayChecked(E->getArgs(), E->getArgs() + E->getNumArgs(),
+                         ToArgs.begin()))
     return nullptr;
 
   return CXXConstructExpr::Create(Importer.getToContext(), T,
                                   Importer.Import(E->getLocation()),
                                   ToCCD, E->isElidable(),
                                   ToArgs, E->hadMultipleCandidates(),
                                   E->isListInitialization(),
                                   E->isStdInitListInitialization(),
                                   E->requiresZeroInitialization(),
                                   E->getConstructionKind(),
                                   Importer.Import(E->getParenOrBraceRange()));
 }
 
 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
   
   Expr *ToFn = Importer.Import(E->getCallee());
   if (!ToFn)
     return nullptr;
   
-  ArrayRef<Expr *> ToArgs;
+  SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
   
-  if (!ImportArray(E->arg_begin(), E->arg_end(), ToArgs))
+  if (ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
     return nullptr;
 
-  return new (Importer.getToContext()) CXXMemberCallExpr(Importer.getToContext(), ToFn,
-                                                         ToArgs, T, E->getValueKind(),
-                                                         Importer.Import(E->getRParenLoc()));
+  return new (Importer.getToContext()) CXXMemberCallExpr(
+        Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
 }
 
 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
   
   return new (Importer.getToContext())
for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
     ToArgs_Copied[ai] = ToArgs[ai];
 
   return new (Importer.getToContext())
     CallExpr(Importer.getToContext(), ToCallee, 
              llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
              Importer.Import(E->getRParenLoc()));
 }
 
-Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
-  QualType T = Importer.Import(E->getType());
+Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
+  QualType T = Importer.Import(ILE->getType());
   if (T.isNull())
     return nullptr;
-    
-  ArrayRef<Expr *> ToInits;
+  llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
+  if (ImportArrayChecked(
+        ILE->getInits(), ILE->getInits() + ILE->getNumInits(), Exprs.begin()))
+    return nullptr;
+
+  ASTContext &ToCtx = Importer.getToContext();
+  InitListExpr *To = new (ToCtx) InitListExpr(
+        ToCtx, Importer.Import(ILE->getLBraceLoc()),
+        Exprs, Importer.Import(ILE->getLBraceLoc()));
+  To->setType(T);
 
-  if (!ImportArray(E->inits().begin(), E->inits().end(), ToInits))
+  if (ILE->hasArrayFiller()) {
+    Expr *Filler = Importer.Import(ILE->getArrayFiller());
+    if (!Filler)
       return nullptr;
-    
-  InitListExpr *ToE = new (Importer.getToContext())
-    InitListExpr(Importer.getToContext(),
-                 Importer.Import(E->getLBraceLoc()),
-                 ToInits,
-                 Importer.Import(E->getRBraceLoc()));
-  
-  if (ToE)
-    ToE->setType(T);
+    To->setArrayFiller(Filler);
+  }
+  if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
+    FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
+    if (!ToFD)
+      return nullptr;
+    To->setInitializedFieldInUnion(ToFD);
+  }
+  if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
+    InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
+          Importer.Import(SyntForm));
+    if (!ToSyntForm)
+      return nullptr;
+    To->setSyntacticForm(ToSyntForm);
+  }
+
+  To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
+  To->setValueDependent(ILE->isValueDependent());
+  To->setInstantiationDependent(ILE->isInstantiationDependent());
 
-  return ToE;
+  return To;
 }
 
 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
                          ASTContext &FromContext, FileManager &FromFileManager,
                          bool MinimalImport)
   : ToContext(ToContext), FromContext(FromContext),
     ToFileManager(ToFileManager), FromFileManager(FromFileManager),
     Minimal(MinimalImport), LastDiagFromFrom(false)

cfe/trunk/unittests/AST/ASTImporterTest.cpp

+//===- unittest/AST/ASTImporterTest.cpp - AST node import test ------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for the correct import of AST nodes from one AST context to another.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTImporter.h"
+#include "MatchVerifier.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace ast_matchers {
+
+using clang::tooling::newFrontendActionFactory;
+using clang::tooling::runToolOnCodeWithArgs;
+using clang::tooling::FrontendActionFactory;
+
+typedef std::vector<std::string> StringVector;
+
+void getLangArgs(Language Lang, StringVector &Args) {
+  switch (Lang) {
+  case Lang_C:
+    Args.insert(Args.end(), { "-x", "c", "-std=c99" });
+    break;
+  case Lang_C89:
+    Args.insert(Args.end(), { "-x", "c", "-std=c89" });
+    break;
+  case Lang_CXX:
+    Args.push_back("-std=c++98");
+    break;
+  case Lang_CXX11:
+    Args.push_back("-std=c++11");
+    break;
+  case Lang_OpenCL:
+  case Lang_OBJCXX:
+    break;
+  }
+}
+
+template<typename NodeType, typename MatcherType>
+testing::AssertionResult
+testImport(const std::string &FromCode, Language FromLang,
+           const std::string &ToCode, Language ToLang,
+           MatchVerifier<NodeType> &Verifier,
+           const MatcherType &AMatcher) {
+  StringVector FromArgs, ToArgs;
+  getLangArgs(FromLang, FromArgs);
+  getLangArgs(ToLang, ToArgs);
+
+  const char *const InputFileName = "input.cc";
+  const char *const OutputFileName = "output.cc";
+
+  std::unique_ptr<ASTUnit>
+      FromAST = tooling::buildASTFromCodeWithArgs(
+        FromCode, FromArgs, InputFileName),
+      ToAST = tooling::buildASTFromCodeWithArgs(ToCode, ToArgs, OutputFileName);
+
+  ASTContext &FromCtx = FromAST->getASTContext(),
+      &ToCtx = ToAST->getASTContext();
+
+  // Add input.cc to virtual file system so importer can 'find' it
+  // while importing SourceLocations.
+  vfs::OverlayFileSystem *OFS = static_cast<vfs::OverlayFileSystem *>(
+        ToCtx.getSourceManager().getFileManager().getVirtualFileSystem().get());
+  vfs::InMemoryFileSystem *MFS = static_cast<vfs::InMemoryFileSystem *>(
+        OFS->overlays_begin()->get());
+  MFS->addFile(InputFileName, 0,
+               llvm::MemoryBuffer::getMemBuffer(FromCode.c_str()));
+
+  ASTImporter Importer(ToCtx, ToAST->getFileManager(),
+                       FromCtx, FromAST->getFileManager(), false);
+
+  IdentifierInfo *ImportedII = &FromCtx.Idents.get("declToImport");
+  assert(ImportedII && "Declaration with 'declToImport' name"
+                       "should be specified in test!");
+  DeclarationName ImportDeclName(ImportedII);
+  SmallVector<NamedDecl *, 4> FoundDecls;
+  FromCtx.getTranslationUnitDecl()->localUncachedLookup(
+        ImportDeclName, FoundDecls);
+
+  if (FoundDecls.size() != 1)
+    return testing::AssertionFailure() << "Multiple declarations were found!";
+
+  auto Imported = Importer.Import(*FoundDecls.begin());
+  if (!Imported)
+    return testing::AssertionFailure() << "Import failed, nullptr returned!";
+
+  // This should dump source locations and assert if some source locations
+  // were not imported
+  SmallString<1024> ImportChecker;
+  llvm::raw_svector_ostream ToNothing(ImportChecker);
+  ToCtx.getTranslationUnitDecl()->print(ToNothing);
+
+  return Verifier.match(Imported, AMatcher);
+}
+
+TEST(ImportExpr, ImportStringLiteral) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(testImport("void declToImport() { \"foo\"; }",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 stringLiteral(
+                                   hasType(
+                                     asString("const char [4]")))))))));
+  EXPECT_TRUE(testImport("void declToImport() { L\"foo\"; }",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 stringLiteral(
+                                   hasType(
+                                     asString("const wchar_t [4]")))))))));
+  EXPECT_TRUE(testImport("void declToImport() { \"foo\" \"bar\"; }",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 stringLiteral(
+                                   hasType(
+                                     asString("const char [7]")))))))));
+}
+
+TEST(ImportExpr, ImportGNUNullExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(testImport("void declToImport() { __null; }",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 gnuNullExpr(
+                                   hasType(isInteger()))))))));
+}
+
+TEST(ImportExpr, ImportCXXNullPtrLiteralExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(testImport("void declToImport() { nullptr; }",
+                         Lang_CXX11, "", Lang_CXX11, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 cxxNullPtrLiteralExpr()))))));
+}
+
+
+TEST(ImportExpr, ImportFloatinglLiteralExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(testImport("void declToImport() { 1.0; }",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 floatLiteral(
+                                   equals(1.0),
+                                   hasType(asString("double")))))))));
+  EXPECT_TRUE(testImport("void declToImport() { 1.0e-5f; }",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 floatLiteral(
+                                   equals(1.0e-5f),
+                                   hasType(asString("float")))))))));
+}
+
+TEST(ImportExpr, ImportCompoundLiteralExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "void declToImport() {"
+          "  struct s { int x; long y; unsigned z; }; "
+          "  (struct s){ 42, 0L, 1U }; }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            hasBody(
+              compoundStmt(
+                has(
+                  compoundLiteralExpr(
+                    hasType(asString("struct s")),
+                    has(initListExpr(
+                      hasType(asString("struct s")),
+                      has(integerLiteral(
+                            equals(42), hasType(asString("int")))),
+                      has(integerLiteral(
+                            equals(0), hasType(asString("long")))),
+                      has(integerLiteral(
+                            equals(1),
+                            hasType(asString("unsigned int"))))
+                      )))))))));
+}
+
+TEST(ImportExpr, ImportCXXThisExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport("class declToImport { void f() { this; } };",
+                   Lang_CXX, "", Lang_CXX, Verifier,
+                   cxxRecordDecl(
+                     hasMethod(
+                       hasBody(
+                         compoundStmt(
+                           has(
+                             cxxThisExpr(
+                               hasType(
+                                 asString("class declToImport *"))))))))));
+}
+
+TEST(ImportExpr, ImportAtomicExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            hasBody(
+              compoundStmt(
+                has(
+                  atomicExpr(
+                    has(declRefExpr(
+                          hasDeclaration(varDecl(hasName("ptr"))),
+                          hasType(asString("int *")))),
+                    has(integerLiteral(equals(1), hasType(asString("int"))))
+                    )))))));
+}
+
+TEST(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "void declToImport() { loop: goto loop; &&loop; }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            hasBody(
+              compoundStmt(
+                has(labelStmt(hasDeclaration(labelDecl(hasName("loop"))))),
+                has(addrLabelExpr(hasDeclaration(labelDecl(hasName("loop")))))
+                )))));
+}
+
+AST_MATCHER_P(TemplateDecl, hasTemplateDecl,
+              internal::Matcher<NamedDecl>, InnerMatcher) {
+  const NamedDecl *Template = Node.getTemplatedDecl();
+  return Template && InnerMatcher.matches(*Template, Finder, Builder);
+}
+
+TEST(ImportExpr, ImportParenListExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "template<typename T> class dummy { void f() { dummy X(*this); } };"
+          "typedef dummy<int> declToImport;"
+          "template class dummy<int>;",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          typedefDecl(
+            hasType(
+              templateSpecializationType(
+                hasDeclaration(
+                  classTemplateDecl(
+                    hasTemplateDecl(
+                      cxxRecordDecl(
+                        hasMethod(
+                        allOf(
+                          hasName("f"),
+                          hasBody(
+                            compoundStmt(
+                              has(
+                                declStmt(
+                                  hasSingleDecl(
+                                    varDecl(
+                                      hasInitializer(
+                                        parenListExpr(
+                                          has(
+                                            unaryOperator(
+                                              hasOperatorName("*"),
+                                              hasUnaryOperand(cxxThisExpr())
+                                              )))))))))))))))))))));
+}
+
+TEST(ImportExpr, ImportStmtExpr) {
+  MatchVerifier<Decl> Verifier;
+  // NOTE: has() ignores implicit casts, using hasDescendant() to match it
+  EXPECT_TRUE(
+        testImport(
+          "void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            hasBody(
+              compoundStmt(
+                has(
+                  declStmt(
+                    hasSingleDecl(
+                      varDecl(
+                        hasName("C"),
+                        hasType(asString("int")),
+                        hasInitializer(
+                          stmtExpr(
+                            hasAnySubstatement(
+                              declStmt(
+                                hasSingleDecl(
+                                  varDecl(
+                                    hasName("X"),
+                                    hasType(asString("int")),
+                                    hasInitializer(
+                                      integerLiteral(equals(4))))))),
+                            hasDescendant(
+                              implicitCastExpr()
+                              ))))))))))));
+}
+
+TEST(ImportExpr, ImportConditionalOperator) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "void declToImport() { true ? 1 : -5; }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            hasBody(
+              compoundStmt(
+                has(
+                  conditionalOperator(
+                    hasCondition(cxxBoolLiteral(equals(true))),
+                    hasTrueExpression(integerLiteral(equals(1))),
+                    hasFalseExpression(
+                      unaryOperator(hasUnaryOperand(integerLiteral(equals(5))))
+                      ))))))));
+}
+
+TEST(ImportExpr, ImportBinaryConditionalOperator) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "void declToImport() { 1 ?: -5; }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            hasBody(
+              compoundStmt(
+                has(
+                  binaryConditionalOperator(
+                    hasCondition(
+                      implicitCastExpr(
+                        hasSourceExpression(
+                          opaqueValueExpr(
+                            hasSourceExpression(integerLiteral(equals(1))))),
+                        hasType(booleanType()))),
+                    hasTrueExpression(
+                      opaqueValueExpr(hasSourceExpression(
+                                        integerLiteral(equals(1))))),
+                    hasFalseExpression(
+                      unaryOperator(hasOperatorName("-"),
+                                    hasUnaryOperand(integerLiteral(equals(5)))))
+                      )))))));
+}
+
+TEST(ImportExpr, ImportDesignatedInitExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(testImport("void declToImport() {"
+                         "  struct point { double x; double y; };"
+                         "  struct point ptarray[10] = "
+                                "{ [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }",
+                         Lang_C, "", Lang_C, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 declStmt(
+                                   hasSingleDecl(
+                                     varDecl(
+                                       hasInitializer(
+                                         initListExpr(
+                                           hasSyntacticForm(
+                                             initListExpr(
+                                               has(
+                                                 designatedInitExpr(
+                                                   designatorCountIs(2),
+                                                   has(floatLiteral(
+                                                         equals(1.0))),
+                                                   has(integerLiteral(
+                                                         equals(2))))),
+                                               has(
+                                                 designatedInitExpr(
+                                                   designatorCountIs(2),
+                                                   has(floatLiteral(
+                                                         equals(2.0))),
+                                                   has(integerLiteral(
+                                                         equals(2))))),
+                                               has(
+                                                 designatedInitExpr(
+                                                   designatorCountIs(2),
+                                                   has(floatLiteral(
+                                                         equals(1.0))),
+                                                   has(integerLiteral(
+                                                         equals(0)))))
+                                               )))))))))))));
+}
+
+
+TEST(ImportExpr, ImportPredefinedExpr) {
+  MatchVerifier<Decl> Verifier;
+  // __func__ expands as StringLiteral("declToImport")
+  EXPECT_TRUE(testImport("void declToImport() { __func__; }",
+                         Lang_CXX, "", Lang_CXX, Verifier,
+                         functionDecl(
+                           hasBody(
+                             compoundStmt(
+                               has(
+                                 predefinedExpr(
+                                   hasType(
+                                     asString("const char [13]")),
+                                   has(
+                                     stringLiteral(
+                                       hasType(
+                                         asString("const char [13]")))))))))));
+}
+
+TEST(ImportExpr, ImportInitListExpr) {
+  MatchVerifier<Decl> Verifier;
+  EXPECT_TRUE(
+        testImport(
+          "void declToImport() {"
+          "  struct point { double x; double y; };"
+          "  point ptarray[10] = { [2].y = 1.0, [2].x = 2.0,"
+          "                        [0].x = 1.0 }; }",
+          Lang_CXX, "", Lang_CXX, Verifier,
+          functionDecl(
+            hasBody(
+              compoundStmt(
+                has(
+                  declStmt(
+                    hasSingleDecl(
+                      varDecl(
+                        hasInitializer(
+                          initListExpr(
+                            has(
+                              cxxConstructExpr(
+                                requiresZeroInitialization())),
+                            has(
+                              initListExpr(
+                                hasType(asString("struct point")),
+                                has(floatLiteral(equals(1.0))),
+                                has(implicitValueInitExpr(
+                                      hasType(asString("double")))))),
+                            has(
+                              initListExpr(
+                                hasType(asString("struct point")),
+                                has(floatLiteral(equals(2.0))),
+                                has(floatLiteral(equals(1.0)))))
+                              )))))))))));
+}
+
+
+} // end namespace ast_matchers
+} // end namespace clang

cfe/trunk/unittests/AST/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(ASTTests
   ASTContextParentMapTest.cpp
+  ASTImporterTest.cpp
   ASTTypeTraitsTest.cpp
   ASTVectorTest.cpp
   CommentLexer.cpp
   CommentParser.cpp
   DeclPrinterTest.cpp
   DeclTest.cpp
   EvaluateAsRValueTest.cpp
   ExternalASTSourceTest.cpp