[Sema] refactor static functions into private methods NFC

[nickdesaulniers]

Summary

While working in SemaStmt, I noticed a bunch of static functions are
passed *this, which is a code smell. Prefer private methods.

[aaron.ballman]

OTOH, this is reasonable, NFC, and I tend to agree about it being a code smell.
OTOH, this makes parsing Sema.h that much slower and adds even more text for us to wade through in that header file.

Given that the approaches are equivalent except for smell and that Sema.h is already 12kLoC long, I would rather leave this as-is or possibly even see us go in the opposite direction and use static functions whenever there's a private function only used in a single .cpp file and making it static doesn't make it overly awkward for some reason.

[nickdesaulniers]

In D77701#1969132, @aaron.ballman wrote:

OTOH, this is reasonable, NFC, and I tend to agree about it being a code smell.
OTOH, this makes parsing Sema.h that much slower and adds even more text for us to wade through in that header file.

Given that the approaches are equivalent except for smell and that Sema.h is already 12kLoC long, I would rather leave this as-is or possibly even see us go in the opposite direction and use static functions whenever there's a private function only used in a single .cpp file and making it static doesn't make it overly awkward for some reason.

Totally, this was a yak shave no one asked for. I was looking at DiagnoseNoDiscard in D77611. Fixing that case there then checking for other instances in the TU turned up more. I pulled a thread that unwound the sweater.

I don't have any attachment to this patch, so I'm ok with it being rejected. If there's concerns with Sema's compile time, please do consider splitting it up further though.

[aaron.ballman]

In D77701#1969687, @nickdesaulniers wrote:

In D77701#1969132, @aaron.ballman wrote:

OTOH, this is reasonable, NFC, and I tend to agree about it being a code smell.
OTOH, this makes parsing Sema.h that much slower and adds even more text for us to wade through in that header file.

Given that the approaches are equivalent except for smell and that Sema.h is already 12kLoC long, I would rather leave this as-is or possibly even see us go in the opposite direction and use static functions whenever there's a private function only used in a single .cpp file and making it static doesn't make it overly awkward for some reason.

Totally, this was a yak shave no one asked for. I was looking at DiagnoseNoDiscard in D77611. Fixing that case there then checking for other instances in the TU turned up more. I pulled a thread that unwound the sweater.

Heh, yeah, I've been there before.

I don't have any attachment to this patch, so I'm ok with it being rejected. If there's concerns with Sema's compile time, please do consider splitting it up further though.

I am curious to hear what other reviewers think, so I wouldn't reject based on my observations alone. I think splitting sema.h would be an interesting prospect, but the bulk of the file are declarations within the Sema class, so splitting may be nontrivial.

[dblaikie]

Yeah, if these were already member-function static, I'd agree it was a code smell - but function-scope static functions that take "this" as the first parameter don't seem like a bad thing to me - it reduces the header surface area/dependence.

clang/include/clang/Sema/Sema.h

bool CheckMemberPointerConversion(Expr *From, QualType ToType,
                                     bool IgnoreBaseAccess);
   bool IsQualificationConversion(QualType FromType, QualType ToType,
                                  bool CStyle, bool &ObjCLifetimeConversion);
   bool IsFunctionConversion(QualType FromType, QualType ToType,
                             QualType &ResultTy);
   bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
   bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
 
+  /// Try to perform the initialization of a potentially-movable value,
+  /// which is the operand to a return or throw statement.
+  ///
+  /// This routine implements C++14 [class.copy]p32, which attempts to treat
+  /// returned lvalues as rvalues in certain cases (to prefer move
+  /// construction), then falls back to treating them as lvalues if that failed.
+  ///
+  /// \param ConvertingConstructorsOnly If true, follow [class.copy]p32 and
+  /// reject resolutions that find non-constructors, such as derived-to-base
+  /// conversions or `operator T()&&` member functions. If false, do consider
+  /// such conversion sequences.
+  ///
+  /// \param Res We will fill this in if move-initialization was possible.
+  /// If move-initialization is not possible, such that we must fall back to
+  /// treating the operand as an lvalue, we will leave Res in its original
+  /// invalid state.
+  void TryMoveInitialization(const InitializedEntity &Entity,
+                             const VarDecl *NRVOCandidate, QualType ResultType,
+                             Expr *&Value, bool ConvertingConstructorsOnly,
+                             ExprResult &Res);
   ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
                                              const VarDecl *NRVOCandidate,
                                              QualType ResultType,
                                              Expr *Value,
                                              bool AllowNRVO = true);
 
   bool CanPerformAggregateInitializationForOverloadResolution(
       const InitializedEntity &Entity, InitListExpr *From);
public:
   StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
                          Stmt *InitStmt,
                          ConditionResult Cond, Stmt *ThenVal,
                          SourceLocation ElseLoc, Stmt *ElseVal);
   StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
                          Stmt *InitStmt,
                          ConditionResult Cond, Stmt *ThenVal,
                          SourceLocation ElseLoc, Stmt *ElseVal);
+  /// Check the specified case value is in range for the given unpromoted switch
+  /// type.
+  void CheckCaseValue(SourceLocation Loc, const llvm::APSInt &Val,
+                      unsigned UnpromotedWidth, bool UnpromotedSign);
   StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
                                     Stmt *InitStmt,
                                     ConditionResult Cond);
+  using EnumValsTy =
+      SmallVector<std::pair<llvm::APSInt, EnumConstantDecl *>, 64>;
+  /// Returns true if we should emit a diagnostic about this case expression not
+  /// being a part of the enum used in the switch controlling expression.
+  bool ShouldDiagnoseSwitchCaseNotInEnum(const EnumDecl *ED,
+                                         const Expr *CaseExpr,
+                                         EnumValsTy::iterator &EI,
+                                         EnumValsTy::iterator &EIEnd,
+                                         const llvm::APSInt &Val);
+  void CheckEnumTypesInSwitchStmt(const Expr *Cond, const Expr *Case);
   StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
                                            Stmt *Switch, Stmt *Body);
   StmtResult ActOnWhileStmt(SourceLocation WhileLoc, ConditionResult Cond,
                             Stmt *Body);
   StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
                          SourceLocation WhileLoc, SourceLocation CondLParen,
                          Expr *Cond, SourceLocation CondRParen);
 
   StmtResult ActOnForStmt(SourceLocation ForLoc,
                           SourceLocation LParenLoc,
                           Stmt *First,
                           ConditionResult Second,
                           FullExprArg Third,
                           SourceLocation RParenLoc,
                           Stmt *Body);
   ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
                                            Expr *collection);
   StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
                                         Stmt *First, Expr *collection,
                                         SourceLocation RParenLoc);
