3 files changed, 37 insertions, 28 deletions

diff --git a/clang/lib/Sema/Sema.h b/clang/lib/Sema/Sema.h
index b7b70bfc44e..31c2aafd6ca 100644
--- a/clang/lib/Sema/Sema.h
+++ b/clang/lib/Sema/Sema.h
@@ -542,6 +542,9 @@ public:
                                                  SourceLocation EqualLoc,
                                                  SourceLocation ArgLoc);
   virtual void ActOnParamDefaultArgumentError(DeclPtrTy param);
+  bool SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
+                               SourceLocation EqualLoc);
+
   
   // Contains the locations of the beginning of unparsed default
   // argument locations.
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index a25a83a9954..5452963fad0 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -101,6 +101,34 @@ namespace {
   }
 }
 
+bool
+Sema::SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
+                              SourceLocation EqualLoc)
+{
+  QualType ParamType = Param->getType();
+
+  Expr *Arg = (Expr *)DefaultArg.get();
+  
+  // C++ [dcl.fct.default]p5
+  //   A default argument expression is implicitly converted (clause
+  //   4) to the parameter type. The default argument expression has
+  //   the same semantic constraints as the initializer expression in
+  //   a declaration of a variable of the parameter type, using the
+  //   copy-initialization semantics (8.5).
+  if (CheckInitializerTypes(Arg, ParamType, EqualLoc, 
+                            Param->getDeclName(), /*DirectInit=*/false))
+    return false;
+
+  Arg = MaybeCreateCXXExprWithTemporaries(Arg, /*DestroyTemps=*/false);
+  
+  // Okay: add the default argument to the parameter
+  Param->setDefaultArg(Arg);
+  
+  DefaultArg.release();
+  
+  return true;
+}
+
 /// ActOnParamDefaultArgument - Check whether the default argument
 /// provided for a function parameter is well-formed. If so, attach it
 /// to the parameter declaration.
@@ -131,30 +159,7 @@ Sema::ActOnParamDefaultArgument(DeclPtrTy param, SourceLocation EqualLoc,
     return;
   }
   
-  // C++ [dcl.fct.default]p5
-  //   A default argument expression is implicitly converted (clause
-  //   4) to the parameter type. The default argument expression has
-  //   the same semantic constraints as the initializer expression in
-  //   a declaration of a variable of the parameter type, using the
-  //   copy-initialization semantics (8.5).
-  Expr *DefaultArgPtr = DefaultArg.get();
-  bool DefaultInitFailed = CheckInitializerTypes(DefaultArgPtr, ParamType,
-                                                 EqualLoc,
-                                                 Param->getDeclName(),
-                                                 /*DirectInit=*/false);
-  if (DefaultArgPtr != DefaultArg.get()) {
-    DefaultArg.take();
-    DefaultArg.reset(DefaultArgPtr);
-  }
-  if (DefaultInitFailed) {
-    return;
-  }
-
-  DefaultArgPtr = MaybeCreateCXXExprWithTemporaries(DefaultArg.take(),
-                                                    /*DestroyTemps=*/false);
-  
-  // Okay: add the default argument to the parameter
-  Param->setDefaultArg(DefaultArgPtr);
+  SetParamDefaultArgument(Param, move(DefaultArg), EqualLoc);
 }
 
 /// ActOnParamUnparsedDefaultArgument - We've seen a default
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index d9add06ee14..04a15054430 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -2492,14 +2492,15 @@ Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
       if (PerformCopyInitialization(Arg, ProtoArgType, "passing"))
         return true;
     } else {
-      if (FDecl->getParamDecl(i)->hasUnparsedDefaultArg()) {
+      ParmVarDecl *Param = FDecl->getParamDecl(i);
+      if (Param->hasUnparsedDefaultArg()) {
         Diag (Call->getSourceRange().getBegin(),
               diag::err_use_of_default_argument_to_function_declared_later) <<
         FDecl << cast<CXXRecordDecl>(FDecl->getDeclContext())->getDeclName();
-        Diag(UnparsedDefaultArgLocs[FDecl->getParamDecl(i)], 
+        Diag(UnparsedDefaultArgLocs[Param], 
               diag::note_default_argument_declared_here);
       } else {
-        Expr *DefaultExpr = FDecl->getParamDecl(i)->getDefaultArg();
+        Expr *DefaultExpr = Param->getDefaultArg();
         
         // If the default expression creates temporaries, we need to
         // push them to the current stack of expression temporaries so they'll
@@ -2514,7 +2515,7 @@ Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
       }
   
       // We already type-checked the argument, so we know it works.
-      Arg = CXXDefaultArgExpr::Create(Context, FDecl->getParamDecl(i));
+      Arg = CXXDefaultArgExpr::Create(Context, Param);
     }
     
     QualType ArgType = Arg->getType();