ASTImporter: expressions, pt.2

[a.sidorin]

Summary

This patch implements some expression-related AST node import (patch #2).

• Some code cleanup
• Add tests not present in http://reviews.llvm.org/D14286
• Integrate a test suite from Serge Pavlov (http://reviews.llvm.org/D14224)
• ArrayTypeTraitExpr: serialize sub-expression to avoid keeping it undefined
• Implement import of some nodes:

ArrayTypeTraitExpr
ExpressionTraitExpr
OpaqueValueExpr
ArraySubscriptExpr
ExplicitCastExpr
ImplicitValueInitExpr
OffsetOfExpr
CXXThisExpr
CXXThrowExpr
CXXNoexceptExpr
CXXDefaultArgExpr
CXXScalarValueInitExpr
CXXBindTemporaryExpr
CXXTemporaryObjectExpr
MaterializeTemporaryExpr
ExprWithCleanups
StaticAssertDecl
FriendDecl
DecayedType

[sepavloff]

The patch requires tests.
For instance, import of CXXBaseSpecifier can be tested along with static_cast: if a class indeed is a base, static_cast will be processed silent, otherwise a message must appear. ArraySubscript could be tested using constexpr function. MaterializeTemporaryExpr, CXXBindTemporaryExpr and CXXBindTemporaryExpr probably also can be tested with constexpr functions if temporary object class has constexpr constructor.

lib/AST/ASTImporter.cpp

5614

Use getStartLoc instead of getExprLoc. It more clearly resolves to ArrayTypeTraitExpr ::Loc.

5628

getExprLoc -> getStartLoc.

5642

getExprLoc -> getLocation.

5769

getExprLoc -> getOperatorLoc.

5859

Is there any reason to use subscript instead of push_back? If no, push_back is more clear.

5890

This code calculates parameter of type canThrowResult:

CanThrowResult V;
if (E->isValueDependent)
  V = CT_Dependent;
else
  V = E->getValue() ? CT_Can : CT_Cannot;

It looks more clear that the manipulations with created expression, doesn't it?

5909

getExprLoc -> getThrowLoc.

5923

getExprLoc -> getUsedLocation

5973

getExprLoc -> getParenOrBraceRange

6002

Should ManglingNumber get numbers associated with 'to' context?

[a.sidorin]

• Some code cleanup
• Add tests not present in http://reviews.llvm.org/D14286
• Integrate a test suite from Serge Pavlov (http://reviews.llvm.org/D14224)
• Fix some issues pointed on review.

[a.sidorin]

lib/AST/ASTImporter.cpp

5859

I usually prefer allocation with required size at the start and avoid push_back() because it may lead to reallocations.

6002

Hm, that's may be true, but I'm not sure. Added a FIXME.

[spyffe]

Overall I'm very enthusiastic about this and only have a few nitpicks. Thanks for the hard work!

lib/AST/ASTImporter.cpp

2364

I would expect this to be checked for nullptr and this function to error out.

2367

Should this be checked for nullptr as is done for other imports of TypeSourceInfo?

5517

This makes me happy :)

6317

You probably mean to use nullptr

[a.sidorin]

Add error checks; replace NULL with nullptr.

[a.sidorin]

lib/AST/ASTImporter.cpp

5527

Nice :)

[a.sidorin]

Add some basic tests for ExpressionTraitExpr and ArrayTypeTraitExpr.

[a.sidorin]

Ping?

[sepavloff]

lib/AST/ASTImporter.cpp

2373

Maybe else before this statement so that in the case of error ToInfo remained default initialized?

2502–2507

Is there a reason to handle lexical context of StaticAssertDecl separately? I would say static_assert is always in the context where it is declared, no?

2518–2519

Since C++17 static_assert may be used without message, so null pointer here is not an error.

3356

variable -> declaration?

3363

Maybe it is more natural to put this check into bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, RecordDecl *D1, RecordDecl *D2)? If records are equivalent, existing decl can be used as a result of import, if not - entire record must be recreated anyway.

[a.sidorin]

Thank you for your comments! And sorry for late response after pinging.

lib/AST/ASTImporter.cpp

2518–2519

I will modify the check, but may be we should check the language standard as well?

3363