+  // Warn when the loop variable is a const reference that creates a copy.
+  // Suggest using the non-reference type for copies.  If a copy can be
+  // prevented suggest the const reference type that would do so. For instance,
+  // given "for (const &Foo : Range)", suggest "for (const Foo : Range)" to
+  // denote a copy is made for the loop.  If possible, also suggest "for (const
+  // &Bar : Range)" if this type prevents the copy altogether.
+  void DiagnoseForRangeReferenceVariableCopies(const VarDecl *VD,
+                                               QualType RangeInitType);
   StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
 
   enum BuildForRangeKind {
     /// Initial building of a for-range statement.
     BFRK_Build,
     /// Instantiation or recovery rebuild of a for-range statement. Don't
     /// attempt any typo-correction.
     BFRK_Rebuild,
     /// Determining whether a for-range statement could be built. Avoid any
     /// unnecessary or irreversible actions.
     BFRK_Check
   };
 
+  /// Build a variable declaration for a for-range statement.
+  VarDecl *BuildForRangeVarDecl(SourceLocation Loc, QualType Type,
+                                StringRef Name);
   StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
                                   SourceLocation CoawaitLoc,
                                   Stmt *InitStmt,
                                   Stmt *LoopVar,
                                   SourceLocation ColonLoc, Expr *Collection,
                                   SourceLocation RParenLoc,
                                   BuildForRangeKind Kind);
   StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
                                   SourceLocation CoawaitLoc,
                                   Stmt *InitStmt,
                                   SourceLocation ColonLoc,
                                   Stmt *RangeDecl, Stmt *Begin, Stmt *End,
                                   Expr *Cond, Expr *Inc,
                                   Stmt *LoopVarDecl,
                                   SourceLocation RParenLoc,
                                   BuildForRangeKind Kind);
+  // Warns when the loop variable can be changed to a reference type to prevent
+  // a copy.  For instance, if given "for (const Foo x : Range)" suggest
+  // "for (const Foo &x : Range)" if this form does not make a copy.
+  void DiagnoseForRangeConstVariableCopies(const VarDecl *VD);
+  /// DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
+  /// 1) for (const foo &x : foos) where foos only returns a copy.  Suggest
+  ///    using "const foo x" to show that a copy is made
+  /// 2) for (const bar &x : foos) where bar is a temporary initialized by bar.
+  ///    Suggest either "const bar x" to keep the copying or "const foo& x" to
+  ///    prevent the copy.
+  /// 3) for (const foo x : foos) where x is constructed from a reference foo.
+  ///    Suggest "const foo &x" to prevent the copy.
+  void DiagnoseForRangeVariableCopies(const CXXForRangeStmt *ForStmt);
   StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
 
   StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
                            SourceLocation LabelLoc,
                            LabelDecl *TheDecl);
   StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
                                    SourceLocation StarLoc,
                                    Expr *DestExp);
+  void CheckJumpOutOfSEHFinally(SourceLocation Loc, const Scope &DestScope);
   StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
   StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
 
+  bool
+  BuildCapturedStmtCaptureList(sema::CapturedRegionScopeInfo *RSI,
+                               SmallVectorImpl<CapturedStmt::Capture> &Captures,
+                               SmallVectorImpl<Expr *> &CaptureInits);
   void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
                                 CapturedRegionKind Kind, unsigned NumParams);
   typedef std::pair<StringRef, QualType> CapturedParamNameType;
   void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
                                 CapturedRegionKind Kind,
                                 ArrayRef<CapturedParamNameType> Params,
                                 unsigned OpenMPCaptureLevel = 0);
   StmtResult ActOnCapturedRegionEnd(Stmt *S);
public:
   void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
 
   bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
 
   /// If it's a file scoped decl that must warn if not used, keep track
   /// of it.
   void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
 
+  /// Diagnose unused comparisons, both builtin and overloaded operators.
+  /// For '==' and '!=', suggest fixits for '=' or '|='.
+  ///
+  /// Adding a cast to void (or other expression wrappers) will prevent the
+  /// warning from firing.
+  bool DiagnoseUnusedComparison(const Expr *E);
+  bool DiagnoseNoDiscard(const WarnUnusedResultAttr *A, SourceLocation Loc,
+                         SourceRange R1, SourceRange R2, bool IsCtor);
   /// DiagnoseUnusedExprResult - If the statement passed in is an expression
   /// whose result is unused, warn.
   void DiagnoseUnusedExprResult(const Stmt *S);
   void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
   void DiagnoseUnusedDecl(const NamedDecl *ND);
 
   /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
   /// statement as a \p Body, and it is located on the same line.

clang/lib/Sema/SemaStmt.cpp

if (getLangOpts().ObjCAutoRefCount) {
     if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) {
       // Add 'const' and mark the variable as pseudo-strong.
       var->setType(type.withConst());
       var->setARCPseudoStrong(true);
     }
   }
 }
 
-/// Diagnose unused comparisons, both builtin and overloaded operators.
-/// For '==' and '!=', suggest fixits for '=' or '|='.
-///
-/// Adding a cast to void (or other expression wrappers) will prevent the
-/// warning from firing.
-static bool DiagnoseUnusedComparison(Sema &S, const Expr *E) {
+bool Sema::DiagnoseUnusedComparison(const Expr *E) {
   SourceLocation Loc;
   bool CanAssign;
   enum { Equality, Inequality, Relational, ThreeWay } Kind;
 
   if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
     if (!Op->isComparisonOp())
       return false;
 
if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
     CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
   } else {
     // Not a typo-prone comparison.
     return false;
   }
 
   // Suppress warnings when the operator, suspicious as it may be, comes from
   // a macro expansion.
-  if (S.SourceMgr.isMacroBodyExpansion(Loc))
+  if (SourceMgr.isMacroBodyExpansion(Loc))
     return false;
 
-  S.Diag(Loc, diag::warn_unused_comparison)
+  Diag(Loc, diag::warn_unused_comparison)
       << (unsigned)Kind << E->getSourceRange();
 
   // If the LHS is a plausible entity to assign to, provide a fixit hint to
   // correct common typos.
   if (CanAssign) {
     if (Kind == Inequality)
-      S.Diag(Loc, diag::note_inequality_comparison_to_or_assign)
+      Diag(Loc, diag::note_inequality_comparison_to_or_assign)
           << FixItHint::CreateReplacement(Loc, "|=");
     else if (Kind == Equality)
-      S.Diag(Loc, diag::note_equality_comparison_to_assign)
+      Diag(Loc, diag::note_equality_comparison_to_assign)
           << FixItHint::CreateReplacement(Loc, "=");
   }
 
   return true;
 }
 
