[ASTImporter] ParmVarDecl default argument initialization

[szepet]

Summary

It was left as a FIXME but I do not exactly see why.
This simple solution worked in every case I experienced (small test cases and even on greater files).
If there is a more complex problem about this initialization please let me know.

[a.sidorin]

Hello Peter,
Thank you for working on this. Unfortunately, this patch is only a partial solution. Setting the initializer for ParmVarDecl is a bit more complicated because internally Init in ParmVarDecl is a large union; there is not simple initializer only, but different cases are handled. You can see the example of how it can be done on https://github.com/haoNoQ/clang/blob/summary-ipa-draft/lib/AST/ASTImporter.cpp#L4523. Hope this will be helpful. If you update your patch with adapting these changes, I will be happy to review it.
Also, I'd like to see some tests showing that the initializer is imported correctly. ASTImporter tests are placed into tests/ASTMerge. You can see some examples here.

[szepet]

Hello Aleksei,
thank you for the review and the advice!

I have adapted the linked changes and checked if there is anything else to set. Removed the the asserts since It is possible that the importer can not import the expression, but it will give a diag message to indicate it (whenever Complain is true). So in this version of the code in case we can not import the defaultarg then it will be set to nullptr.

Added a small test case where the given CXXDefaultArgExpr is imported. Without this change it fails when creating the expression since the given ParmVarDecl's default argument is null and it will be dereferenced. So that ensures us tat the parmVarDecls defarg is set.
I'm not sure how to test the other 2 cases (uninstantiated and unparsed args).

[szepet]

additional small test case added

[a.sidorin]

Looks very promising overall. I also like to see the tests here. There are some comments below.

lib/AST/ASTImporter.cpp

3896

If Expr * being imported can be null, then we can check the result in such manner:

if (FromExpr && !ToExpr)
  return nullptr;

3900

It's better to use consistent Expr * over the patch (with * sticked to the variable name).

[szepet]

Use one ToExpr and FromExpr in the patch.
Check for unsuccessful import added.

[a.sidorin]

This looks good to me. If there will be no any other review comments, I will commit. Thank you!

lib/AST/ASTImporter.cpp

if (T.isNull())
     return nullptr;
 
   // Create the imported parameter.
   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
   ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
                                      Importer.Import(D->getInnerLocStart()),
                                             Loc, Name.getAsIdentifierInfo(),
                                             T, TInfo, D->getStorageClass(),
-                                            /*FIXME: Default argument*/nullptr);
+                                            /*DefaultArg*/ nullptr);
+
+  // Set the default argument.
   ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
+  ToParm->setKNRPromoted(D->isKNRPromoted());
+
+  Expr *ToDefArg = nullptr;
+  Expr *FromDefArg = nullptr;
+  if (D->hasUninstantiatedDefaultArg()) {
+    FromDefArg = D->getUninstantiatedDefaultArg();
+    ToDefArg = Importer.Import(FromDefArg);
+    ToParm->setUninstantiatedDefaultArg(ToDefArg);
+  } else if (D->hasUnparsedDefaultArg()) {
+    ToParm->setUnparsedDefaultArg();
+  } else if (D->hasDefaultArg()) {
+    FromDefArg = D->getDefaultArg();
+    ToDefArg = Importer.Import(FromDefArg);
+    ToParm->setDefaultArg(ToDefArg);
+  }
+  if (FromDefArg && !ToDefArg)
+    return nullptr;
 
   if (D->isUsed())
     ToParm->setIsUsed();
 
   return Importer.Imported(D, ToParm);
 }
 
 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {

test/ASTMerge/exprs-cpp/Inputs/exprs3.cpp

void testOffsetOf() {
   __builtin_offsetof(struct T, s[2].d);
 }
 
 
 int testDefaultArg(int a = 2*2) {
   return a;
 }
 
+int testDefaultArgExpr() {
+  return testDefaultArg();
+}
+
 template <typename T> // T has TemplateTypeParmType
 void testTemplateTypeParmType(int i);
 
 void useTemplateType() {
   testTemplateTypeParmType<char>(4);
 }
 
 const bool ExpressionTrait = __is_lvalue_expr(1);
 const unsigned ArrayRank = __array_rank(int[10][20]);
 const unsigned ArrayExtent = __array_extent(int[10][20], 1);

test/ASTMerge/exprs-cpp/test.cpp

void testImport(int *x, const S1 &cs1, S1 &s1) {
   testTernaryOp(0, 1, 2);
   testConstCast(cs1);
   testStaticCast(s1);
   testReinterpretCast(s1);
   testDynamicCast(s1);
   testScalarInit(42);
   testOffsetOf();
   testDefaultArg(12);
+  testDefaultArg();
+  testDefaultArgExpr();
   useTemplateType();
 }