Sorry, it seems like I don't completely understand your idea. Won't IsStructurallyEquivalent() do an additional amount of work?

[a.sidorin]

lib/AST/ASTImporter.cpp

3363

And also, even if they are equivalent, we should search for the equivalent FriendDecl to return it.

[a.sidorin]

Fix some issues pointed by Serge Pavlov.
Serge: putting a check of FriendDecls to IsStructurallyEquivalent() seems like a good idea for me, but we need some additional changes for it. CXXRecodeDecl::getFirstDecl() is private and StructuralEquivalenceContext() is located in an anonymous namespace so we cannot forward-declare it in DeclCXX.h to make it friend. We can move StructuralEquivalenceContext() out of anonymous namespace, however. What do you think?

[a.sidorin]

I don't think this small improvement in Importer is worth invasive changes in other components.

Thanks, Serge. Is it OK to commit?

[a.sidorin]

An attempt to fix unit test on Windows.
Serge, thank you! Could you please check this patch again?

[a.sidorin]

Removed unneeded matcher.

[sepavloff]

With this patch unit tests pass on Windows as well.
I do not have formal authority to approve patches, but for me the patch is good enough to be accepted.

lib/AST/ASTImporter.cpp

3422

Consider using unsigned instead of int to avoid MSVC warning about mix of signed and unsigned types.

[a.sidorin]

Fix signed/unsigned mismatch warning in the loop condition.

[a.sidorin]

Serge, Sean, is this patch OK to commit?

[sepavloff]

LGTM.

[spyffe]

Yes, I look forward to testing this in LLDB. Thanks for your hard work.

[khazem]

I'm updating this patch so that it rebases cleanly onto master, as this patch hasn't been updated for a couple of months...

At the time of writing, one of Clang's tests is failing with this patch. Specifically, there is a segfault at line 130 of test/ASTMerge/Inputs/exprs3.cpp. I'm working on getting this fixed now.

[a.sidorin]

Don't hurry. The segfault is fixed already and patch waits for approval: https://reviews.llvm.org/D24807. I'll update this fix in Monday.

[a.sidorin]

Merge patch D24807 to both fix segmentation fault and provide a test for it.

[ABataev]

lib/AST/ASTImporter.cpp

3414

CXXRecordDecl *RD -> auto *RD

5569

No need for 'else' here, unconditional statement

5583

Remove '/*TemplateArgs=*/' comment, it is not required anymore

[a.sidorin]

Address review comments; add accidentally missed file.

[aaron.ballman]

LGTM with two minor nits.

lib/AST/ASTImporter.cpp

5563–5564

Any particular reason not to use a range-based for loop over template_arguments()?

6283

Spurious newline.

[a.sidorin]

Committed after Aaron's comment were addressed. Big thanks to all reviewers!

include/clang/AST/ASTImporter.h

 
 namespace clang {
   class ASTContext;
+  class CXXBaseSpecifier;
   class Decl;
   class DeclContext;
   class DiagnosticsEngine;

   class ASTImporter {
   public:
     typedef llvm::DenseSet<std::pair<Decl *, Decl *> > NonEquivalentDeclSet;
-    
+    typedef llvm::DenseMap<const CXXBaseSpecifier *, CXXBaseSpecifier *>
+    ImportedCXXBaseSpecifierMap;
+
   private:
     /// \brief The contexts we're importing to and from.
     ASTContext &ToContext, &FromContext;

     /// \brief Mapping from the already-imported FileIDs in the "from" source
     /// manager to the corresponding FileIDs in the "to" source manager.
     llvm::DenseMap<FileID, FileID> ImportedFileIDs;
-    
+    /// \brief Mapping from the already-imported CXXBasesSpecifier in
+    ///  the "from" source manager to the corresponding CXXBasesSpecifier
+    ///  in the "to" source manager.
+    ImportedCXXBaseSpecifierMap ImportedCXXBaseSpecifiers;
+
     /// \brief Imported, anonymous tag declarations that are missing their 
     /// corresponding typedefs.
     SmallVector<TagDecl *, 4> AnonTagsWithPendingTypedefs;

     /// \returns the equivalent file ID in the source manager of the "to"
     /// context.
     FileID Import(FileID);
-    
+    /// \brief Import the given CXXBaseSpecifier from the "from" context into
+    /// the "to" context.
+    ///
+    /// \returns the equivalent CXXBaseSpecifier in the source manager of the
+    /// "to" context.
+    CXXBaseSpecifier *Import(const CXXBaseSpecifier *FromSpec);
+
     /// \brief Import the definition of the given declaration, including all of
     /// the declarations it contains.
     ///

lib/AST/ASTImporter.cpp

                                   DeclarationNameInfo& To);
     void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
 
+    bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
+
     typedef DesignatedInitExpr::Designator Designator;
     Designator ImportDesignator(const Designator &D);
 

     Expr *VisitBinaryOperator(BinaryOperator *E);
     Expr *VisitConditionalOperator(ConditionalOperator *E);
     Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
+    Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
+    Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
+    Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
+    Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
     Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
     Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
-    Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
+    Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
+    Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
+    Expr *VisitOffsetOfExpr(OffsetOfExpr *E);
+    Expr *VisitCXXThisExpr(CXXThisExpr *E);
+    Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
+    Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
+    Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
+    Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
+    Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
+    Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
+    Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
     Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
     Expr *VisitMemberExpr(MemberExpr *E);
     Expr *VisitCallExpr(CallExpr *E);

         T, E->getValueKind(), E->getObjectKind());
 }
 
+Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
+  if (!ToQueried)
+    return nullptr;
+
+  Expr *Dim = Importer.Import(E->getDimensionExpression());
+  if (!Dim && E->getDimensionExpression())
+    return nullptr;
+
+  return new (Importer.getToContext()) ArrayTypeTraitExpr(
+        Importer.Import(E->getExprLoc()), E->getTrait(), ToQueried,
+        E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
+}
+
+Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *ToQueried = Importer.Import(E->getQueriedExpression());
+  if (!ToQueried)
+    return nullptr;
+
+  return new (Importer.getToContext()) ExpressionTraitExpr(
+        Importer.Import(E->getExprLoc()), E->getTrait(), ToQueried,
+        E->getValue(), Importer.Import(E->getLocEnd()), T);
+}
+
+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::VisitArraySubscriptExpr(ArraySubscriptExpr *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;
+
+  return new (Importer.getToContext()) ArraySubscriptExpr(
+        ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
+        Importer.Import(E->getRBracketLoc()));
+}
+
 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())

                                                E->isFPContractable());
 }
 
-static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
-  if (E->path_empty()) return false;
-
-  // TODO: import cast paths
-  return true;
+bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
+  for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
+    if (CXXBaseSpecifier *Spec = Importer.Import(*I))
+      Path.push_back(Spec);
+    else
+      return true;
+  }
+  return false;
 }
 
 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {

                                   SubExpr, &BasePath, E->getValueKind());
 }
 
-Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
+Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   QualType T = Importer.Import(E->getType());
   if (T.isNull())
     return nullptr;

   if (ImportCastPath(E, BasePath))
     return nullptr;
 
