Changes after running performance-returning-type check on LLVM codebase.

[staronj]

Summary

Merged diff from LLVM and clang repos after running performance-returning-type check on LLVM codebase.

[Prazek]

This looks good to me. I will take a closer look at implementation later to see if you are not skiping any case.

lib/Analysis/MemoryBuiltins.cpp

15

diff-clang-format.
For example this include should be under the rest, and clang-format should fix it.

lib/Analysis/MemoryBuiltins.cpp

 //===------ MemoryBuiltins.cpp - Identify calls to memory builtins --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This family of functions identifies calls to builtin functions that allocate
 // or free memory.
 //
 //===----------------------------------------------------------------------===//
 
+#include <utility>
+
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"

     return std::make_pair(ConstantInt::get(Context, Const.first),
                           ConstantInt::get(Context, Const.second));
 
   V = V->stripPointerCasts();
 
   // check cache
   CacheMapTy::iterator CacheIt = CacheMap.find(V);
   if (CacheIt != CacheMap.end())
-    return CacheIt->second;
+    return SizeOffsetEvalType(std::move(CacheIt->second));
 
   // always generate code immediately before the instruction being
   // processed, so that the generated code dominates the same BBs
   BuilderTy::InsertPointGuard Guard(Builder);
   if (Instruction *I = dyn_cast<Instruction>(V))
     Builder.SetInsertPoint(I);
 
   // now compute the size and offset

lib/CodeGen/MachineBasicBlock.cpp

 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <algorithm>
+#include <utility>
 using namespace llvm;
 
 #define DEBUG_TYPE "codegen"
 
 MachineBasicBlock::MachineBasicBlock(MachineFunction &MF, const BasicBlock *B)
     : BB(B), Number(-1), xParent(&MF) {
   Insts.Parent = this;
 }

 }
 
 MachineBasicBlock::iterator MachineBasicBlock::getFirstNonPHI() {
   instr_iterator I = instr_begin(), E = instr_end();
   while (I != E && I->isPHI())
     ++I;
   assert((I == E || !I->isInsideBundle()) &&
          "First non-phi MI cannot be inside a bundle!");
-  return I;
+  return MachineBasicBlock::iterator(std::move(I));
 }
 
 MachineBasicBlock::iterator
 MachineBasicBlock::SkipPHIsAndLabels(MachineBasicBlock::iterator I) {
   iterator E = end();
   while (I != E && (I->isPHI() || I->isPosition() || I->isDebugValue()))
     ++I;
   // FIXME: This needs to change if we wish to bundle labels / dbg_values

 MachineBasicBlock::iterator MachineBasicBlock::getLastNonDebugInstr() {
   // Skip over end-of-block dbg_value instructions.
   instr_iterator B = instr_begin(), I = instr_end();
   while (I != B) {
     --I;
     // Return instruction that starts a bundle.
     if (I->isDebugValue() || I->isInsideBundle())
       continue;
-    return I;
+    return MachineBasicBlock::iterator(std::move(I));
   }
   // The block is all debug values.
   return end();
 }
 
 bool MachineBasicBlock::hasEHPadSuccessor() const {
   for (const_succ_iterator I = succ_begin(), E = succ_end(); I != E; ++I)
     if ((*I)->isEHPad())

lib/Parse/ParseDeclCXX.cpp

 //===--- ParseDeclCXX.cpp - C++ Declaration Parsing -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the C++ Declaration portions of the Parser interfaces.
 //
 //===----------------------------------------------------------------------===//
 
+#include <utility>
+
 #include "clang/Parse/Parser.h"
 #include "RAIIObjectsForParser.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/TargetInfo.h"

       AnnotateTemplateIdTokenAsType();
 
       assert(Tok.is(tok::annot_typename) && "template-id -> type failed");
       ParsedType Type = getTypeAnnotation(Tok);
       EndLocation = Tok.getAnnotationEndLoc();
       ConsumeToken();
 
       if (Type)
-        return Type;
+        return TypeResult(std::move(Type));
       return true;
     }
 
     // Fall through to produce an error below.
   }
 
   if (Tok.isNot(tok::identifier)) {
     Diag(Tok, diag::err_expected_class_name);

     if (Tok.isNot(tok::annot_typename))
       return true;
 
     // Retrieve the type from the annotation token, consume that token, and
     // return.
     EndLocation = Tok.getAnnotationEndLoc();
     ParsedType Type = getTypeAnnotation(Tok);
     ConsumeToken();
-    return Type;
+    return TypeResult(std::move(Type));
   }
 
   // We have an identifier; check whether it is actually a type.
   IdentifierInfo *CorrectedII = nullptr;
   ParsedType Type =
       Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, true, false, nullptr,
                           /*IsCtorOrDtorName=*/false,
                           /*NonTrivialTypeSourceInfo=*/true, &CorrectedII);

