Added processing of several AST nodes in ASTNodeImporter.

[sepavloff]

It is stale already.

lib/AST/ASTImporter.cpp

public:
     Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
     Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
     Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
     Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
     Decl *VisitClassTemplateSpecializationDecl(
                                             ClassTemplateSpecializationDecl *D);
     Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
     Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
+    Decl *VisitFriendDecl(FriendDecl *D);
+    Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
+    Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
 
     // Importing statements
     DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
 
     Stmt *VisitStmt(Stmt *S);
     Stmt *VisitDeclStmt(DeclStmt *S);
     Stmt *VisitNullStmt(NullStmt *S);
     Stmt *VisitCompoundStmt(CompoundStmt *S);
public:
     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
+    bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
+
     Expr *VisitExpr(Expr *E);
     Expr *VisitDeclRefExpr(DeclRefExpr *E);
     Expr *VisitIntegerLiteral(IntegerLiteral *E);
     Expr *VisitCharacterLiteral(CharacterLiteral *E);
+    Expr *VisitStringLiteral(StringLiteral *E);
+    Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
+    Expr *VisitFloatingLiteral(FloatingLiteral *E);
+    Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
+    Expr *VisitCXXThisExpr(CXXThisExpr *E);
+    Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
+    Expr *VisitCXXNewExpr(CXXNewExpr *E);
+    Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
     Expr *VisitParenExpr(ParenExpr *E);
     Expr *VisitUnaryOperator(UnaryOperator *E);
     Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
+    Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
     Expr *VisitBinaryOperator(BinaryOperator *E);
     Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
+    Expr *VisitConditionalOperator(ConditionalOperator *E);
     Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
     Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
+    Expr *VisitInitListExpr(InitListExpr *E);
+    Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
+    Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
+    Expr *VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
+    Expr *VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
+    Expr *VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
+    Expr *VisitCXXConstCastExpr(CXXConstCastExpr *E);
+    Expr *VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
     Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
+    Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
+    Expr *VisitExprWithCleanups(ExprWithCleanups *E);
     Expr *VisitMemberExpr(MemberExpr *E);
     Expr *VisitCallExpr(CallExpr *E);
+    Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
   };
 }
 using namespace clang;
 
 //----------------------------------------------------------------------------
 // Structural Equivalence
 //----------------------------------------------------------------------------
 
Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
   Importer.Imported(D, D2);
 
   if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
     return nullptr;
 
   return D2;
 }
 
+Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
+  ASTContext &Context = Importer.getToContext();
+  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
+  if (!DC)
+    return nullptr;
+
+  FriendDecl::FriendUnion FU;
+  if (TypeSourceInfo *TSInfo = D->getFriendType()) {
+    FU = Importer.Import(TSInfo);
+  } else {
+    Decl *NDecl = D->getFriendDecl();
+    assert(NDecl);
+    NamedDecl *NewDecl = cast<NamedDecl>(Importer.Import(NDecl));
+    NewDecl->setObjectOfFriendDecl();
+    FU = NewDecl;
+  }
+
+  FriendDecl *FDecl = FriendDecl::Create(Context, DC,
+     Importer.Import(D->getLocation()), FU, Importer.Import(D->getFriendLoc()));
+  FDecl->setAccess(D->getAccess());
+
+  Importer.Imported(D, FDecl);
+  return FDecl;
+}
+
+Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
+  ASTContext &Context = Importer.getToContext();
+  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
+  if (!DC)
+    return nullptr;
+
+  AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, D->getAccess(), DC,
+          Importer.Import(D->getLocation()), Importer.Import(D->getColonLoc()));
+  Importer.Imported(D, ASDecl);
+  return ASDecl;
+}
+
+Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
+  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
+  SourceLocation Loc = Importer.Import(D->getLocation());
+  Expr *AssertExpr = Importer.Import(D->getAssertExpr());
+  StringLiteral *Message = cast<StringLiteral>(
+                                              Importer.Import(D->getMessage()));
+  SourceLocation RParenLoc = Importer.Import(D->getRParenLoc());
+
+  StaticAssertDecl *To = StaticAssertDecl::Create(Importer.getToContext(), DC,
+                            Loc, AssertExpr, Message, RParenLoc, D->isFailed());
+  Importer.Imported(D, To);
+  return To;
+}
+
 //----------------------------------------------------------------------------
 // Import Statements
 //----------------------------------------------------------------------------
 
 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
   if (DG.isNull())
     return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
   size_t NumDecls = DG.end() - DG.begin();
Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
   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 Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  SmallVector<SourceLocation, 4> NewLocations;