-static bool DiagnoseNoDiscard(Sema &S, const WarnUnusedResultAttr *A,
-                              SourceLocation Loc, SourceRange R1,
-                              SourceRange R2, bool IsCtor) {
+bool Sema::DiagnoseNoDiscard(const WarnUnusedResultAttr *A, SourceLocation Loc,
+                             SourceRange R1, SourceRange R2, bool IsCtor) {
   if (!A)
     return false;
   StringRef Msg = A->getMessage();
 
   if (Msg.empty()) {
     if (IsCtor)
-      return S.Diag(Loc, diag::warn_unused_constructor) << A << R1 << R2;
-    return S.Diag(Loc, diag::warn_unused_result) << A << R1 << R2;
+      return Diag(Loc, diag::warn_unused_constructor) << A << R1 << R2;
+    return Diag(Loc, diag::warn_unused_result) << A << R1 << R2;
   }
 
   if (IsCtor)
-    return S.Diag(Loc, diag::warn_unused_constructor_msg) << A << Msg << R1
-                                                          << R2;
-  return S.Diag(Loc, diag::warn_unused_result_msg) << A << Msg << R1 << R2;
+    return Diag(Loc, diag::warn_unused_constructor_msg) << A << Msg << R1 << R2;
+  return Diag(Loc, diag::warn_unused_result_msg) << A << Msg << R1 << R2;
 }
 
 void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
   if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
     return DiagnoseUnusedExprResult(Label->getSubStmt());
 
   const Expr *E = dyn_cast_or_null<Expr>(S);
   if (!E)
void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
   // we might want to make a more specific diagnostic.  Check for one of these
   // cases now.
   unsigned DiagID = diag::warn_unused_expr;
   if (const FullExpr *Temps = dyn_cast<FullExpr>(E))
     E = Temps->getSubExpr();
   if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
     E = TempExpr->getSubExpr();
 
-  if (DiagnoseUnusedComparison(*this, E))
+  if (DiagnoseUnusedComparison(E))
     return;
 
   E = WarnExpr;
   if (const auto *Cast = dyn_cast<CastExpr>(E))
     if (Cast->getCastKind() == CK_NoOp ||
         Cast->getCastKind() == CK_ConstructorConversion)
       E = Cast->getSubExpr()->IgnoreImpCasts();
 
   if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
     if (E->getType()->isVoidType())
       return;
 
-    if (DiagnoseNoDiscard(*this, cast_or_null<WarnUnusedResultAttr>(
-                                     CE->getUnusedResultAttr(Context)),
+    if (DiagnoseNoDiscard(cast_or_null<WarnUnusedResultAttr>(
                           Loc, R1, R2, /*isCtor=*/false))
       return;
 
     // If the callee has attribute pure, const, or warn_unused_result, warn with
     // a more specific message to make it clear what is happening. If the call
     // is written in a macro body, only warn if it has the warn_unused_result
     // attribute.
     if (const Decl *FD = CE->getCalleeDecl()) {
       if (ShouldSuppress)
         return;
       if (FD->hasAttr<PureAttr>()) {
         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
         return;
       }
       if (FD->hasAttr<ConstAttr>()) {
         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
         return;
       }
     }
   } else if (const auto *CE = dyn_cast<CXXConstructExpr>(E)) {
     if (const CXXConstructorDecl *Ctor = CE->getConstructor()) {
       const auto *A = Ctor->getAttr<WarnUnusedResultAttr>();
       A = A ? A : Ctor->getParent()->getAttr<WarnUnusedResultAttr>();
-      if (DiagnoseNoDiscard(*this, A, Loc, R1, R2, /*isCtor=*/true))
+      if (DiagnoseNoDiscard(A, Loc, R1, R2, /*isCtor=*/true))
         return;
     }
   } else if (const auto *ILE = dyn_cast<InitListExpr>(E)) {
     if (const TagDecl *TD = ILE->getType()->getAsTagDecl()) {
 
-      if (DiagnoseNoDiscard(*this, TD->getAttr<WarnUnusedResultAttr>(), Loc, R1,
-                            R2, /*isCtor=*/false))
+      if (DiagnoseNoDiscard(TD->getAttr<WarnUnusedResultAttr>(), Loc, R1, R2,
+                            /*isCtor=*/false))
         return;
     }
   } else if (ShouldSuppress)
     return;
 
   E = WarnExpr;
   if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
     if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
       Diag(Loc, diag::err_arc_unused_init_message) << R1;
       return;
     }
     const ObjCMethodDecl *MD = ME->getMethodDecl();
     if (MD) {
-      if (DiagnoseNoDiscard(*this, MD->getAttr<WarnUnusedResultAttr>(), Loc, R1,
-                            R2, /*isCtor=*/false))
+      if (DiagnoseNoDiscard(MD->getAttr<WarnUnusedResultAttr>(), Loc, R1, R2,
+                            /*isCtor=*/false))
         return;
     }
   } else if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
     const Expr *Source = POE->getSyntacticForm();
     // Handle the actually selected call of an OpenMP specialized call.
     if (LangOpts.OpenMP && isa<CallExpr>(Source) &&
         POE->getNumSemanticExprs() == 1 &&
         isa<CallExpr>(POE->getSemanticExpr(0)))
StmtResult Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
   return SS;
 }
 
 static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
   Val = Val.extOrTrunc(BitWidth);
   Val.setIsSigned(IsSigned);
 }
 
