diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index a5a0723..2ed90d0 100644
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -766,8 +766,7 @@
 
   ImplicitConversionSequence 
   TryCopyInitialization(Expr* From, QualType ToType,
-                        bool SuppressUserConversions = false,
-                        bool ForceRValue = false);
+                        bool SuppressUserConversions, bool ForceRValue);
   bool PerformCopyInitialization(Expr *&From, QualType ToType, 
                                  const char *Flavor, bool Elidable = false);
 
diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 8592494..870041d 100644
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -1228,7 +1228,9 @@
       // Could still fail if there's no copy constructor.
       // FIXME: Is this a hard error then, or just a conversion failure? The
       // standard doesn't say.
-      ICS = Self.TryCopyInitialization(From, TTy);
+      ICS = Self.TryCopyInitialization(From, TTy, 
+                                       /*SuppressUserConversions=*/false,
+                                       /*ForceRValue=*/false);
     }
   } else {
     //     -- Otherwise: E1 can be converted to match E2 if E1 can be
diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 405dd84..fb00008 100644
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -661,7 +661,10 @@
       //   an initializer-list. If the initializer can initialize a
       //   member, the member is initialized. [...]
       ImplicitConversionSequence ICS 
-        = SemaRef.TryCopyInitialization(expr, ElemType);
+        = SemaRef.TryCopyInitialization(expr, ElemType,
+                                        /*SuppressUserConversions=*/false,
+                                        /*ForceRValue=*/false);
+
       if (ICS.ConversionKind != ImplicitConversionSequence::BadConversion) {
         if (SemaRef.PerformImplicitConversion(expr, ElemType, ICS, 
                                                "initializing"))
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index dde5c28..52010ab 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -2430,7 +2430,11 @@
   CallExpr Call(Context, &ConversionFn, 0, 0, 
                 Conversion->getConversionType().getNonReferenceType(),
                 SourceLocation());
-  ImplicitConversionSequence ICS = TryCopyInitialization(&Call, ToType, true);
+  ImplicitConversionSequence ICS = 
+    TryCopyInitialization(&Call, ToType, 
+                          /*SuppressUserConversions=*/true,
+                          /*ForceRValue=*/false);
+  
   switch (ICS.ConversionKind) {
   case ImplicitConversionSequence::StandardConversion:
     Candidate.FinalConversion = ICS.Standard;
@@ -2543,7 +2547,8 @@
       QualType ParamType = Proto->getArgType(ArgIdx);
       Candidate.Conversions[ArgIdx + 1] 
         = TryCopyInitialization(Args[ArgIdx], ParamType, 
-                                /*SuppressUserConversions=*/false);
+                                /*SuppressUserConversions=*/false,
+                                /*ForceRValue=*/false);
       if (Candidate.Conversions[ArgIdx + 1].ConversionKind 
             == ImplicitConversionSequence::BadConversion) {
         Candidate.Viable = false;
@@ -2674,7 +2679,8 @@
     } else {
       Candidate.Conversions[ArgIdx] 
         = TryCopyInitialization(Args[ArgIdx], ParamTys[ArgIdx], 
-                                ArgIdx == 0 && IsAssignmentOperator);
+                                ArgIdx == 0 && IsAssignmentOperator,
+                                /*ForceRValue=*/false);
     }
     if (Candidate.Conversions[ArgIdx].ConversionKind 
         == ImplicitConversionSequence::BadConversion) {