+  for (auto I = E->tokloc_begin(), End = E->tokloc_end(); I != End; ++I)
+    NewLocations.push_back(Importer.Import(*I));
+
+  ASTContext &ToCtx = Importer.getToContext();
+  return StringLiteral::Create(ToCtx, E->getBytes(), E->getKind(),
+                               E->isPascal(), Ty, NewLocations.data(),
+                               E->getNumConcatenated());
+}
+
+Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
+  ASTContext &ToCtx = Importer.getToContext();
+  return new(ToCtx) CXXBoolLiteralExpr(E->getValue(), ToCtx.BoolTy,
+                                       Importer.Import(E->getLocation()));
+}
+
+Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+  return FloatingLiteral::Create(Importer.getToContext(), E->getValue(),
+                           E->isExact(), Ty, Importer.Import(E->getLocation()));
+}
+
+Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
+  ASTContext &ToCtx = Importer.getToContext();
+  return new(ToCtx) CXXNullPtrLiteralExpr(ToCtx.NullPtrTy,
+                                          Importer.Import(E->getLocation()));
+}
+
+Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+  SourceLocation Loc = Importer.Import(E->getLocation());
+  return new(Importer.getToContext()) CXXThisExpr(Loc, Ty, E->isImplicit());
+}
+
+Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+  Expr *Ex = Importer.Import(E->getSubExpr());
+  SourceLocation Loc = Importer.Import(E->getThrowLoc());
+  return new(Importer.getToContext()) CXXThrowExpr(Ex, Ty, Loc,
+                                                  E->isThrownVariableInScope());
+}
+
+Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Decl *OpNew = Importer.Import(E->getOperatorNew());
+  if (!OpNew)
+    return nullptr;
+  Decl *OpDelete = Importer.Import(E->getOperatorDelete());
+
+  SmallVector<Expr*, 8> PlacementArgs;
+  for (auto I = E->placement_arg_begin(), End = E->placement_arg_end();
+       I != End; ++I)
+    PlacementArgs.push_back(Importer.Import(*I));
+
+  SourceRange TIDParens = Importer.Import(E->getTypeIdParens());
+  SourceRange Range = Importer.Import(E->getSourceRange());
+  SourceRange DIRange = Importer.Import(E->getDirectInitRange());
+
+  Expr *ArraySize = Importer.Import(E->getArraySize());
+  Expr *Initializer = Importer.Import(E->getInitializer());
+
+  TypeSourceInfo *AllocatedTypeInfo = Importer.Import(
+                                               E->getAllocatedTypeSourceInfo());
+
+  ASTContext &ToCtx = Importer.getToContext();
+  return new(ToCtx) CXXNewExpr(ToCtx, E->isGlobalNew(),
+      cast<FunctionDecl>(OpNew), cast_or_null<FunctionDecl>(OpDelete),
+      E->doesUsualArrayDeleteWantSize(), PlacementArgs, TIDParens, ArraySize,
+      E->getInitializationStyle(), Initializer, Ty, AllocatedTypeInfo, Range,
+      DIRange);
+}
+
+Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  FunctionDecl *OpDelete = cast<FunctionDecl>(
+                                       Importer.Import(E->getOperatorDelete()));
+  Expr *Arg = Importer.Import(E->getArgument());
+  SourceLocation Loc = Importer.Import(E->getLocStart());
+  return new(Importer.getToContext()) CXXDeleteExpr(Ty, E->isGlobalDelete(),
+      E->isArrayForm(), E->isArrayFormAsWritten(),
+      E->doesUsualArrayDeleteWantSize(), OpDelete, Arg, Loc);
+}
+
 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()),
if (!SubExpr)
     return nullptr;
 
   return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
                                           SubExpr, ResultType,
                                           Importer.Import(E->getOperatorLoc()),
                                           Importer.Import(E->getRParenLoc()));
 }
 
+Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Expr *LHS = Importer.Import(E->getLHS());
+  if (!LHS)
+    return nullptr;
+  Expr *RHS = Importer.Import(E->getRHS());
+  if (!RHS)
+    return nullptr;
+
+  return new(Importer.getToContext()) ArraySubscriptExpr(LHS, RHS, Ty,
+                                          E->getValueKind(), E->getObjectKind(),
+                                          Importer.Import(E->getRBracketLoc()));
+}
+
 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *LHS = Importer.Import(E->getLHS());
   if (!LHS)
     return nullptr;
return new (Importer.getToContext())
                         CompoundAssignOperator(LHS, RHS, E->getOpcode(),
                                                T, E->getValueKind(),
                                                E->getObjectKind(),
                                                CompLHSType, CompResultType,
                                            Importer.Import(E->getOperatorLoc()),
                                                E->isFPContractable());
 }
 
-static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
-  if (E->path_empty()) return false;
+Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
 
-  // TODO: import cast paths
+  Expr *Cond = Importer.Import(E->getCond());
+  if (!Cond)
+    return nullptr;
+  Expr *LHS = Importer.Import(E->getLHS());
+  if (!LHS)
+    return nullptr;
+  Expr *RHS = Importer.Import(E->getRHS());
+  if (!RHS)
+    return nullptr;
+
+  return new(Importer.getToContext()) ConditionalOperator(Cond,
+                                     Importer.Import(E->getQuestionLoc()), LHS,
+                                     Importer.Import(E->getColonLoc()), RHS,
+                                     Ty, E->getValueKind(), E->getObjectKind());
+}
+
+bool ASTNodeImporter::ImportCastPath(CastExpr *E, CXXCastPath &Path) {
+  if (E->path_empty())
+    return false;
+
+  for (auto *I = E->path_begin(), *End = E->path_end(); I != End; ++I) {
+    CXXBaseSpecifier *FromBase = *I;
+    SourceRange RLoc = Importer.Import(FromBase->getSourceRange());
+    SourceLocation ELoc = Importer.Import(FromBase->getEllipsisLoc());
+    TypeSourceInfo *TInfo = Importer.Import(FromBase->getTypeSourceInfo());
+    CXXBaseSpecifier *ToBase = new(Importer.getToContext()) CXXBaseSpecifier(
+        RLoc, FromBase->isVirtual(), FromBase->isBaseOfClass(),
+        FromBase->getAccessSpecifier(), TInfo, ELoc);
+    if (!ToBase)
       return true;
+    Path.push_back(ToBase);
+  }
+  return false;
 }
 
 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *SubExpr = Importer.Import(E->getSubExpr());
Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
 
   return CStyleCastExpr::Create(Importer.getToContext(), T,
                                 E->getValueKind(), E->getCastKind(),
                                 SubExpr, &BasePath, TInfo,
                                 Importer.Import(E->getLParenLoc()),
                                 Importer.Import(E->getRParenLoc()));
 }
 
+Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  SmallVector<Expr*, 8> InitExprs;
+  for (unsigned I = 0; I < E->getNumInits(); ++I) {
+    Expr *IE = Importer.Import(E->getInit(I));
+    if (!IE)
+      return nullptr;
+    InitExprs.push_back(IE);
+  }
+
+  SourceLocation LBLoc = Importer.Import(E->getLBraceLoc());
+  SourceLocation RBLoc = Importer.Import(E->getRBraceLoc());
+  ASTContext &ToCtx = Importer.getToContext();
+  InitListExpr *Res = new(ToCtx) InitListExpr(ToCtx, LBLoc, InitExprs, RBLoc);
+  Res->setType(Ty);
+
+  if (InitListExpr *SF = E->getSyntacticForm())
+    Res->setSyntacticForm(cast<InitListExpr>(Importer.Import(SF)));
+
+  if (E->hasArrayFiller())
+    Res->setArrayFiller(Importer.Import(E->getArrayFiller()));
+
+  if (FieldDecl *FD = E->getInitializedFieldInUnion())
+    Res->setInitializedFieldInUnion(cast<FieldDecl>(Importer.Import(FD)));
+
+  if (E->hadArrayRangeDesignator())
+    Res->sawArrayRangeDesignator();
+
+  return Res;
+}
+
+static DesignatedInitExpr::Designator
+ImportDesignator(ASTImporter &Importer, DesignatedInitExpr::Designator *D) {
+  if (D->isFieldDesignator()) {
+    Decl *FldDecl = Importer.Import(D->getField());
+    IdentifierInfo *II = Importer.Import(D->getFieldName());
+    SourceLocation DotLoc = Importer.Import(D->getDotLoc());
+    SourceLocation FieldLoc = Importer.Import(D->getFieldLoc());
+
+    DesignatedInitExpr::Designator DI(II, DotLoc, FieldLoc);
+    if (FldDecl)
+      DI.setField(cast<FieldDecl>(FldDecl));
+    return DI;
+  }
+
+  if (D->isArrayDesignator()) {
+    SourceLocation LBLoc = Importer.Import(D->getLBracketLoc());
+    SourceLocation RBLoc = Importer.Import(D->getRBracketLoc());
+    return DesignatedInitExpr::Designator(D->getFirstExprIndex(), LBLoc, RBLoc);
+  }
+
+  assert(D->isArrayRangeDesignator());
+  SourceLocation LBLoc = Importer.Import(D->getLBracketLoc());
+  SourceLocation ElLoc = Importer.Import(D->getEllipsisLoc());
+  SourceLocation RBLoc = Importer.Import(D->getRBracketLoc());
+  return DesignatedInitExpr::Designator(D->getFirstExprIndex(), LBLoc, ElLoc,
+                                        RBLoc);
+}
+
+Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
+  unsigned NumIndexExprs = E->getNumSubExprs();
+  SmallVector<Expr*, 4> IndexExprs;
+  for (unsigned I = 1; I < NumIndexExprs; ++I)
+    IndexExprs.push_back(Importer.Import(E->getSubExpr(I)));
+
+  SmallVector<DesignatedInitExpr::Designator, 16> Designators;
+  for (auto *D = E->designators_begin(); D != E->designators_end(); ++D)
+    Designators.emplace_back(ImportDesignator(Importer, D));
+
+  return DesignatedInitExpr::Create(Importer.getToContext(), Designators.data(),
+      Designators.size(), IndexExprs, Importer.Import(E->getEqualOrColonLoc()),
+      E->usesGNUSyntax(), Importer.Import(E->getInit()));
+}
+
+Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  return new (Importer.getToContext()) ImplicitValueInitExpr(Ty);
+}
+
+Expr *ASTNodeImporter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Expr *Op = Importer.Import(E->getSubExpr());
+  TypeSourceInfo *Written = Importer.Import(E->getTypeInfoAsWritten());
+  SourceLocation L = Importer.Import(E->getOperatorLoc());
+  SourceLocation RPLoc = Importer.Import(E->getRParenLoc());
+  SourceRange ABLoc = Importer.Import(E->getAngleBrackets());
+
+  CXXCastPath Path;
+  if (ImportCastPath(E, Path))
+    return nullptr;
+
+  return CXXStaticCastExpr::Create(Importer.getToContext(), Ty,
+      E->getValueKind(), E->getCastKind(), Op, &Path, Written, L, RPLoc, ABLoc);
+}
+
+Expr *ASTNodeImporter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Expr *OP = Importer.Import(E->getSubExpr());
+  TypeSourceInfo *WrittenTy = Importer.Import(E->getTypeInfoAsWritten());
+  SourceLocation Loc = Importer.Import(E->getLocStart());
+  SourceLocation RPLoc = Importer.Import(E->getRParenLoc());
+  SourceRange ABLoc = Importer.Import(E->getAngleBrackets());
+
+  CXXCastPath Path;
+  if (ImportCastPath(E, Path))
+    return 0;
+
+  return CXXDynamicCastExpr::Create(Importer.getToContext(),
+                                    Ty, E->getValueKind(), E->getCastKind(),
+                                    OP, &Path, WrittenTy, Loc, RPLoc, ABLoc);
+}
+
+Expr *ASTNodeImporter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Expr *OP = Importer.Import(E->getSubExpr());
+  TypeSourceInfo *WrittenTy = Importer.Import(E->getTypeInfoAsWritten());
+  SourceLocation Loc = Importer.Import(E->getLocStart());
+  SourceLocation RPLoc = Importer.Import(E->getRParenLoc());
+  SourceRange ABLoc = Importer.Import(E->getAngleBrackets());
+
+  CXXCastPath Path;
+  if (ImportCastPath(E, Path))
+    return 0;
+
+  return CXXReinterpretCastExpr::Create(Importer.getToContext(),
+                                        Ty, E->getValueKind(), E->getCastKind(),
+                                       OP, &Path, WrittenTy, Loc, RPLoc, ABLoc);
+}
+
+Expr *ASTNodeImporter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Expr *OP = Importer.Import(E->getSubExpr());
+  TypeSourceInfo *WrittenTy = Importer.Import(E->getTypeInfoAsWritten());
+  SourceLocation Loc = Importer.Import(E->getLocStart());
+  SourceLocation RPLoc = Importer.Import(E->getRParenLoc());
+  SourceRange ABLoc = Importer.Import(E->getAngleBrackets());
+
+  return CXXConstCastExpr::Create(Importer.getToContext(), Ty,
+                           E->getValueKind(), OP, WrittenTy, Loc, RPLoc, ABLoc);
+}
+
+Expr *ASTNodeImporter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Expr *OP = Importer.Import(E->getSubExpr());
+  TypeSourceInfo *WrittenTy = Importer.Import(E->getTypeInfoAsWritten());
+  SourceLocation RPLoc = Importer.Import(E->getRParenLoc());
+  SourceLocation LPLoc = Importer.Import(E->getLParenLoc());
+
+  CXXCastPath Path;
+  if (ImportCastPath(E, Path))
+    return nullptr;
+
+  return CXXFunctionalCastExpr::Create(Importer.getToContext(), Ty,
+      E->getValueKind(), WrittenTy, E->getCastKind(), OP, &Path, LPLoc, RPLoc);
+}
+
 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   CXXConstructorDecl *ToCCD =
     dyn_cast<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
   if (!ToCCD && E->getConstructor())
