Eliminate the non-InitializedEntity PerformCopyInitialization() and

re-route its only caller to the newer
PerformCopyInitialization(). We're down to one remaining caller of
Sema::CheckReferenceInit.

llvm-svn: 99650

clang/lib/Sema/Sema.h

@@ -1101,9 +1101,6 @@ public:
                         bool SuppressUserConversions, bool ForceRValue,
                         bool InOverloadResolution);
   
-  bool PerformCopyInitialization(Expr *&From, QualType ToType,
-                                 AssignmentAction Action, bool Elidable = false);
-
   OwningExprResult PerformCopyInitialization(const InitializedEntity &Entity,
                                              SourceLocation EqualLoc,
                                              OwningExprResult Init);

clang/lib/Sema/SemaExprCXX.cpp

@@ -1062,10 +1062,15 @@ bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
     // Watch out for variadic allocator function.
     unsigned NumArgsInFnDecl = FnDecl->getNumParams();
     for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) {
-      if (PerformCopyInitialization(Args[i],
-                                    FnDecl->getParamDecl(i)->getType(),
-                                    AA_Passing))
+      OwningExprResult Result
+        = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+                                                       FnDecl->getParamDecl(i)),
+                                    SourceLocation(),
+                                    Owned(Args[i]->Retain()));
+      if (Result.isInvalid())
         return true;
+      
+      Args[i] = Result.takeAs<Expr>();
     }
     Operator = FnDecl;
     CheckAllocationAccess(StartLoc, Range, R.getNamingClass(), Best->FoundDecl);

clang/lib/Sema/SemaOverload.cpp

@@ -2201,44 +2201,6 @@ Sema::TryCopyInitialization(Expr *From, QualType ToType,
   }
 }
 
-/// PerformCopyInitialization - Copy-initialize an object of type @p ToType with
-/// the expression @p From. Returns true (and emits a diagnostic) if there was
-/// an error, returns false if the initialization succeeded. Elidable should
-/// be true when the copy may be elided (C++ 12.8p15). Overload resolution works
-/// differently in C++0x for this case.
-bool Sema::PerformCopyInitialization(Expr *&From, QualType ToType,
-                                     AssignmentAction Action, bool Elidable) {
-  if (!getLangOptions().CPlusPlus) {
-    // In C, argument passing is the same as performing an assignment.
-    QualType FromType = From->getType();
-
-    AssignConvertType ConvTy =
-      CheckSingleAssignmentConstraints(ToType, From);
-    if (ConvTy != Compatible &&
-        CheckTransparentUnionArgumentConstraints(ToType, From) == Compatible)
-      ConvTy = Compatible;
-
-    return DiagnoseAssignmentResult(ConvTy, From->getLocStart(), ToType,
-                                    FromType, From, Action);
-  }
-
-  if (ToType->isReferenceType())
-    return CheckReferenceInit(From, ToType,
-                              /*FIXME:*/From->getLocStart(),
-                              /*SuppressUserConversions=*/false,
-                              /*AllowExplicit=*/false,
-                              /*ForceRValue=*/false);
-
-  if (!PerformImplicitConversion(From, ToType, Action,
-                                 /*AllowExplicit=*/false, Elidable))
-    return false;
-  if (!DiagnoseMultipleUserDefinedConversion(From, ToType))
-    return Diag(From->getSourceRange().getBegin(),
-                diag::err_typecheck_convert_incompatible)
-      << ToType << From->getType() << Action << From->getSourceRange();
-  return true;
-}
-
 /// TryObjectArgumentInitialization - Try to initialize the object
 /// parameter of the given member function (@c Method) from the
 /// expression @p From.