-/// Check the specified case value is in range for the given unpromoted switch
-/// type.
-static void checkCaseValue(Sema &S, SourceLocation Loc, const llvm::APSInt &Val,
-                           unsigned UnpromotedWidth, bool UnpromotedSign) {
+void Sema::CheckCaseValue(SourceLocation Loc, const llvm::APSInt &Val,
   // In C++11 onwards, this is checked by the language rules.
-  if (S.getLangOpts().CPlusPlus11)
+  if (getLangOpts().CPlusPlus11)
     return;
 
   // If the case value was signed and negative and the switch expression is
   // unsigned, don't bother to warn: this is implementation-defined behavior.
   // FIXME: Introduce a second, default-ignored warning for this case?
   if (UnpromotedWidth < Val.getBitWidth()) {
     llvm::APSInt ConvVal(Val);
     AdjustAPSInt(ConvVal, UnpromotedWidth, UnpromotedSign);
     AdjustAPSInt(ConvVal, Val.getBitWidth(), Val.isSigned());
     // FIXME: Use different diagnostics for overflow  in conversion to promoted
     // type versus "switch expression cannot have this value". Use proper
     // IntRange checking rather than just looking at the unpromoted type here.
     if (ConvVal != Val)
-      S.Diag(Loc, diag::warn_case_value_overflow) << Val.toString(10)
-                                                  << ConvVal.toString(10);
+      Diag(Loc, diag::warn_case_value_overflow)
+          << Val.toString(10) << ConvVal.toString(10);
   }
 }
 
-typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64> EnumValsTy;
-
-/// Returns true if we should emit a diagnostic about this case expression not
-/// being a part of the enum used in the switch controlling expression.
-static bool ShouldDiagnoseSwitchCaseNotInEnum(const Sema &S,
-                                              const EnumDecl *ED,
-                                              const Expr *CaseExpr,
-                                              EnumValsTy::iterator &EI,
-                                              EnumValsTy::iterator &EIEnd,
-                                              const llvm::APSInt &Val) {
+bool Sema::ShouldDiagnoseSwitchCaseNotInEnum(const EnumDecl *ED,
   if (!ED->isClosed())
     return false;
 
   if (const DeclRefExpr *DRE =
           dyn_cast<DeclRefExpr>(CaseExpr->IgnoreParenImpCasts())) {
     if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
       QualType VarType = VD->getType();
-      QualType EnumType = S.Context.getTypeDeclType(ED);
+      QualType EnumType = Context.getTypeDeclType(ED);
       if (VD->hasGlobalStorage() && VarType.isConstQualified() &&
-          S.Context.hasSameUnqualifiedType(EnumType, VarType))
+          Context.hasSameUnqualifiedType(EnumType, VarType))
         return false;
     }
   }
 
   if (ED->hasAttr<FlagEnumAttr>())
-    return !S.IsValueInFlagEnum(ED, Val, false);
+    return !IsValueInFlagEnum(ED, Val, false);
 
   while (EI != EIEnd && EI->first < Val)
     EI++;
 
   if (EI != EIEnd && EI->first == Val)
     return false;
 
   return true;
 }
 
-static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond,
-                                       const Expr *Case) {
+void Sema::CheckEnumTypesInSwitchStmt(const Expr *Cond, const Expr *Case) {
   QualType CondType = Cond->getType();
   QualType CaseType = Case->getType();
 
   const EnumType *CondEnumType = CondType->getAs<EnumType>();
   const EnumType *CaseEnumType = CaseType->getAs<EnumType>();
   if (!CondEnumType || !CaseEnumType)
     return;
 
   // Ignore anonymous enums.
   if (!CondEnumType->getDecl()->getIdentifier() &&
       !CondEnumType->getDecl()->getTypedefNameForAnonDecl())
     return;
   if (!CaseEnumType->getDecl()->getIdentifier() &&
       !CaseEnumType->getDecl()->getTypedefNameForAnonDecl())
     return;
 
-  if (S.Context.hasSameUnqualifiedType(CondType, CaseType))
+  if (Context.hasSameUnqualifiedType(CondType, CaseType))
     return;
 
-  S.Diag(Case->getExprLoc(), diag::warn_comparison_of_mixed_enum_types_switch)
+  Diag(Case->getExprLoc(), diag::warn_comparison_of_mixed_enum_types_switch)
       << CondType << CaseType << Cond->getSourceRange()
       << Case->getSourceRange();
 }
 
 StmtResult
 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
                             Stmt *BodyStmt) {
   SwitchStmt *SS = cast<SwitchStmt>(Switch);
if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
       // We already verified that the expression has a constant value;
       // get that value (prior to conversions).
       const Expr *LoBeforePromotion = Lo;
       GetTypeBeforeIntegralPromotion(LoBeforePromotion);
       llvm::APSInt LoVal = LoBeforePromotion->EvaluateKnownConstInt(Context);
 
       // Check the unconverted value is within the range of possible values of
       // the switch expression.
-      checkCaseValue(*this, Lo->getBeginLoc(), LoVal, CondWidthBeforePromotion,
+      CheckCaseValue(Lo->getBeginLoc(), LoVal, CondWidthBeforePromotion,
                      CondIsSignedBeforePromotion);
 
       // FIXME: This duplicates the check performed for warn_not_in_enum below.
-      checkEnumTypesInSwitchStmt(*this, CondExprBeforePromotion,
-                                 LoBeforePromotion);
+      CheckEnumTypesInSwitchStmt(CondExprBeforePromotion, LoBeforePromotion);
 
       // Convert the value to the same width/sign as the condition.
       AdjustAPSInt(LoVal, CondWidth, CondIsSigned);
 
       // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
       if (CS->getRHS()) {
         if (CS->getRHS()->isValueDependent()) {
           HasDependentValue = true;
if (!CaseRanges.empty()) {
         Expr *Hi = CR->getRHS();
 
         const Expr *HiBeforePromotion = Hi;
         GetTypeBeforeIntegralPromotion(HiBeforePromotion);
         llvm::APSInt HiVal = HiBeforePromotion->EvaluateKnownConstInt(Context);
 
         // Check the unconverted value is within the range of possible values of
         // the switch expression.
-        checkCaseValue(*this, Hi->getBeginLoc(), HiVal,
-                       CondWidthBeforePromotion, CondIsSignedBeforePromotion);
+        CheckCaseValue(Hi->getBeginLoc(), HiVal, CondWidthBeforePromotion,
+                       CondIsSignedBeforePromotion);
 
         // Convert the value to the same width/sign as the condition.
         AdjustAPSInt(HiVal, CondWidth, CondIsSigned);
 
         // If the low value is bigger than the high value, the case is empty.
         if (LoVal > HiVal) {
           Diag(CR->getLHS()->getBeginLoc(), diag::warn_case_empty_range)
               << SourceRange(CR->getLHS()->getBeginLoc(), Hi->getEndLoc());
if (!CaseListIsErroneous && !CaseListIsIncomplete && !HasConstantCond &&
       llvm::stable_sort(EnumVals, CmpEnumVals);
       auto EI = EnumVals.begin(), EIEnd =
         std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
 
       // See which case values aren't in enum.
       for (CaseValsTy::const_iterator CI = CaseVals.begin();
           CI != CaseVals.end(); CI++) {
         Expr *CaseExpr = CI->second->getLHS();
-        if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd,
+        if (ShouldDiagnoseSwitchCaseNotInEnum(ED, CaseExpr, EI, EIEnd,
                                               CI->first))
           Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum)
             << CondTypeBeforePromotion;
       }
 
       // See which of case ranges aren't in enum
       EI = EnumVals.begin();
       for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
           RI != CaseRanges.end(); RI++) {
         Expr *CaseExpr = RI->second->getLHS();
-        if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd,
+        if (ShouldDiagnoseSwitchCaseNotInEnum(ED, CaseExpr, EI, EIEnd,
                                               RI->first))
           Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum)
             << CondTypeBeforePromotion;
 
         llvm::APSInt Hi =
           RI->second->getRHS()->EvaluateKnownConstInt(Context);
         AdjustAPSInt(Hi, CondWidth, CondIsSigned);
 
         CaseExpr = RI->second->getRHS();
-        if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd,
-                                              Hi))
+        if (ShouldDiagnoseSwitchCaseNotInEnum(ED, CaseExpr, EI, EIEnd, Hi))
           Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum)
             << CondTypeBeforePromotion;
       }
 
       // Check which enum vals aren't in switch
       auto CI = CaseVals.begin();
       auto RI = CaseRanges.begin();
       bool hasCasesNotInSwitch = false;
Description = SemaRef.getTemplateArgumentBindingsText(
       FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
     IsTemplate = true;
   }
 
   SemaRef.Diag(Loc, diag::note_for_range_begin_end)
     << BEF << IsTemplate << Description << E->getType();
 }
 
