[Analyzer] Avoid copy and modifying passed reference in BodyFarm::create_call_once

[dcoughlin]

Looks great to me. Thanks George!

cfe/trunk/lib/Analysis/BodyFarm.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Creation functions for faux ASTs.
 //===----------------------------------------------------------------------===//
 
 typedef Stmt *(*FunctionFarmer)(ASTContext &C, const FunctionDecl *D);
 
-static CallExpr *
-create_call_once_funcptr_call(ASTContext &C, ASTMaker M,
+static CallExpr *create_call_once_funcptr_call(ASTContext &C, ASTMaker M,
                                                const ParmVarDecl *Callback,
-                              SmallVectorImpl<Expr *> &CallArgs) {
+                                               ArrayRef<Expr *> CallArgs) {
 
   return new (C) CallExpr(
       /*ASTContext=*/C,
       /*StmtClass=*/M.makeLvalueToRvalue(/*Expr=*/Callback),
       /*args=*/CallArgs,
       /*QualType=*/C.VoidTy,
       /*ExprValueType=*/VK_RValue,
       /*SourceLocation=*/SourceLocation());
 }
 
-static CallExpr *
-create_call_once_lambda_call(ASTContext &C, ASTMaker M,
-                             const ParmVarDecl *Callback, QualType CallbackType,
-                             SmallVectorImpl<Expr *> &CallArgs) {
+static CallExpr *create_call_once_lambda_call(ASTContext &C, ASTMaker M,
+                                              const ParmVarDecl *Callback,
+                                              QualType CallbackType,
+                                              ArrayRef<Expr *> CallArgs) {
 
   CXXRecordDecl *CallbackDecl = CallbackType->getAsCXXRecordDecl();
 
   assert(CallbackDecl != nullptr);
   assert(CallbackDecl->isLambda());
   FunctionDecl *callOperatorDecl = CallbackDecl->getLambdaCallOperator();
   assert(callOperatorDecl != nullptr);
 
   DeclRefExpr *callOperatorDeclRef =
       DeclRefExpr::Create(/* Ctx = */ C,
                           /* QualifierLoc = */ NestedNameSpecifierLoc(),
                           /* TemplateKWLoc = */ SourceLocation(),
                           const_cast<FunctionDecl *>(callOperatorDecl),
                           /* RefersToEnclosingVariableOrCapture= */ false,
                           /* NameLoc = */ SourceLocation(),
                           /* T = */ callOperatorDecl->getType(),
                           /* VK = */ VK_LValue);
 
-  CallArgs.insert(
-      CallArgs.begin(),
-      M.makeDeclRefExpr(Callback,
-                        /* RefersToEnclosingVariableOrCapture= */ true,
-                        /* GetNonReferenceType= */ true));
-
   return new (C)
       CXXOperatorCallExpr(/*AstContext=*/C, OO_Call, callOperatorDeclRef,
                           /*args=*/CallArgs,
                           /*QualType=*/C.VoidTy,
                           /*ExprValueType=*/VK_RValue,
                           /*SourceLocation=*/SourceLocation(), FPOptions());
 }
 
if (D->param_size() < 2)
     return nullptr;
 
   ASTMaker M(C);
 
   const ParmVarDecl *Flag = D->getParamDecl(0);
   const ParmVarDecl *Callback = D->getParamDecl(1);
   QualType CallbackType = Callback->getType().getNonReferenceType();
 
+  bool isLambdaCall = CallbackType->getAsCXXRecordDecl() &&
+                      CallbackType->getAsCXXRecordDecl()->isLambda();
+
   SmallVector<Expr *, 5> CallArgs;
 
+  if (isLambdaCall)
+    // Lambda requires callback itself inserted as a first parameter.
+    CallArgs.push_back(
+        M.makeDeclRefExpr(Callback,
+                          /* RefersToEnclosingVariableOrCapture= */ true,
+                          /* GetNonReferenceType= */ true));
+
   // All arguments past first two ones are passed to the callback.
   for (unsigned int i = 2; i < D->getNumParams(); i++)
     CallArgs.push_back(M.makeLvalueToRvalue(D->getParamDecl(i)));
 
   CallExpr *CallbackCall;
-  if (CallbackType->getAsCXXRecordDecl() &&
-      CallbackType->getAsCXXRecordDecl()->isLambda()) {
+  if (isLambdaCall) {
 
     CallbackCall =
         create_call_once_lambda_call(C, M, Callback, CallbackType, CallArgs);
   } else {
 
     // Function pointer case.
     CallbackCall = create_call_once_funcptr_call(C, M, Callback, CallArgs);
   }