return CXXConstructExpr::Create(Importer.getToContext(), T,
                                   ToArgs, E->hadMultipleCandidates(),
                                   E->isListInitialization(),
                                   E->isStdInitListInitialization(),
                                   E->requiresZeroInitialization(),
                                   E->getConstructionKind(),
                                   Importer.Import(E->getParenOrBraceRange()));
 }
 
+Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
+  CXXDestructorDecl *FromDestructor = const_cast<CXXDestructorDecl*>(
+                                            E->getTemporary()->getDestructor());
+  CXXDestructorDecl *ToDestructor = cast<CXXDestructorDecl>(
+                                               Importer.Import(FromDestructor));
+  Importer.Imported(FromDestructor, ToDestructor);
+
+  CXXTemporary *Temp = CXXTemporary::Create(Importer.getToContext(),
+                                            ToDestructor);
+  Expr *SubExpr = Importer.Import(E->getSubExpr());
+  return CXXBindTemporaryExpr::Create(Importer.getToContext(), Temp, SubExpr);
+}
+
+Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
+  Expr *SubExpr = Importer.Import(E->getSubExpr());
+  assert(SubExpr && "SubExpr should be set");
+
+  SmallVector<ExprWithCleanups::CleanupObject, 8> Objects;
+  for (unsigned int i = 0; i < E->getNumObjects(); ++i) {
+    BlockDecl *From = E->getObject(i);
+    BlockDecl *To = cast<BlockDecl>(Importer.Import(From));
+    Importer.Imported(From, To);
+    Objects.push_back(To);
+  }
+
+  return ExprWithCleanups::Create(Importer.getToContext(), SubExpr, Objects);
+}
+
 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;
 
   Expr *ToBase = Importer.Import(E->getBase());
   if (!ToBase && E->getBase())
     return nullptr;
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::VisitMaterializeTemporaryExpr(
+                                                  MaterializeTemporaryExpr *E) {
+  QualType Ty = Importer.Import(E->getType());
+  if (Ty.isNull())
+    return nullptr;
+
+  Expr *Temp = Importer.Import(E->GetTemporaryExpr());
+
+  ValueDecl *FromExtendedBy = const_cast<ValueDecl*>(E->getExtendingDecl());
+  ValueDecl *ToExtendedBy = nullptr;
+  if (FromExtendedBy) {
+    ToExtendedBy = cast<ValueDecl>(Importer.Import(FromExtendedBy));
+    Importer.Imported(FromExtendedBy, ToExtendedBy);
+  }
+
+  MaterializeTemporaryExpr *To = new(Importer.getToContext())
+      MaterializeTemporaryExpr(Ty, Temp, E->isBoundToLvalueReference());
+  To->setExtendingDecl(ToExtendedBy, E->getManglingNumber());
+
+  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)
 {
   ImportedDecls[FromContext.getTranslationUnitDecl()]

test/ASTMerge/Inputs/class3.cpp

+class C1 {
+public:
+  C1();
+  ~C1();
+  C1 *method_1() {
+    return this;
+  }
+  C1 method_2() {
+    return C1();
+  }
+  void method_3() {
+    const C1 &ref = C1();
+  }
+};
+
+class C11 : public C1 {
+};
+
+class C2 {
+  int x;
+  friend class C3;
+  static_assert(sizeof(x) == sizeof(int), "Error");
+};

test/ASTMerge/Inputs/exprs3.cpp

+// Integer literals
+const char Ch1 = 'a';
+const signed char Ch2 = 'b';
+const unsigned char Ch3 = 'c';
+
+const wchar_t Ch4 = L'd';
+const signed wchar_t Ch5 = L'e';
+const unsigned wchar_t Ch6 = L'f';
+
+const short C1 = 12;
+const unsigned short C2 = 13;
+
+const int C3 = 12;
+const unsigned int C4 = 13;
+
+const long C5 = 22;
+const unsigned long C6 = 23;
+
+const long long C7 = 66;
+const unsigned long long C8 = 67;
+
+
+// String literals
+const char str1[] = "ABCD";
+const char str2[] = "ABCD" "0123";
+
+const wchar_t wstr1[] = L"DEF";
+const wchar_t wstr2[] = L"DEF" L"123";
+
+
+// Boolean literals
+const bool bval1 = true;
+const bool bval2 = false;
+
+// Floating Literals
+const float F1 = 12.2F;
+const double F2 = 1E4;
+const long double F3 = 1.2E-3L;
+
+
+// nullptr literal
+const void *vptr = nullptr;
+
+
+int glb_1[4] = { 10, 20, 30, 40 };
+
+struct S1 {
+  int a;
+  int b[3];
+};
+
+struct S2 {
+  int c;
+  S1 d;
+};
+
+S2 glb_2 = { 22, .d.a = 44, .d.b[0] = 55, .d.b[1] = 66 };
+
+void func() {
+  throw;
+  char *p = new char[10];
+  delete[] p;
+}
+
+int func_2(int *x, int n) {
+  return x[n];
+}
+
+int func_3(int c, int x, int y) {
+  return c ? x : y;
+}
+
+S1 &func_4(const S1 &x) {
+  return const_cast<S1&>(x);
+}
+
+S1 &func_5(S1 &x) {
+  return static_cast<S1&>(x);
+}
+
+S1 &func_6(S1 &x) {
+  return reinterpret_cast<S1&>(x);
+}
+
+S1 &func_7(S1 &x) {
+  return dynamic_cast<S1&>(x);
+}
+
+int func_8(int x) {
+  return int(x);
+}
+

test/ASTMerge/class2.cpp

+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1z -emit-pch -o %t.1.ast %S/Inputs/class3.cpp
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1z -ast-merge %t.1.ast -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+class C3 {
+  int method_1(C2 *x) {
+    return x->x;
+  }
+};

test/ASTMerge/exprs.cpp

+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1z -fcxx-exceptions -emit-pch -o %t.1.ast %S/Inputs/exprs3.cpp
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1z -fcxx-exceptions -ast-merge %t.1.ast -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+static_assert(Ch1 == 'a');
+static_assert(Ch2 == 'b');
+static_assert(Ch3 == 'c');
+
+static_assert(Ch4 == L'd');
+static_assert(Ch5 == L'e');
+static_assert(Ch6 == L'f');
+
+static_assert(C1 == 12);
+static_assert(C2 == 13);
+
+static_assert(C3 == 12);
+static_assert(C4 == 13);
+
+static_assert(C5 == 22L);
+static_assert(C6 == 23L);
+
+static_assert(C7 == 66LL);
+static_assert(C8 == 67ULL);
+
+static_assert(bval1 == true);
+static_assert(bval2 == false);