-/// Build a variable declaration for a for-range statement.
-VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
-                              QualType Type, StringRef Name) {
-  DeclContext *DC = SemaRef.CurContext;
-  IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
-  TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
-  VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
-                                  TInfo, SC_None);
+} // namespace
+
+VarDecl *Sema::BuildForRangeVarDecl(SourceLocation Loc, QualType Type,
+                                    StringRef Name) {
+  DeclContext *DC = CurContext;
+  IdentifierInfo *II = &PP.getIdentifierTable().get(Name);
+  TypeSourceInfo *TInfo = Context.getTrivialTypeSourceInfo(Type, Loc);
+  VarDecl *Decl =
+      VarDecl::Create(Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
   Decl->setImplicit();
   return Decl;
 }
 
-}
-
 static bool ObjCEnumerationCollection(Expr *Collection) {
   return !Collection->isTypeDependent()
           && Collection->getType()->getAs<ObjCObjectPointerType>() != nullptr;
 }
 
 /// ActOnCXXForRangeStmt - Check and build a C++11 for-range statement.
 ///
 /// C++11 [stmt.ranged]:
if (!CoawaitLoc.isInvalid()) {
     if (!ActOnCoroutineBodyStart(S, CoawaitLoc, "co_await"))
       return StmtError();
   }
 
   // Build  auto && __range = range-init
   // Divide by 2, since the variables are in the inner scope (loop body).
   const auto DepthStr = std::to_string(S->getDepth() / 2);
   SourceLocation RangeLoc = Range->getBeginLoc();
-  VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
-                                           Context.getAutoRRefDeductType(),
-                                           std::string("__range") + DepthStr);
+  VarDecl *RangeVar =
+      BuildForRangeVarDecl(RangeLoc, Context.getAutoRRefDeductType(),
   if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
                             diag::err_for_range_deduction_failure)) {
     LoopVar->setInvalidDecl();
     return StmtError();
   }
 
   // Claim the type doesn't contain auto: we've already done the checking.
   DeclGroupPtrTy RangeGroup =