lib/Sema/SemaDecl.cpp

 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/Template.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
 #include <algorithm>
 #include <cstring>
 #include <functional>
+#include <utility>
 
 using namespace clang;
 using namespace sema;
 
 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
   if (OwnedType) {
     Decl *Group[2] = { OwnedType, Ptr };
     return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));

   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
   LookupParsedName(Result, S, &SS, !CurMethod);
 
   // For unqualified lookup in a class template in MSVC mode, look into
   // dependent base classes where the primary class template is known.
   if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
     if (ParsedType TypeInBase =
             recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
-      return TypeInBase;
+      return Sema::NameClassification(std::move(TypeInBase));
   }
 
   // Perform lookup for Objective-C instance variables (including automatically
   // synthesized instance variables), if we're in an Objective-C method.
   // FIXME: This lookup really, really needs to be folded in to the normal
   // unqualified lookup mechanism.
   if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
     ExprResult E = LookupInObjCMethod(Result, S, Name, true);
     if (E.get() || E.isInvalid())
-      return E;
+      return Sema::NameClassification(std::move(E));
   }
 
   bool SecondTry = false;
   bool IsFilteredTemplateName = false;
 
 Corrected:
   switch (Result.getResultKind()) {
   case LookupResult::NotFound:

 
         // If we found an Objective-C instance variable, let
         // LookupInObjCMethod build the appropriate expression to
         // reference the ivar.
         // FIXME: This is a gross hack.
         if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
           Result.clear();
           ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
-          return E;
+          return Sema::NameClassification(std::move(E));
         }
 
         goto Corrected;
       }
     }
 
     // We failed to correct; just fall through and let the parser deal with it.
     Result.suppressDiagnostics();

lib/Sema/SemaTemplate.cpp

 //===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ templates.
 //===----------------------------------------------------------------------===//
 
+#include <utility>
+
 #include "TreeTransform.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"

 
 static SourceRange findTemplateParameter(unsigned Depth, Expr *E) {
   if (!E->isInstantiationDependent())
     return SourceLocation();
   DependencyChecker Checker(Depth);
   Checker.TraverseStmt(E);
   if (Checker.Match && Checker.MatchLoc.isInvalid())
     return E->getSourceRange();
-  return Checker.MatchLoc;
+  return clang::SourceRange(std::move(Checker.MatchLoc));
 }
 
 static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL) {
   if (!TL.getType()->isDependentType())
     return SourceLocation();
   DependencyChecker Checker(Depth);
   Checker.TraverseTypeLoc(TL);
   if (Checker.Match && Checker.MatchLoc.isInvalid())
     return TL.getSourceRange();
-  return Checker.MatchLoc;
+  return clang::SourceRange(std::move(Checker.MatchLoc));
 }
 
 /// \brief Subroutine of Sema::CheckTemplatePartialSpecializationArgs
 /// that checks non-type template partial specialization arguments.
 static bool CheckNonTypeTemplatePartialSpecializationArgs(
     Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
     const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
   for (unsigned I = 0; I != NumArgs; ++I) {

lib/Sema/SemaType.cpp

 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements type-related semantic analysis.
 //
 //===----------------------------------------------------------------------===//
 
+#include <utility>
+
 #include "TypeLocBuilder.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"

       TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
       ProtocolLAngleLoc,
       llvm::makeArrayRef((ObjCProtocolDecl * const *)Protocols.data(),
                          Protocols.size()),
       ProtocolLocs, ProtocolRAngleLoc,
       /*FailOnError=*/false);
 
   if (Result == T)
-    return BaseType;
+    return TypeResult(std::move(BaseType));
     
   // Create source information for this type.
   TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
   TypeLoc ResultTL = ResultTInfo->getTypeLoc();
 
   // For id<Proto1, Proto2> or Class<Proto1, Proto2>, we'll have an
   // object pointer type. Fill in source information for it.
   if (auto ObjCObjectPointerTL = ResultTL.getAs<ObjCObjectPointerTypeLoc>()) {