-  return CStyleCastExpr::Create(Importer.getToContext(), T,
-                                E->getValueKind(), E->getCastKind(),
-                                SubExpr, &BasePath, TInfo,
-                                Importer.Import(E->getLParenLoc()),
-                                Importer.Import(E->getRParenLoc()));
+  switch (E->getStmtClass()) {
+  case Stmt::CStyleCastExprClass: {
+    CStyleCastExpr *CCE = cast<CStyleCastExpr>(E);
+    return CStyleCastExpr::Create(Importer.getToContext(), T,
+                                  E->getValueKind(), E->getCastKind(),
+                                  SubExpr, &BasePath, TInfo,
+                                  Importer.Import(CCE->getLParenLoc()),
+                                  Importer.Import(CCE->getRParenLoc()));
+  }
+
+  case Stmt::CXXFunctionalCastExprClass: {
+    CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E);
+    return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
+                                         E->getValueKind(), TInfo,
+                                         E->getCastKind(), SubExpr, &BasePath,
+                                         Importer.Import(FCE->getLParenLoc()),
+                                         Importer.Import(FCE->getRParenLoc()));
+  }
+
+  case Stmt::ObjCBridgedCastExprClass: {
+      ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E);
+      return new (Importer.getToContext()) ObjCBridgedCastExpr(
+            Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
+            E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
+            TInfo, SubExpr);
+  }
+  default:
+    break; // just fall through
+  }
+
+  CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E);
+  SourceLocation ExprLoc = Importer.Import(Named->getExprLoc()),
+      RParenLoc = Importer.Import(Named->getRParenLoc());
+  SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
+
+  switch (E->getStmtClass()) {
+  case Stmt::CXXStaticCastExprClass:
+    return CXXStaticCastExpr::Create(Importer.getToContext(), T,
+                                     E->getValueKind(), E->getCastKind(),
+                                     SubExpr, &BasePath, TInfo,
+                                     ExprLoc, RParenLoc, Brackets);
+
+  case Stmt::CXXDynamicCastExprClass:
+    return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
+                                      E->getValueKind(), E->getCastKind(),
+                                      SubExpr, &BasePath, TInfo,
+                                      ExprLoc, RParenLoc, Brackets);
+
+  case Stmt::CXXReinterpretCastExprClass:
+    return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
+                                          E->getValueKind(), E->getCastKind(),
+                                          SubExpr, &BasePath, TInfo,
+                                          ExprLoc, RParenLoc, Brackets);
+
+  case Stmt::CXXConstCastExprClass:
+    return CXXConstCastExpr::Create(Importer.getToContext(), T,
+                                    E->getValueKind(), SubExpr, TInfo, ExprLoc,
+                                    RParenLoc, Brackets);
+  default:
+    llvm_unreachable("Cast expression of unsupported type!");
+    return nullptr;
+  }
+}
+
+Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  return new (Importer.getToContext()) ImplicitValueInitExpr(T);
+}
+
+
+Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  SmallVector<OffsetOfExpr::OffsetOfNode, 4> Nodes;
+  for (int i = 0, e = E->getNumComponents(); i < e; ++i) {
+    const OffsetOfExpr::OffsetOfNode &Node = E->getComponent(i);
+    switch (Node.getKind()) {
+    case OffsetOfExpr::OffsetOfNode::Array:
+      Nodes.push_back(OffsetOfExpr::OffsetOfNode(
+                        Importer.Import(Node.getLocStart()),
+                        Node.getArrayExprIndex(),
+                        Importer.Import(Node.getLocEnd())));
+      break;
+    case OffsetOfExpr::OffsetOfNode::Base: {
+      CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
+      if (!BS && Node.getBase())
+        return nullptr;
+      Nodes.push_back(OffsetOfExpr::OffsetOfNode(BS));
+      break;
+    }
+    case OffsetOfExpr::OffsetOfNode::Field: {
+      FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
+      if (!FD)
+        return nullptr;
+      Nodes.push_back(OffsetOfExpr::OffsetOfNode(
+                    Importer.Import(Node.getLocStart()), FD,
+                    Importer.Import(Node.getLocEnd())));
+      break;
+    }
+    case OffsetOfExpr::OffsetOfNode::Identifier: {
+      IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
+      if (ToII)
+        return nullptr;
+      Nodes.push_back(OffsetOfExpr::OffsetOfNode(
+                        Importer.Import(Node.getLocStart()), ToII,
+                        Importer.Import(Node.getLocEnd())));
+      break;
+    }
+    }
+  }
+
+  SmallVector<Expr *, 4> Exprs(E->getNumExpressions());
+  for (int i = 0, e = E->getNumExpressions(); i < e; ++i) {
+    Expr *ToIndexExpr = Importer.Import(E->getIndexExpr(i));
+    if (!ToIndexExpr)
+      return nullptr;
+    Exprs[i] = ToIndexExpr;
+  }
+
+  TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
+  if (!TInfo && E->getTypeSourceInfo())
+    return nullptr;
+
+  return OffsetOfExpr::Create(Importer.getToContext(), T,
+                              Importer.Import(E->getOperatorLoc()),
+                              TInfo, Nodes, Exprs,
+                              Importer.Import(E->getRParenLoc()));
+}
+
+Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  return new (Importer.getToContext()) CXXThisExpr(
+        Importer.Import(E->getExprLoc()), T, E->isImplicit());
+}
+
+Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *Operand = Importer.Import(E->getOperand());
+  if (!Operand)
+    return nullptr;
+
+  // We cannot get source CanThrowVal so correction is required after init
+  CXXNoexceptExpr *ToE = new (Importer.getToContext()) CXXNoexceptExpr(
+        T, Operand, E->getValue() ? CT_Cannot : CT_Dependent,
+        Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
+  ToE->setInstantiationDependent(E->isInstantiationDependent());
+  ToE->setValueDependent(E->isValueDependent());
+  return ToE;
+}
+
+Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *SubExpr = Importer.Import(E->getSubExpr());
+  if (!SubExpr && E->getSubExpr())
+    return nullptr;
+
+  return new (Importer.getToContext()) CXXThrowExpr(
+        SubExpr, T, Importer.Import(E->getExprLoc()),
+        E->isThrownVariableInScope());
+}
+
+Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
+  ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
+  if (!Param && E->getParam())
+    return nullptr;
+
+  Expr *SubExpr = Importer.Import(E->getExpr());
+  if (!SubExpr && E->getExpr())
+    return nullptr;
+
+  return CXXDefaultArgExpr::Create(
+        Importer.getToContext(), Importer.Import(E->getExprLoc()),
+        Param, SubExpr);
+}
+
+Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
+  if (!TypeInfo)
+    return nullptr;
+
+  return new (Importer.getToContext()) CXXScalarValueInitExpr(
+        T, TypeInfo, Importer.Import(E->getRParenLoc()));
+}
+
+Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
+  Expr *SubExpr = Importer.Import(E->getSubExpr());
+  if (!SubExpr)
+    return nullptr;
+
+  auto *Dtor = cast_or_null<CXXDestructorDecl>(
+        Importer.Import(const_cast<CXXDestructorDecl *>(
+                          E->getTemporary()->getDestructor())));
+  if (!Dtor)
+    return nullptr;
+
+  ASTContext &ToCtx = Importer.getToContext();
+  CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
+  return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
+}
+
+Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
+  QualType T = Importer.Import(CE->getType());
+  if (T.isNull())
+    return nullptr;
+
+  SmallVector<Expr *, 8> Args(CE->getNumArgs());
+  ImportMultipleItems<Expr *>(CE->arg_begin(), CE->arg_end(), Args.begin());
+  if (!checkNull(Args.begin(), Args.end()))
+    return nullptr;
+
+  auto *Ctor = cast_or_null<CXXConstructorDecl>(
+        Importer.Import(CE->getConstructor()));
+  if (!Ctor)
+    return nullptr;
+
+  return CXXTemporaryObjectExpr::Create(
+        Importer.getToContext(), T,
+        Importer.Import(CE->getExprLoc()),
+        Ctor,
+        CE->isElidable(),
+        Args,
+        CE->hadMultipleCandidates(),
+        CE->isListInitialization(),
+        CE->isStdInitListInitialization(),
+        CE->requiresZeroInitialization(),
+        CE->getConstructionKind(),
+        Importer.Import(CE->getParenOrBraceRange()));
+}
+
+Expr *
+ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
+  QualType T = Importer.Import(E->getType());
+  if (T.isNull())
+    return nullptr;
+
+  Expr *TempE = Importer.Import(E->GetTemporaryExpr());
+  if (!TempE)
+    return nullptr;
+
+  ValueDecl *ExtendedBy = cast_or_null<ValueDecl>(
+        Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
+  if (!ExtendedBy && E->getExtendingDecl())
+    return nullptr;
+
+  auto *ToMTE =  new (Importer.getToContext()) MaterializeTemporaryExpr(
+        T, TempE, E->isBoundToLvalueReference());
+  ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
+  return ToMTE;
 }
 
 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {

   return ToID;
 }
 
+CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
+  auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
+  if (Pos != ImportedCXXBaseSpecifiers.end())
+    return Pos->second;
+
+  CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
+        Import(BaseSpec->getSourceRange()),
+        BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
+        BaseSpec->getAccessSpecifierAsWritten(),
+        Import(BaseSpec->getTypeSourceInfo()),
+        Import(BaseSpec->getEllipsisLoc()));
+  ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
+  return Imported;
+}
+
 void ASTImporter::ImportDefinition(Decl *From) {
   Decl *To = Import(From);
   if (!To)