if (RangeVarType->isDependentType()) {
 
     if (RequireCompleteType(RangeLoc, RangeType,
                             diag::err_for_range_incomplete_type))
       return StmtError();
 
     // Build auto __begin = begin-expr, __end = end-expr.
     // Divide by 2, since the variables are in the inner scope (loop body).
     const auto DepthStr = std::to_string(S->getDepth() / 2);
-    VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
+    VarDecl *BeginVar = BuildForRangeVarDecl(ColonLoc, AutoType,
                                              std::string("__begin") + DepthStr);
-    VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
+    VarDecl *EndVar = BuildForRangeVarDecl(ColonLoc, AutoType,
                                            std::string("__end") + DepthStr);
 
     // Build begin-expr and end-expr and attach to __begin and __end variables.
     ExprResult BeginExpr, EndExpr;
     if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
       // - if _RangeT is an array type, begin-expr and end-expr are __range and
       //   __range + __bound, respectively, where __bound is the array bound. If
       //   _RangeT is an array of unknown size or an array of incomplete type,
StmtResult Sema::FinishObjCForCollectionStmt(Stmt *S, Stmt *B) {
   if (!S || !B)
     return StmtError();
   ObjCForCollectionStmt * ForStmt = cast<ObjCForCollectionStmt>(S);
 
   ForStmt->setBody(B);
   return S;
 }
 
-// Warn when the loop variable is a const reference that creates a copy.
-// Suggest using the non-reference type for copies.  If a copy can be prevented
-// suggest the const reference type that would do so.
-// For instance, given "for (const &Foo : Range)", suggest
-// "for (const Foo : Range)" to denote a copy is made for the loop.  If
-// possible, also suggest "for (const &Bar : Range)" if this type prevents
-// the copy altogether.
-static void DiagnoseForRangeReferenceVariableCopies(Sema &SemaRef,
-                                                    const VarDecl *VD,
-                                                    QualType RangeInitType) {
+void Sema::DiagnoseForRangeReferenceVariableCopies(const VarDecl *VD,
   const Expr *InitExpr = VD->getInit();
   if (!InitExpr)
     return;
 
   QualType VariableType = VD->getType();
 
   if (auto Cleanups = dyn_cast<ExprWithCleanups>(InitExpr))
     if (!Cleanups->cleanupsHaveSideEffects())
if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(E)) {
       const MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(E);
       E = MTE->getSubExpr();
     }
     E = E->IgnoreImpCasts();
   }
 
   QualType ReferenceReturnType;
   if (isa<UnaryOperator>(E)) {
-    ReferenceReturnType = SemaRef.Context.getLValueReferenceType(E->getType());
+    ReferenceReturnType = Context.getLValueReferenceType(E->getType());
   } else {
     const CXXOperatorCallExpr *Call = cast<CXXOperatorCallExpr>(E);
     const FunctionDecl *FD = Call->getDirectCallee();
     QualType ReturnType = FD->getReturnType();
     if (ReturnType->isReferenceType())
       ReferenceReturnType = ReturnType;
   }
 
   if (!ReferenceReturnType.isNull()) {
     // Loop variable creates a temporary.  Suggest either to go with
     // non-reference loop variable to indicate a copy is made, or
     // the correct type to bind a const reference.
-    SemaRef.Diag(VD->getLocation(),
-                 diag::warn_for_range_const_ref_binds_temp_built_from_ref)
+    Diag(VD->getLocation(),
         << VD << VariableType << ReferenceReturnType;
     QualType NonReferenceType = VariableType.getNonReferenceType();
     NonReferenceType.removeLocalConst();
     QualType NewReferenceType =
-        SemaRef.Context.getLValueReferenceType(E->getType().withConst());
-    SemaRef.Diag(VD->getBeginLoc(), diag::note_use_type_or_non_reference)
+        Context.getLValueReferenceType(E->getType().withConst());
+    Diag(VD->getBeginLoc(), diag::note_use_type_or_non_reference)
         << NonReferenceType << NewReferenceType << VD->getSourceRange()
         << FixItHint::CreateRemoval(VD->getTypeSpecEndLoc());
   } else if (!VariableType->isRValueReferenceType()) {
     // The range always returns a copy, so a temporary is always created.
     // Suggest removing the reference from the loop variable.
     // If the type is a rvalue reference do not warn since that changes the
     // semantic of the code.
-    SemaRef.Diag(VD->getLocation(), diag::warn_for_range_ref_binds_ret_temp)
+    Diag(VD->getLocation(), diag::warn_for_range_ref_binds_ret_temp)
         << VD << RangeInitType;
     QualType NonReferenceType = VariableType.getNonReferenceType();
     NonReferenceType.removeLocalConst();
-    SemaRef.Diag(VD->getBeginLoc(), diag::note_use_non_reference_type)
+    Diag(VD->getBeginLoc(), diag::note_use_non_reference_type)
         << NonReferenceType << VD->getSourceRange()
         << FixItHint::CreateRemoval(VD->getTypeSpecEndLoc());
   }
 }
 
 /// Determines whether the @p VariableType's declaration is a record with the
 /// clang::trivial_abi attribute.
 static bool hasTrivialABIAttr(QualType VariableType) {
   if (CXXRecordDecl *RD = VariableType->getAsCXXRecordDecl())
     return RD->hasAttr<TrivialABIAttr>();
 
   return false;
 }
 
-// Warns when the loop variable can be changed to a reference type to
-// prevent a copy.  For instance, if given "for (const Foo x : Range)" suggest
-// "for (const Foo &x : Range)" if this form does not make a copy.
-static void DiagnoseForRangeConstVariableCopies(Sema &SemaRef,
-                                                const VarDecl *VD) {
+void Sema::DiagnoseForRangeConstVariableCopies(const VarDecl *VD) {
   const Expr *InitExpr = VD->getInit();
   if (!InitExpr)
     return;
 
-  QualType VariableType = VD->getType();
-
   if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(InitExpr)) {
     if (!CE->getConstructor()->isCopyConstructor())
       return;
   } else if (const CastExpr *CE = dyn_cast<CastExpr>(InitExpr)) {
     if (CE->getCastKind() != CK_LValueToRValue)
       return;
   } else {
     return;
   }
 
   // Small trivially copyable types are cheap to copy. Do not emit the
   // diagnostic for these instances. 64 bytes is a common size of a cache line.
   // (The function `getTypeSize` returns the size in bits.)
-  ASTContext &Ctx = SemaRef.Context;
-  if (Ctx.getTypeSize(VariableType) <= 64 * 8 &&
-      (VariableType.isTriviallyCopyableType(Ctx) ||
+  QualType VariableType = VD->getType();
+  if (Context.getTypeSize(VariableType) <= 64 * 8 &&
+      (VariableType.isTriviallyCopyableType(Context) ||
        hasTrivialABIAttr(VariableType)))
     return;
 
   // Suggest changing from a const variable to a const reference variable
   // if doing so will prevent a copy.
-  SemaRef.Diag(VD->getLocation(), diag::warn_for_range_copy)
-      << VD << VariableType;
-  SemaRef.Diag(VD->getBeginLoc(), diag::note_use_reference_type)
-      << SemaRef.Context.getLValueReferenceType(VariableType)
-      << VD->getSourceRange()
+  Diag(VD->getLocation(), diag::warn_for_range_copy) << VD << VariableType;
+  Diag(VD->getBeginLoc(), diag::note_use_reference_type)
+      << Context.getLValueReferenceType(VariableType) << VD->getSourceRange()
       << FixItHint::CreateInsertion(VD->getLocation(), "&");
 }
 
-/// DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
-/// 1) for (const foo &x : foos) where foos only returns a copy.  Suggest
-///    using "const foo x" to show that a copy is made
-/// 2) for (const bar &x : foos) where bar is a temporary initialized by bar.
-///    Suggest either "const bar x" to keep the copying or "const foo& x" to
-///    prevent the copy.
-/// 3) for (const foo x : foos) where x is constructed from a reference foo.
-///    Suggest "const foo &x" to prevent the copy.
-static void DiagnoseForRangeVariableCopies(Sema &SemaRef,
-                                           const CXXForRangeStmt *ForStmt) {
-  if (SemaRef.inTemplateInstantiation())
+void Sema::DiagnoseForRangeVariableCopies(const CXXForRangeStmt *ForStmt) {
+  if (inTemplateInstantiation())
     return;
 
-  if (SemaRef.Diags.isIgnored(
-          diag::warn_for_range_const_ref_binds_temp_built_from_ref,
+  if (Diags.isIgnored(diag::warn_for_range_const_ref_binds_temp_built_from_ref,
                       ForStmt->getBeginLoc()) &&
-      SemaRef.Diags.isIgnored(diag::warn_for_range_ref_binds_ret_temp,
-                              ForStmt->getBeginLoc()) &&
-      SemaRef.Diags.isIgnored(diag::warn_for_range_copy,
-                              ForStmt->getBeginLoc())) {
+      Diags.isIgnored(diag::warn_for_range_ref_binds_ret_temp,
+      Diags.isIgnored(diag::warn_for_range_copy, ForStmt->getBeginLoc()))
     return;
-  }
 
   const VarDecl *VD = ForStmt->getLoopVariable();
   if (!VD)
     return;
 
   QualType VariableType = VD->getType();
 
   if (VariableType->isIncompleteType())
     return;
 
   const Expr *InitExpr = VD->getInit();
   if (!InitExpr)
     return;
 
   if (InitExpr->getExprLoc().isMacroID())
     return;
 
   if (VariableType->isReferenceType()) {
-    DiagnoseForRangeReferenceVariableCopies(SemaRef, VD,
+    DiagnoseForRangeReferenceVariableCopies(VD,
                                             ForStmt->getRangeInit()->getType());
   } else if (VariableType.isConstQualified()) {
-    DiagnoseForRangeConstVariableCopies(SemaRef, VD);
+    DiagnoseForRangeConstVariableCopies(VD);
   }
 }
 
 /// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
 /// This is a separate step from ActOnCXXForRangeStmt because analysis of the
 /// body cannot be performed until after the type of the range variable is
 /// determined.
 StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
   if (!S || !B)
     return StmtError();
 
   if (isa<ObjCForCollectionStmt>(S))
     return FinishObjCForCollectionStmt(S, B);
 
   CXXForRangeStmt *ForStmt = cast<CXXForRangeStmt>(S);
   ForStmt->setBody(B);
 
   DiagnoseEmptyStmtBody(ForStmt->getRParenLoc(), B,
                         diag::warn_empty_range_based_for_body);
 
-  DiagnoseForRangeVariableCopies(*this, ForStmt);
+  DiagnoseForRangeVariableCopies(ForStmt);
 
   return S;
 }
 
 StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
                                SourceLocation LabelLoc,
                                LabelDecl *TheDecl) {
   setFunctionHasBranchIntoScope();
if (ExprRes.isInvalid())
     return StmtError();
   E = ExprRes.get();
 
   setFunctionHasIndirectGoto();
 
   return new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E);
 }
 
-static void CheckJumpOutOfSEHFinally(Sema &S, SourceLocation Loc,
-                                     const Scope &DestScope) {
-  if (!S.CurrentSEHFinally.empty() &&
-      DestScope.Contains(*S.CurrentSEHFinally.back())) {
-    S.Diag(Loc, diag::warn_jump_out_of_seh_finally);
+void Sema::CheckJumpOutOfSEHFinally(SourceLocation Loc,
+  if (!CurrentSEHFinally.empty() &&
+      DestScope.Contains(*CurrentSEHFinally.back())) {
+    Diag(Loc, diag::warn_jump_out_of_seh_finally);
   }
 }
 
 StmtResult
 Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
   Scope *S = CurScope->getContinueParent();
   if (!S) {
     // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
     return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
   }
-  CheckJumpOutOfSEHFinally(*this, ContinueLoc, *S);
+  CheckJumpOutOfSEHFinally(ContinueLoc, *S);
 
   return new (Context) ContinueStmt(ContinueLoc);
 }
 
 StmtResult
 Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
   Scope *S = CurScope->getBreakParent();
   if (!S) {
     // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
     return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
   }
   if (S->isOpenMPLoopScope())
     return StmtError(Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt)
                      << "break");
-  CheckJumpOutOfSEHFinally(*this, BreakLoc, *S);
+  CheckJumpOutOfSEHFinally(BreakLoc, *S);
 
   return new (Context) BreakStmt(BreakLoc);
 }
 
 /// Determine whether the given expression is a candidate for
 /// copy elision in either a return statement or a throw expression.
 ///
 /// \param ReturnType If we're determining the copy elision candidate for
bool Sema::isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,
   // alignment cannot use NRVO.
   if (!VD->getType()->isDependentType() && VD->hasAttr<AlignedAttr>() &&
       Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VD->getType()))
     return false;
 
   return true;
 }
 
-/// Try to perform the initialization of a potentially-movable value,
-/// which is the operand to a return or throw statement.
-///
-/// This routine implements C++14 [class.copy]p32, which attempts to treat
-/// returned lvalues as rvalues in certain cases (to prefer move construction),
-/// then falls back to treating them as lvalues if that failed.
-///
-/// \param ConvertingConstructorsOnly If true, follow [class.copy]p32 and reject
-/// resolutions that find non-constructors, such as derived-to-base conversions
-/// or `operator T()&&` member functions. If false, do consider such
-/// conversion sequences.
-///
-/// \param Res We will fill this in if move-initialization was possible.
-/// If move-initialization is not possible, such that we must fall back to
-/// treating the operand as an lvalue, we will leave Res in its original
-/// invalid state.
-static void TryMoveInitialization(Sema& S,
-                                  const InitializedEntity &Entity,
-                                  const VarDecl *NRVOCandidate,
-                                  QualType ResultType,
-                                  Expr *&Value,
-                                  bool ConvertingConstructorsOnly,
-                                  ExprResult &Res) {
+void Sema::TryMoveInitialization(const InitializedEntity &Entity,
+                                 QualType ResultType, Expr *&Value,
   ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, Value->getType(),
                             CK_NoOp, Value, VK_XValue);
 
   Expr *InitExpr = &AsRvalue;
 
   InitializationKind Kind = InitializationKind::CreateCopy(
       Value->getBeginLoc(), Value->getBeginLoc());
 
-  InitializationSequence Seq(S, Entity, Kind, InitExpr);
+  InitializationSequence Seq(*this, Entity, Kind, InitExpr);
 
   if (!Seq)
     return;
 
   for (const InitializationSequence::Step &Step : Seq.steps()) {
     if (Step.Kind != InitializationSequence::SK_ConstructorInitialization &&
         Step.Kind != InitializationSequence::SK_UserConversion)
       continue;
 
     FunctionDecl *FD = Step.Function.Function;
     if (ConvertingConstructorsOnly) {
       if (isa<CXXConstructorDecl>(FD)) {
         // C++14 [class.copy]p32:
         // [...] If the first overload resolution fails or was not performed,
         // or if the type of the first parameter of the selected constructor
         // is not an rvalue reference to the object's type (possibly
         // cv-qualified), overload resolution is performed again, considering
         // the object as an lvalue.
         const RValueReferenceType *RRefType =
             FD->getParamDecl(0)->getType()->getAs<RValueReferenceType>();
         if (!RRefType)
           break;
-        if (!S.Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
-                                              NRVOCandidate->getType()))
+        if (!Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
           break;
       } else {
         continue;
       }
     } else {
       if (isa<CXXConstructorDecl>(FD)) {
         // Check that overload resolution selected a constructor taking an
         // rvalue reference. If it selected an lvalue reference, then we
         // didn't need to cast this thing to an rvalue in the first place.
         if (!isa<RValueReferenceType>(FD->getParamDecl(0)->getType()))
           break;
       } else if (isa<CXXMethodDecl>(FD)) {
         // Check that overload resolution selected a conversion operator
         // taking an rvalue reference.
         if (cast<CXXMethodDecl>(FD)->getRefQualifier() != RQ_RValue)
           break;
       } else {
         continue;
       }
     }
 
     // Promote "AsRvalue" to the heap, since we now need this
     // expression node to persist.
-    Value = ImplicitCastExpr::Create(S.Context, Value->getType(), CK_NoOp,
-                                     Value, nullptr, VK_XValue);
+    Value = ImplicitCastExpr::Create(Context, Value->getType(), CK_NoOp, Value,
+                                     nullptr, VK_XValue);
 
     // Complete type-checking the initialization of the return type
     // using the constructor we found.
-    Res = Seq.Perform(S, Entity, Kind, Value);
+    Res = Seq.Perform(*this, Entity, Kind, Value);
   }
 }
 
 /// Perform the initialization of a potentially-movable value, which
 /// is the result of return value.
 ///
 /// This routine implements C++14 [class.copy]p32, which attempts to treat
 /// returned lvalues as rvalues in certain cases (to prefer move construction),
if (!NRVOCandidate) {
                                       Value->getExprLoc())) {
         const VarDecl *NRVOCandidateInCXX11 =
             getCopyElisionCandidate(ResultType, Value, CES_FormerDefault);
         AffectedByCWG1579 = (!NRVOCandidateInCXX11);
       }
     }
 
     if (NRVOCandidate) {
-      TryMoveInitialization(*this, Entity, NRVOCandidate, ResultType, Value,
-                            true, Res);
+      TryMoveInitialization(Entity, NRVOCandidate, ResultType, Value, true,
+                            Res);
     }
 
     if (!Res.isInvalid() && AffectedByCWG1579) {
       QualType QT = NRVOCandidate->getType();
       if (QT.getNonReferenceType()
                      .getUnqualifiedType()
                      .isTriviallyCopyableType(Context)) {
         // Adding 'std::move' around a trivially copyable variable is probably
if (!Res.isInvalid() && AffectedByCWG1579) {
         } else if (QT.getNonReferenceType()
                        .getUnqualifiedType()
                        .isTriviallyCopyableType(Context)) {
           // Adding 'std::move' around a trivially copyable variable is probably
           // pointless. Don't suggest it.
         } else {
           ExprResult FakeRes = ExprError();
           Expr *FakeValue = Value;
-          TryMoveInitialization(*this, Entity, FakeNRVOCandidate, ResultType,
+          TryMoveInitialization(Entity, FakeNRVOCandidate, ResultType,
                                 FakeValue, false, FakeRes);
           if (!FakeRes.isInvalid()) {
             bool IsThrow =
                 (Entity.getKind() == InitializedEntity::EK_Exception);
             SmallString<32> Str;
             Str += "std::move(";
             Str += FakeNRVOCandidate->getDeclName().getAsString();
             Str += ")";
Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
 
   if (VarDecl *VD =
       const_cast<VarDecl*>(cast<ReturnStmt>(R.get())->getNRVOCandidate())) {
     CurScope->addNRVOCandidate(VD);
   } else {
     CurScope->setNoNRVO();
   }
 
-  CheckJumpOutOfSEHFinally(*this, ReturnLoc, *CurScope->getFnParent());
+  CheckJumpOutOfSEHFinally(ReturnLoc, *CurScope->getFnParent());
 
   return R;
 }
 
 StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
   // Check for unexpanded parameter packs.
   if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
     return StmtError();

 
 StmtResult
 Sema::ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope) {
   Scope *SEHTryParent = CurScope;
   while (SEHTryParent && !SEHTryParent->isSEHTryScope())
     SEHTryParent = SEHTryParent->getParent();
   if (!SEHTryParent)
     return StmtError(Diag(Loc, diag::err_ms___leave_not_in___try));
-  CheckJumpOutOfSEHFinally(*this, Loc, *SEHTryParent);
+  CheckJumpOutOfSEHFinally(Loc, *SEHTryParent);
 
   return new (Context) SEHLeaveStmt(Loc);
 }
 
 StmtResult Sema::BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
                                             bool IsIfExists,
                                             NestedNameSpecifierLoc QualifierLoc,
                                             DeclarationNameInfo NameInfo,
Sema::CreateCapturedStmtRecordDecl(CapturedDecl *&CD, SourceLocation Loc,
   RD->startDefinition();
 
   assert(NumParams > 0 && "CapturedStmt requires context parameter");
   CD = CapturedDecl::Create(Context, CurContext, NumParams);
   DC->addDecl(CD);
   return RD;
 }
 
-static bool
-buildCapturedStmtCaptureList(Sema &S, CapturedRegionScopeInfo *RSI,
-                             SmallVectorImpl<CapturedStmt::Capture> &Captures,
-                             SmallVectorImpl<Expr *> &CaptureInits) {
+bool Sema::BuildCapturedStmtCaptureList(
+    CapturedRegionScopeInfo *RSI,
   for (const sema::Capture &Cap : RSI->Captures) {
     if (Cap.isInvalid())
       continue;
 
     // Form the initializer for the capture.
-    ExprResult Init = S.BuildCaptureInit(Cap, Cap.getLocation(),
-                                         RSI->CapRegionKind == CR_OpenMP);
+    ExprResult Init = BuildCaptureInit(Cap, Cap.getLocation(),
 
     // FIXME: Bail out now if the capture is not used and the initializer has
     // no side-effects.
 
     // Create a field for this capture.
-    FieldDecl *Field = S.BuildCaptureField(RSI->TheRecordDecl, Cap);
+    FieldDecl *Field = BuildCaptureField(RSI->TheRecordDecl, Cap);
 
     // Add the capture to our list of captures.
     if (Cap.isThisCapture()) {
       Captures.push_back(CapturedStmt::Capture(Cap.getLocation(),
                                                CapturedStmt::VCK_This));
     } else if (Cap.isVLATypeCapture()) {
       Captures.push_back(
           CapturedStmt::Capture(Cap.getLocation(), CapturedStmt::VCK_VLAType));
     } else {
       assert(Cap.isVariableCapture() && "unknown kind of capture");
 
-      if (S.getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP)
-        S.setOpenMPCaptureKind(Field, Cap.getVariable(), RSI->OpenMPLevel);
+      if (getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP)
+        setOpenMPCaptureKind(Field, Cap.getVariable(), RSI->OpenMPLevel);
 
       Captures.push_back(CapturedStmt::Capture(Cap.getLocation(),
                                                Cap.isReferenceCapture()
                                                    ? CapturedStmt::VCK_ByRef
                                                    : CapturedStmt::VCK_ByCopy,
                                                Cap.getVariable()));
     }
     CaptureInits.push_back(Init.get());
StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) {
   DiscardCleanupsInEvaluationContext();
   PopExpressionEvaluationContext();
   PopDeclContext();
   PoppedFunctionScopePtr ScopeRAII = PopFunctionScopeInfo();
   CapturedRegionScopeInfo *RSI = cast<CapturedRegionScopeInfo>(ScopeRAII.get());
 
   SmallVector<CapturedStmt::Capture, 4> Captures;
   SmallVector<Expr *, 4> CaptureInits;
-  if (buildCapturedStmtCaptureList(*this, RSI, Captures, CaptureInits))
+  if (BuildCapturedStmtCaptureList(RSI, Captures, CaptureInits))
     return StmtError();
 
   CapturedDecl *CD = RSI->TheCapturedDecl;
   RecordDecl *RD = RSI->TheRecordDecl;
 
   CapturedStmt *Res = CapturedStmt::Create(
       getASTContext(), S, static_cast<CapturedRegionKind>(RSI->CapRegionKind),
       Captures, CaptureInits, CD, RD);
 
   CD->setBody(Res->getCapturedStmt());
   RD->completeDefinition();
 
   return Res;
 }