do not merge - [clang] fix EndLoc of some Statements

[AlexanderLanin]

Summary

At the moment statements like break, continue, return, goto do not include the semicolon in the end within getEndLoc(). Add missing SourceLocation to those statements to express their EndLoc.

Warning: this is a proof of concept. It works at least in some cases. However I have no idea what I'm doing here.

[shafik]

Adding potentially relevant reviews.

[rjmccall]

We don't generally consider the semicolon to be part of the statement's source range. Among other things, it's really unclear how that would apply to expressions given that we don't have a separate ExprStmt class.

[AlexanderLanin]

Thanks for the feedback. I was trying to start a discussion on cfe-dev where I referenced this commit, but I'm also fine having it here! There you'll also find some rationale. Just worried it will get out of sync.
Compare http://lists.llvm.org/pipermail/cfe-dev/2020-March/064861.html

The problem from clang-tidy checkers point of view is that Stmt.getEndLoc does include the semicolon in most cases. It's just these few where it is not.
Me and @ymandel had a mail thread over here: http://lists.llvm.org/pipermail/cfe-dev/2020-February/thread.html#64743 & http://lists.llvm.org/pipermail/cfe-dev/2020-March/thread.html#64844 but started a new one for Stmt modification.

The alternative is adding a Stmt traversal function to clang-tidy like this one: https://reviews.llvm.org/D75813#change-Bc7Hs8CXH7Z9 (It needs to be extended a little with GotoStmt etc).
Idea of this commit was to reduce different behavior cases to "Expr vs rest" instead of "half a dozen apparently random statements vs rest".

It would also be interesting to think about always excluding the semicolon, but that change would probably be bigger than this one.

[AlexanderLanin]

One more thought: This originated for me from attempting to fix braces-around-statements which has quite some trouble finding the correct place to place the }. However this is a good definition of "end location of statement" isn't it? The place where you can end the scope. The place where you could place the next statement!

[AlexanderLanin]

Mailing list was clear about AST having to many users. No change to clang AST.
Will hopefully be resolved by D75813 instead.

clang/include/clang/AST/Stmt.h

 };
 
 /// DoStmt - This represents a 'do/while' stmt.
 class DoStmt : public Stmt {
   enum { BODY, COND, END_EXPR };
   Stmt *SubExprs[END_EXPR];
   SourceLocation WhileLoc;
   SourceLocation RParenLoc; // Location of final ')' in do stmt condition.
+  SourceLocation EndLoc; // Location of final ';' in do stmt condition.
 
 public:
   DoStmt(Stmt *Body, Expr *Cond, SourceLocation DL, SourceLocation WL,
-         SourceLocation RP)
-      : Stmt(DoStmtClass), WhileLoc(WL), RParenLoc(RP) {
+         SourceLocation RP, SourceLocation EL)
+      : Stmt(DoStmtClass), WhileLoc(WL), RParenLoc(RP), EndLoc(EL) {
     setCond(Cond);
     setBody(Body);
     setDoLoc(DL);
   }
 
   /// Build an empty do-while statement.
   explicit DoStmt(EmptyShell Empty) : Stmt(DoStmtClass, Empty) {}
 
public:
   SourceLocation getDoLoc() const { return DoStmtBits.DoLoc; }
   void setDoLoc(SourceLocation L) { DoStmtBits.DoLoc = L; }
   SourceLocation getWhileLoc() const { return WhileLoc; }
   void setWhileLoc(SourceLocation L) { WhileLoc = L; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getBeginLoc() const { return getDoLoc(); }
-  SourceLocation getEndLoc() const { return getRParenLoc(); }
+  SourceLocation getEndLoc() const { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == DoStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
const_child_range children() const {
     return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
   }
 };
 
 /// GotoStmt - This represents a direct goto.
 class GotoStmt : public Stmt {
   LabelDecl *Label;
   SourceLocation LabelLoc;
+  SourceLocation EndLoc; // Location of final ';'
 
 public:
-  GotoStmt(LabelDecl *label, SourceLocation GL, SourceLocation LL)
-      : Stmt(GotoStmtClass), Label(label), LabelLoc(LL) {
+  GotoStmt(LabelDecl *label, SourceLocation GL, SourceLocation LL, SourceLocation EL)
+      : Stmt(GotoStmtClass), Label(label), LabelLoc(LL), EndLoc(EL) {
     setGotoLoc(GL);
   }
 
   /// Build an empty goto statement.
   explicit GotoStmt(EmptyShell Empty) : Stmt(GotoStmtClass, Empty) {}
 
   LabelDecl *getLabel() const { return Label; }
   void setLabel(LabelDecl *D) { Label = D; }
 
   SourceLocation getGotoLoc() const { return GotoStmtBits.GotoLoc; }
   void setGotoLoc(SourceLocation L) { GotoStmtBits.GotoLoc = L; }
   SourceLocation getLabelLoc() const { return LabelLoc; }
   void setLabelLoc(SourceLocation L) { LabelLoc = L; }
 
   SourceLocation getBeginLoc() const { return getGotoLoc(); }
-  SourceLocation getEndLoc() const { return getLabelLoc(); }
+  SourceLocation getEndLoc() const { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == GotoStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
public:
 
   const_child_range children() const {
     return const_child_range(&Target, &Target + 1);
   }
 };
 
 /// ContinueStmt - This represents a continue.
 class ContinueStmt : public Stmt {
+  SourceLocation EndLoc; // Location of final ';'
 public:
-  ContinueStmt(SourceLocation CL) : Stmt(ContinueStmtClass) {
+  ContinueStmt(SourceLocation CL, SourceLocation EL) : Stmt(ContinueStmtClass), EndLoc(EL) {
     setContinueLoc(CL);
   }
 
   /// Build an empty continue statement.
   explicit ContinueStmt(EmptyShell Empty) : Stmt(ContinueStmtClass, Empty) {}
 
   SourceLocation getContinueLoc() const { return ContinueStmtBits.ContinueLoc; }
   void setContinueLoc(SourceLocation L) { ContinueStmtBits.ContinueLoc = L; }
 
   SourceLocation getBeginLoc() const { return getContinueLoc(); }
-  SourceLocation getEndLoc() const { return getContinueLoc(); }
+  SourceLocation getEndLoc() const { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ContinueStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
 /// BreakStmt - This represents a break.
 class BreakStmt : public Stmt {
+  SourceLocation EndLoc; // Location of final ';'
 public:
-  BreakStmt(SourceLocation BL) : Stmt(BreakStmtClass) {
+  BreakStmt(SourceLocation BL, SourceLocation EL) : Stmt(BreakStmtClass), EndLoc(EL) {
     setBreakLoc(BL);
   }
 
   /// Build an empty break statement.
   explicit BreakStmt(EmptyShell Empty) : Stmt(BreakStmtClass, Empty) {}
 
   SourceLocation getBreakLoc() const { return BreakStmtBits.BreakLoc; }
   void setBreakLoc(SourceLocation L) { BreakStmtBits.BreakLoc = L; }
 
   SourceLocation getBeginLoc() const { return getBreakLoc(); }
-  SourceLocation getEndLoc() const { return getBreakLoc(); }
+  SourceLocation getEndLoc() const { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == BreakStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
class ReturnStmt final
   /// True if this ReturnStmt has storage for an NRVO candidate.
   bool hasNRVOCandidate() const { return ReturnStmtBits.HasNRVOCandidate; }
 
   unsigned numTrailingObjects(OverloadToken<const VarDecl *>) const {
     return hasNRVOCandidate();
   }
 
   /// Build a return statement.
-  ReturnStmt(SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate);
+  ReturnStmt(SourceLocation RL, SourceLocation EL, Expr *E,
+             const VarDecl *NRVOCandidate);
 
   /// Build an empty return statement.
   explicit ReturnStmt(EmptyShell Empty, bool HasNRVOCandidate);
 
+  SourceLocation EndLoc; // Location of final ';'
 public:
   /// Create a return statement.
-  static ReturnStmt *Create(const ASTContext &Ctx, SourceLocation RL, Expr *E,
+  static ReturnStmt *Create(const ASTContext &Ctx, SourceLocation RL, SourceLocation EL, Expr *E,
                             const VarDecl *NRVOCandidate);
 
   /// Create an empty return statement, optionally with
   /// storage for an NRVO candidate.
   static ReturnStmt *CreateEmpty(const ASTContext &Ctx, bool HasNRVOCandidate);
 
   Expr *getRetValue() { return reinterpret_cast<Expr *>(RetExpr); }
   const Expr *getRetValue() const { return reinterpret_cast<Expr *>(RetExpr); }
assert(hasNRVOCandidate() &&
            "This return statement has no storage for an NRVO candidate!");
     *getTrailingObjects<const VarDecl *>() = Var;
   }
 
   SourceLocation getReturnLoc() const { return ReturnStmtBits.RetLoc; }
   void setReturnLoc(SourceLocation L) { ReturnStmtBits.RetLoc = L; }
 
   SourceLocation getBeginLoc() const { return getReturnLoc(); }
-  SourceLocation getEndLoc() const LLVM_READONLY {
-    return RetExpr ? RetExpr->getEndLoc() : getReturnLoc();
-  }
+  SourceLocation getEndLoc() const LLVM_READONLY { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ReturnStmtClass;
   }
 
   // Iterators
   child_range children() {
     if (RetExpr)
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHTryStmtClass;
   }
 };
 
 /// Represents a __leave statement.
 class SEHLeaveStmt : public Stmt {
   SourceLocation LeaveLoc;
+  SourceLocation EndLoc; // Location of final ';'
 
 public:
-  explicit SEHLeaveStmt(SourceLocation LL)
-      : Stmt(SEHLeaveStmtClass), LeaveLoc(LL) {}
+  explicit SEHLeaveStmt(SourceLocation LL, SourceLocation EL)
+      : Stmt(SEHLeaveStmtClass), LeaveLoc(LL), EndLoc(EL) {}
 
   /// Build an empty __leave statement.
   explicit SEHLeaveStmt(EmptyShell Empty) : Stmt(SEHLeaveStmtClass, Empty) {}
 
   SourceLocation getLeaveLoc() const { return LeaveLoc; }
   void setLeaveLoc(SourceLocation L) { LeaveLoc = L; }
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return LeaveLoc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return LeaveLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY { return EndLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == SEHLeaveStmtClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());

clang/include/clang/Parse/Parser.h

private:
   /// A SmallVector of statements, with stack size 32 (as that is the only one
   /// used.)
   typedef SmallVector<Stmt*, 32> StmtVector;
   /// A SmallVector of expressions, with stack size 12 (the maximum used.)
   typedef SmallVector<Expr*, 12> ExprVector;
   /// A SmallVector of types.
   typedef SmallVector<ParsedType, 12> TypeVector;
 
+  SourceLocation consumeStatementEndingSemicolon(const char *SemiError);
+
   StmtResult
   ParseStatement(SourceLocation *TrailingElseLoc = nullptr,
                  ParsedStmtContext StmtCtx = ParsedStmtContext::SubStmt);
   StmtResult ParseStatementOrDeclaration(
       StmtVector &Stmts, ParsedStmtContext StmtCtx,
       SourceLocation *TrailingElseLoc = nullptr);
   StmtResult ParseStatementOrDeclarationAfterAttributes(
                                          StmtVector &Stmts,

clang/include/clang/Sema/Sema.h

StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
                                     Stmt *InitStmt,
                                     ConditionResult Cond);
   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);
+                         Expr *Cond, SourceLocation CondRParen,
+                         SourceLocation EndLoc);
 
   StmtResult ActOnForStmt(SourceLocation ForLoc,
                           SourceLocation LParenLoc,
                           Stmt *First,
                           ConditionResult Second,
                           FullExprArg Third,
                           SourceLocation RParenLoc,
                           Stmt *Body);
StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
                                   SourceLocation ColonLoc,
                                   Stmt *RangeDecl, Stmt *Begin, Stmt *End,
                                   Expr *Cond, Expr *Inc,
                                   Stmt *LoopVarDecl,
                                   SourceLocation RParenLoc,
                                   BuildForRangeKind Kind);
   StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
 
-  StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
-                           SourceLocation LabelLoc,
-                           LabelDecl *TheDecl);
+  StmtResult ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
+                           SourceLocation EndLoc, LabelDecl *TheDecl);
   StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
                                    SourceLocation StarLoc,
-                                   Expr *DestExp);
-  StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
-  StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
+                                   SourceLocation EndLoc, Expr *DestExp);
+  StmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
+                               SourceLocation EndLoc, Scope *CurScope);
+  StmtResult ActOnBreakStmt(SourceLocation BreakLoc, SourceLocation EndLoc,
+                            Scope *CurScope);
 
   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);
CES_AsIfByStdMove = (CES_AllowParameters | CES_AllowDifferentTypes |
                          CES_AllowExceptionVariables),
   };
 
   VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,
                                    CopyElisionSemanticsKind CESK);
   bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,
                               CopyElisionSemanticsKind CESK);
 
-  StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
-                             Scope *CurScope);
-  StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
-  StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
+  StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, SourceLocation EndLoc,
+                             Expr *RetValExp, Scope *CurScope);
+  StmtResult BuildReturnStmt(SourceLocation ReturnLoc, SourceLocation EndLoc,
+                             Expr *RetValExp);
+  StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc,
+                                     SourceLocation EndLoc, Expr *RetValExp);
 
   StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
                              bool IsVolatile, unsigned NumOutputs,
                              unsigned NumInputs, IdentifierInfo **Names,
                              MultiExprArg Constraints, MultiExprArg Exprs,
                              Expr *AsmString, MultiExprArg Clobbers,
                              unsigned NumLabels,
                              SourceLocation RParenLoc);
StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
                               SourceLocation TryLoc, Stmt *TryBlock,
                               Stmt *Handler);
   StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
                                  Expr *FilterExpr,
                                  Stmt *Block);
   void ActOnStartSEHFinallyBlock();
   void ActOnAbortSEHFinallyBlock();
   StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
-  StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
+  StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, SourceLocation EndLoc,
+                               Scope *CurScope);
 
   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);

 
   //===--------------------------------------------------------------------===//
   // C++ Coroutines TS
   //
   bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,
                                StringRef Keyword);
   ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
   ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
-  StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);
+  StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc,
+                               SourceLocation EndLoc, Expr *E);
 
   ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
                                       bool IsImplicit = false);
   ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
                                         UnresolvedLookupExpr* Lookup);
   ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
   StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
                                bool IsImplicit = false);

clang/lib/AST/ASTImporter.cpp

 ExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) {
 
   Error Err = Error::success();
   auto ToBody = importChecked(Err, S->getBody());
   auto ToCond = importChecked(Err, S->getCond());
   auto ToDoLoc = importChecked(Err, S->getDoLoc());
   auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
+  auto ToEndLoc = importChecked(Err, S->getEndLoc());
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) DoStmt(
-      ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
+  return new (Importer.getToContext())
+      DoStmt(ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc, ToEndLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {
 
   Error Err = Error::success();
   auto ToInit = importChecked(Err, S->getInit());
   auto ToCond = importChecked(Err, S->getCond());
   auto ToConditionVariable = importChecked(Err, S->getConditionVariable());

 }
 
 ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
 
   Error Err = Error::success();
   auto ToLabel = importChecked(Err, S->getLabel());
   auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
   auto ToLabelLoc = importChecked(Err, S->getLabelLoc());
+  auto ToEndLoc = importChecked(Err, S->getEndLoc());
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) GotoStmt(
-      ToLabel, ToGotoLoc, ToLabelLoc);
+  return new (Importer.getToContext())
+      GotoStmt(ToLabel, ToGotoLoc, ToLabelLoc, ToEndLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 
   Error Err = Error::success();
   auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
   auto ToStarLoc = importChecked(Err, S->getStarLoc());
   auto ToTarget = importChecked(Err, S->getTarget());
   if (Err)
     return std::move(Err);
 
   return new (Importer.getToContext()) IndirectGotoStmt(
       ToGotoLoc, ToStarLoc, ToTarget);
 }
 
 ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
-  ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
-  if (!ToContinueLocOrErr)
-    return ToContinueLocOrErr.takeError();
-  return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr);
+  Error Err = Error::success();
+  auto ToContinueLoc = importChecked(Err, S->getContinueLoc());
+  auto ToEndLoc = importChecked(Err, S->getEndLoc());
+  if (Err)
+    return std::move(Err);
+  return new (Importer.getToContext()) ContinueStmt(ToContinueLoc, ToEndLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
-  auto ToBreakLocOrErr = import(S->getBreakLoc());
-  if (!ToBreakLocOrErr)
-    return ToBreakLocOrErr.takeError();
-  return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr);
+  Error Err = Error::success();
+  auto ToBreakLoc = importChecked(Err, S->getBreakLoc());
+  auto ToEndLoc = importChecked(Err, S->getEndLoc());
+  if (Err)
+    return std::move(Err);
+
+  return new (Importer.getToContext()) BreakStmt(ToBreakLoc, ToEndLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
 
   Error Err = Error::success();
   auto ToReturnLoc = importChecked(Err, S->getReturnLoc());
   auto ToRetValue = importChecked(Err, S->getRetValue());
   auto ToNRVOCandidate = importChecked(Err, S->getNRVOCandidate());
+  auto ToEndLoc = importChecked(Err, S->getEndLoc());
   if (Err)
     return std::move(Err);
 
-  return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToRetValue,
-                            ToNRVOCandidate);
+  return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToEndLoc,
+                            ToRetValue, ToNRVOCandidate);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
 
   Error Err = Error::success();
   auto ToCatchLoc = importChecked(Err, S->getCatchLoc());
   auto ToExceptionDecl = importChecked(Err, S->getExceptionDecl());
   auto ToHandlerBlock = importChecked(Err, S->getHandlerBlock());

clang/lib/AST/Stmt.cpp

 // IndirectGotoStmt
 LabelDecl *IndirectGotoStmt::getConstantTarget() {
   if (auto *E = dyn_cast<AddrLabelExpr>(getTarget()->IgnoreParenImpCasts()))
     return E->getLabel();
   return nullptr;
 }
 
 // ReturnStmt
-ReturnStmt::ReturnStmt(SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
-    : Stmt(ReturnStmtClass), RetExpr(E) {
+ReturnStmt::ReturnStmt(SourceLocation RL, SourceLocation EL, Expr *E,
+                       const VarDecl *NRVOCandidate)
+    : Stmt(ReturnStmtClass), RetExpr(E), EndLoc(EL) {
   bool HasNRVOCandidate = NRVOCandidate != nullptr;
   ReturnStmtBits.HasNRVOCandidate = HasNRVOCandidate;
   if (HasNRVOCandidate)
     setNRVOCandidate(NRVOCandidate);
   setReturnLoc(RL);
 }
 
 ReturnStmt::ReturnStmt(EmptyShell Empty, bool HasNRVOCandidate)
     : Stmt(ReturnStmtClass, Empty) {
   ReturnStmtBits.HasNRVOCandidate = HasNRVOCandidate;
 }
 
 ReturnStmt *ReturnStmt::Create(const ASTContext &Ctx, SourceLocation RL,
-                               Expr *E, const VarDecl *NRVOCandidate) {
+                               SourceLocation EL, Expr *E,
+                               const VarDecl *NRVOCandidate) {
   bool HasNRVOCandidate = NRVOCandidate != nullptr;
   void *Mem = Ctx.Allocate(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),
                            alignof(ReturnStmt));
-  return new (Mem) ReturnStmt(RL, E, NRVOCandidate);
+  return new (Mem) ReturnStmt(RL, EL, E, NRVOCandidate);
 }
 
 ReturnStmt *ReturnStmt::CreateEmpty(const ASTContext &Ctx,
                                     bool HasNRVOCandidate) {
   void *Mem = Ctx.Allocate(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),
                            alignof(ReturnStmt));
   return new (Mem) ReturnStmt(EmptyShell(), HasNRVOCandidate);
 }

clang/lib/Analysis/BodyFarm.cpp

ObjCIvarRefExpr *ASTMaker::makeObjCIvarRef(const Expr *Base,
                                            const ObjCIvarDecl *IVar) {
   return new (C) ObjCIvarRefExpr(const_cast<ObjCIvarDecl*>(IVar),
                                  IVar->getType(), SourceLocation(),
                                  SourceLocation(), const_cast<Expr*>(Base),
                                  /*arrow=*/true, /*free=*/false);
 }
 
 ReturnStmt *ASTMaker::makeReturn(const Expr *RetVal) {
-  return ReturnStmt::Create(C, SourceLocation(), const_cast<Expr *>(RetVal),
+  return ReturnStmt::Create(C, SourceLocation(), SourceLocation(),
+                            const_cast<Expr *>(RetVal),
                             /* NRVOCandidate=*/nullptr);
 }
 
 IntegerLiteral *ASTMaker::makeIntegerLiteral(uint64_t Value, QualType Ty) {
   llvm::APInt APValue = llvm::APInt(C.getTypeSize(Ty), Value);
   return IntegerLiteral::Create(C, APValue, Ty, SourceLocation());
 }
 

clang/lib/CodeGen/CGObjC.cpp

 void
 CodeGenFunction::generateObjCGetterBody(const ObjCImplementationDecl *classImpl,
                                         const ObjCPropertyImplDecl *propImpl,
                                         const ObjCMethodDecl *GetterMethodDecl,
                                         llvm::Constant *AtomicHelperFn) {
   // If there's a non-trivial 'get' expression, we just have to emit that.
   if (!hasTrivialGetExpr(propImpl)) {
     if (!AtomicHelperFn) {
-      auto *ret = ReturnStmt::Create(getContext(), SourceLocation(),
-                                     propImpl->getGetterCXXConstructor(),
-                                     /* NRVOCandidate=*/nullptr);
+      auto *ret =
+          ReturnStmt::Create(getContext(), SourceLocation(), SourceLocation(),
       EmitReturnStmt(*ret);
     }
     else {
       ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();
       emitCPPObjectAtomicGetterCall(*this, ReturnValue.getPointer(),
                                     ivar, AtomicHelperFn);
     }
     return;

clang/lib/Parse/ParseStmt.cpp

std::unique_ptr<CorrectionCandidateCallback> clone() override {
     return std::make_unique<StatementFilterCCC>(*this);
   }
 
 private:
   Token NextToken;
 };
 }
 
+SourceLocation Parser::consumeStatementEndingSemicolon(const char *SemiError) {
+  SourceLocation Loc;
+  // If we reached this code, the statement must end in a semicolon.
+  if (!TryConsumeToken(tok::semi, Loc)) {
+    // If the result was valid, then we do want to diagnose this.  Use
+    // ExpectAndConsume to emit the diagnostic, even though we know it won't
+    // succeed.
+    ExpectAndConsume(tok::semi, diag::err_expected_semi_after_stmt, SemiError);
+    // Skip until we see a } or ;, but don't eat it.
+    SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
+  }
+  return Loc;
+}
+
 StmtResult Parser::ParseStatementOrDeclarationAfterAttributes(
     StmtVector &Stmts, ParsedStmtContext StmtCtx,
     SourceLocation *TrailingElseLoc, ParsedAttributesWithRange &Attrs) {
-  const char *SemiError = nullptr;
-  StmtResult Res;
+  StmtResult Res; //< deprecated
   SourceLocation GNUAttributeLoc;
 
-  // Cases in this switch statement should fall through if the parser expects
-  // the token to end in a semicolon (in which case SemiError should be set),
-  // or they directly 'return;' if not.
 Retry:
   tok::TokenKind Kind  = Tok.getKind();
   SourceLocation AtLoc;
+
+  // Each case should return directly.
   switch (Kind) {
   case tok::at: // May be a @try or @throw statement
     {
       ProhibitAttributes(Attrs); // TODO: is it correct?
       AtLoc = ConsumeToken();  // consume @
       return ParseObjCAtStatement(AtLoc, StmtCtx);
     }
 
Retry:
   case tok::kw_if:                  // C99 6.8.4.1: if-statement
     return ParseIfStatement(TrailingElseLoc);
   case tok::kw_switch:              // C99 6.8.4.2: switch-statement
     return ParseSwitchStatement(TrailingElseLoc);
 
   case tok::kw_while:               // C99 6.8.5.1: while-statement
     return ParseWhileStatement(TrailingElseLoc);
   case tok::kw_do:                  // C99 6.8.5.2: do-statement
-    Res = ParseDoStatement();
-    SemiError = "do/while";
-    break;
+    return ParseDoStatement();
   case tok::kw_for:                 // C99 6.8.5.3: for-statement
     return ParseForStatement(TrailingElseLoc);
 
   case tok::kw_goto:                // C99 6.8.6.1: goto-statement
     Res = ParseGotoStatement();
-    SemiError = "goto";
-    break;
+    return Res;
   case tok::kw_continue:            // C99 6.8.6.2: continue-statement
     Res = ParseContinueStatement();
-    SemiError = "continue";
-    break;
+    return Res;
   case tok::kw_break:               // C99 6.8.6.3: break-statement
     Res = ParseBreakStatement();
-    SemiError = "break";
-    break;
+    return Res;
   case tok::kw_return:              // C99 6.8.6.4: return-statement
     Res = ParseReturnStatement();
-    SemiError = "return";
-    break;
+    return Res;
   case tok::kw_co_return:            // C++ Coroutines: co_return statement
     Res = ParseReturnStatement();
-    SemiError = "co_return";
-    break;
+    consumeStatementEndingSemicolon("co_return");
+    return Res;
 
   case tok::kw_asm: {
     ProhibitAttributes(Attrs);
     bool msAsm = false;
     Res = ParseAsmStatement(msAsm);
     Res = Actions.ActOnFinishFullStmt(Res.get());
     if (msAsm) return Res;
-    SemiError = "asm";
-    break;
+    consumeStatementEndingSemicolon("asm");
+    return Res;
   }
 
   case tok::kw___if_exists:
   case tok::kw___if_not_exists:
     ProhibitAttributes(Attrs);
     ParseMicrosoftIfExistsStatement(Stmts);
     // An __if_exists block is like a compound statement, but it doesn't create
     // a new scope.
     return StmtEmpty();
 
   case tok::kw_try:                 // C++ 15: try-block
     return ParseCXXTryBlock();
 
   case tok::kw___try:
     ProhibitAttributes(Attrs); // TODO: is it correct?
     return ParseSEHTryBlock();
 
   case tok::kw___leave:
     Res = ParseSEHLeaveStatement();
-    SemiError = "__leave";
-    break;
+    consumeStatementEndingSemicolon("__leave");
+    return Res;
 
   case tok::annot_pragma_vis:
     ProhibitAttributes(Attrs);
     HandlePragmaVisibility();
     return StmtEmpty();
 
   case tok::annot_pragma_pack:
     ProhibitAttributes(Attrs);
case tok::annot_pragma_dump:
     HandlePragmaDump();
     return StmtEmpty();
 
   case tok::annot_pragma_attribute:
     HandlePragmaAttribute();
     return StmtEmpty();
   }
 
-  // If we reached this code, the statement must end in a semicolon.
-  if (!TryConsumeToken(tok::semi) && !Res.isInvalid()) {
-    // If the result was valid, then we do want to diagnose this.  Use
-    // ExpectAndConsume to emit the diagnostic, even though we know it won't
-    // succeed.
-    ExpectAndConsume(tok::semi, diag::err_expected_semi_after_stmt, SemiError);
-    // Skip until we see a } or ;, but don't eat it.
-    SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
-  }
-
   return Res;
 }
 
 /// Parse an expression statement.
 StmtResult Parser::ParseExprStatement(ParsedStmtContext StmtCtx) {
   // If a case keyword is missing, this is where it should be inserted.
   Token OldToken = Tok;
 

 }
 
 /// Handle __leave
 ///
 /// seh-leave-statement:
 ///   '__leave' ';'
 ///
 StmtResult Parser::ParseSEHLeaveStatement() {
-  SourceLocation LeaveLoc = ConsumeToken();  // eat the '__leave'.
-  return Actions.ActOnSEHLeaveStmt(LeaveLoc, getCurScope());
+  const SourceLocation LeaveLoc = ConsumeToken(); // eat the '__leave'.
+  const SourceLocation EndLoc = consumeStatementEndingSemicolon("__leave");
+  return Actions.ActOnSEHLeaveStmt(LeaveLoc, EndLoc, getCurScope());
 }
 
 /// ParseLabeledStatement - We have an identifier and a ':' after it.
 ///
 ///       labeled-statement:
 ///         identifier ':' statement
 /// [GNU]   identifier ':' attributes[opt] statement
 ///
if (Cond.isInvalid() || Body.isInvalid())
     return StmtError();
 
   return Actions.ActOnWhileStmt(WhileLoc, Cond, Body.get());
 }
 
 /// ParseDoStatement
 ///       do-statement: [C99 6.8.5.2]
 ///         'do' statement 'while' '(' expression ')' ';'
-/// Note: this lets the caller parse the end ';'.
 StmtResult Parser::ParseDoStatement() {
   assert(Tok.is(tok::kw_do) && "Not a do stmt!");
   SourceLocation DoLoc = ConsumeToken();  // eat the 'do'.
 
   // C99 6.8.5p5 - In C99, the do statement is a block.  This is not
   // the case for C90.  Start the loop scope.
   unsigned ScopeFlags;
   if (getLangOpts().C99)
StmtResult Parser::ParseDoStatement() {
 
   // Pop the body scope if needed.
   InnerScope.Exit();
 
   if (Tok.isNot(tok::kw_while)) {
     if (!Body.isInvalid()) {
       Diag(Tok, diag::err_expected_while);
       Diag(DoLoc, diag::note_matching) << "'do'";
-      SkipUntil(tok::semi, StopBeforeMatch);
+      SkipUntil(tok::semi);
     }
     return StmtError();
   }
   SourceLocation WhileLoc = ConsumeToken();
 
   if (Tok.isNot(tok::l_paren)) {
     Diag(Tok, diag::err_expected_lparen_after) << "do/while";
-    SkipUntil(tok::semi, StopBeforeMatch);
+    SkipUntil(tok::semi);
     return StmtError();
   }
 
   // Parse the parenthesized expression.
   BalancedDelimiterTracker T(*this, tok::l_paren);
   T.consumeOpen();
 
   // A do-while expression is not a condition, so can't have attributes.
   DiagnoseAndSkipCXX11Attributes();
 
   ExprResult Cond = ParseExpression();
   // Correct the typos in condition before closing the scope.
   if (Cond.isUsable())
     Cond = Actions.CorrectDelayedTyposInExpr(Cond);
   T.consumeClose();
   DoScope.Exit();
 
   if (Cond.isInvalid() || Body.isInvalid())
     return StmtError();
 
+  SourceLocation EndLoc = consumeStatementEndingSemicolon("do/while");
+
   return Actions.ActOnDoStmt(DoLoc, Body.get(), WhileLoc, T.getOpenLocation(),
-                             Cond.get(), T.getCloseLocation());
+                             Cond.get(), T.getCloseLocation(), EndLoc);
 }
 
 bool Parser::isForRangeIdentifier() {
   assert(Tok.is(tok::identifier));
 
   const Token &Next = NextToken();
   if (Next.is(tok::colon))
     return true;
return Actions.ActOnForStmt(ForLoc, T.getOpenLocation(), FirstPart.get(),
                               SecondPart, ThirdPart, T.getCloseLocation(),
                               Body.get());
 }
 
 /// ParseGotoStatement
 ///       jump-statement:
 ///         'goto' identifier ';'
 /// [GNU]   'goto' '*' expression ';'
-///
-/// Note: this lets the caller parse the end ';'.
-///
 StmtResult Parser::ParseGotoStatement() {
   assert(Tok.is(tok::kw_goto) && "Not a goto stmt!");
   SourceLocation GotoLoc = ConsumeToken();  // eat the 'goto'.
 
   StmtResult Res;
   if (Tok.is(tok::identifier)) {
     LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
                                                 Tok.getLocation());
-    Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), LD);
     ConsumeToken();
+    const SourceLocation EndLoc = consumeStatementEndingSemicolon("goto");
+    Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), EndLoc, LD);
+
   } else if (Tok.is(tok::star)) {
     // GNU indirect goto extension.
     Diag(Tok, diag::ext_gnu_indirect_goto);
     SourceLocation StarLoc = ConsumeToken();
     ExprResult R(ParseExpression());
     if (R.isInvalid()) {  // Skip to the semicolon, but don't consume it.
       SkipUntil(tok::semi, StopBeforeMatch);
       return StmtError();
     }
-    Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.get());
+    const SourceLocation EndLoc = consumeStatementEndingSemicolon("goto");
+    Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, EndLoc, R.get());
   } else {
     Diag(Tok, diag::err_expected) << tok::identifier;
     return StmtError();
   }
 
   return Res;
 }
 
 /// ParseContinueStatement
 ///       jump-statement:
 ///         'continue' ';'
-///
-/// Note: this lets the caller parse the end ';'.
-///
 StmtResult Parser::ParseContinueStatement() {
-  SourceLocation ContinueLoc = ConsumeToken();  // eat the 'continue'.
-  return Actions.ActOnContinueStmt(ContinueLoc, getCurScope());
+  const SourceLocation ContinueLoc = ConsumeToken(); // eat the 'continue'.
+  const SourceLocation EndLoc = consumeStatementEndingSemicolon("continue");
+  return Actions.ActOnContinueStmt(ContinueLoc, EndLoc, getCurScope());
 }
 
 /// ParseBreakStatement
 ///       jump-statement:
 ///         'break' ';'
-///
-/// Note: this lets the caller parse the end ';'.
-///
 StmtResult Parser::ParseBreakStatement() {
-  SourceLocation BreakLoc = ConsumeToken();  // eat the 'break'.
-  return Actions.ActOnBreakStmt(BreakLoc, getCurScope());
+  const SourceLocation BreakLoc = ConsumeToken(); // eat the 'break'.
+  const SourceLocation EndLoc = consumeStatementEndingSemicolon("continue");
+  return Actions.ActOnBreakStmt(BreakLoc, EndLoc, getCurScope());
 }
 
 /// ParseReturnStatement
 ///       jump-statement:
 ///         'return' expression[opt] ';'
 ///         'return' braced-init-list ';'
 ///         'co_return' expression[opt] ';'
 ///         'co_return' braced-init-list ';'
if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus) {
             << R.get()->getSourceRange();
     } else
       R = ParseExpression();
     if (R.isInvalid()) {
       SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
       return StmtError();
     }
   }
+
+  const SourceLocation EndLoc = consumeStatementEndingSemicolon("return");
+
   if (IsCoreturn)
-    return Actions.ActOnCoreturnStmt(getCurScope(), ReturnLoc, R.get());
-  return Actions.ActOnReturnStmt(ReturnLoc, R.get(), getCurScope());
+    return Actions.ActOnCoreturnStmt(getCurScope(), ReturnLoc, EndLoc, R.get());
+  return Actions.ActOnReturnStmt(ReturnLoc, EndLoc, R.get(), getCurScope());
 }
 
 StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts,
                                        ParsedStmtContext StmtCtx,
                                        SourceLocation *TrailingElseLoc,
                                        ParsedAttributesWithRange &Attrs) {
   // Create temporary attribute list.
   ParsedAttributesWithRange TempAttrs(AttrFactory);

clang/lib/Sema/SemaCoroutine.cpp

ExprResult Sema::BuildCoyieldExpr(SourceLocation Loc, Expr *E) {
 
   Expr *Res =
       new (Context) CoyieldExpr(Loc, E, RSS.Results[0], RSS.Results[1],
                                 RSS.Results[2], RSS.OpaqueValue);
 
   return Res;
 }
 
-StmtResult Sema::ActOnCoreturnStmt(Scope *S, SourceLocation Loc, Expr *E) {
+StmtResult Sema::ActOnCoreturnStmt(Scope *S, SourceLocation Loc,
+                                   SourceLocation EndLoc, Expr *E) {
   if (!ActOnCoroutineBodyStart(S, Loc, "co_return")) {
     CorrectDelayedTyposInExpr(E);
     return StmtError();
   }
-  return BuildCoreturnStmt(Loc, E);
+  return BuildCoreturnStmt(Loc, /* EndLoc, */ E);
 }
 
 StmtResult Sema::BuildCoreturnStmt(SourceLocation Loc, Expr *E,
                                    bool IsImplicit) {
   auto *FSI = checkCoroutineContext(*this, Loc, "co_return", IsImplicit);
   if (!FSI)
     return StmtError();
 
bool CoroutineStmtBuilder::makeReturnOnAllocFailure() {
   if (!diagReturnOnAllocFailure(S, DeclNameExpr.get(), PromiseRecordDecl, Fn))
     return false;
 
   ExprResult ReturnObjectOnAllocationFailure =
       S.BuildCallExpr(nullptr, DeclNameExpr.get(), Loc, {}, Loc);
   if (ReturnObjectOnAllocationFailure.isInvalid())
     return false;
 
-  StmtResult ReturnStmt =
-      S.BuildReturnStmt(Loc, ReturnObjectOnAllocationFailure.get());
+  StmtResult ReturnStmt = S.BuildReturnStmt(
+      Loc, /*End*/ Loc, ReturnObjectOnAllocationFailure.get());
   if (ReturnStmt.isInvalid()) {
     S.Diag(Found.getFoundDecl()->getLocation(), diag::note_member_declared_here)
         << DN;
     S.Diag(Fn.FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
         << Fn.getFirstCoroutineStmtKeyword();
     return false;
   }
 
if (GroDeclStmt.isInvalid())
     return false;
 
   this->ResultDecl = GroDeclStmt.get();
 
   ExprResult declRef = S.BuildDeclRefExpr(GroDecl, GroType, VK_LValue, Loc);
   if (declRef.isInvalid())
     return false;
 
-  StmtResult ReturnStmt = S.BuildReturnStmt(Loc, declRef.get());
+  StmtResult ReturnStmt = S.BuildReturnStmt(Loc, /*End*/ Loc, declRef.get());
   if (ReturnStmt.isInvalid()) {
     noteMemberDeclaredHere(S, ReturnValue, Fn);
     return false;
   }
   if (cast<clang::ReturnStmt>(ReturnStmt.get())->getNRVOCandidate() == GroDecl)
     GroDecl->setNRVOVariable(true);
 
   this->ReturnStmt = ReturnStmt.get();

clang/lib/Sema/SemaDeclCXX.cpp

StmtResult build() {
     case DefaultedComparisonKind::Relational:
       RetVal = cast<Expr>(Stmts.Stmts.pop_back_val());
       break;
     }
 
     // Build the final return statement.
     if (RetVal.isInvalid())
       return StmtError();
-    StmtResult ReturnStmt = S.BuildReturnStmt(Loc, RetVal.get());
+    StmtResult ReturnStmt = S.BuildReturnStmt(Loc, /*End*/ Loc, RetVal.get());
     if (ReturnStmt.isInvalid())
       return StmtError();
     Stmts.Stmts.push_back(ReturnStmt.get());
 
     return S.ActOnCompoundStmt(Loc, Loc, Stmts.Stmts, /*IsStmtExpr=*/false);
   }
 
 private:
if (Cond.isInvalid())
       return StmtError();
 
     ExprResult NotCond = S.CreateBuiltinUnaryOp(Loc, UO_LNot, Cond.get());
     if (NotCond.isInvalid())
       return StmtError();
 
     ExprResult False = S.ActOnCXXBoolLiteral(Loc, tok::kw_false);
     assert(!False.isInvalid() && "should never fail");
-    StmtResult ReturnFalse = S.BuildReturnStmt(Loc, False.get());
+    StmtResult ReturnFalse = S.BuildReturnStmt(Loc, /*End*/ Loc, False.get());
     if (ReturnFalse.isInvalid())
       return StmtError();
 
     return S.ActOnIfStmt(Loc, false, nullptr,
                          S.ActOnCondition(nullptr, Loc, NotCond.get(),
                                           Sema::ConditionKind::Boolean),
                          ReturnFalse.get(), SourceLocation(), nullptr);
   }
case DefaultedComparisonKind::ThreeWay: {
           nullptr, Loc, Comp.get(), Sema::ConditionKind::Boolean);
       if (Cond.isInvalid())
         return StmtError();
 
       // return cmp;
       VDRef = getDecl(VD);
       if (VDRef.isInvalid())
         return StmtError();
-      StmtResult ReturnStmt = S.BuildReturnStmt(Loc, VDRef.get());
+      StmtResult ReturnStmt = S.BuildReturnStmt(Loc, /*End*/ Loc, VDRef.get());
       if (ReturnStmt.isInvalid())
         return StmtError();
 
       // if (...)
       return S.ActOnIfStmt(Loc, /*IsConstexpr=*/false, InitStmt, Cond,
                            ReturnStmt.get(), /*ElseLoc=*/SourceLocation(),
                            /*Else=*/nullptr);
     }
for (auto *Field : ClassDecl->fields()) {
     // Success! Record the copy.
     Statements.push_back(Copy.getAs<Stmt>());
   }
 
   if (!Invalid) {
     // Add a "return *this;"
     ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
 
-    StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
+    StmtResult Return = BuildReturnStmt(Loc, /*End*/ Loc, ThisObj.get());
     if (Return.isInvalid())
       Invalid = true;
     else
       Statements.push_back(Return.getAs<Stmt>());
   }
 
   if (Invalid) {
     CopyAssignOperator->setInvalidDecl();
for (auto *Field : ClassDecl->fields()) {
     Statements.push_back(Move.getAs<Stmt>());
   }
 
   if (!Invalid) {
     // Add a "return *this;"
     ExprResult ThisObj =
         CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
 
-    StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
+    StmtResult Return = BuildReturnStmt(Loc, /*End*/ Loc, ThisObj.get());
     if (Return.isInvalid())
       Invalid = true;
     else
       Statements.push_back(Return.getAs<Stmt>());
   }
 
   if (Invalid) {
     MoveAssignOperator->setInvalidDecl();
void Sema::DefineImplicitLambdaToFunctionPointerConversion(
   Invoker->setReferenced();
   Invoker->setType(Conv->getReturnType()->getPointeeType());
   Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
 
   // Construct the body of the conversion function { return __invoke; }.
   Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
                                        VK_LValue, Conv->getLocation());
   assert(FunctionRef && "Can't refer to __invoke function?");
-  Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
+  Stmt *Return =
+      BuildReturnStmt(Conv->getLocation(), Conv->getEndLoc(), FunctionRef)
+          .get();
   Conv->setBody(CompoundStmt::Create(Context, Return, Conv->getLocation(),
                                      Conv->getLocation()));
   Conv->markUsed(Context);
   Conv->setReferenced();
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(Conv);
     L->CompletedImplicitDefinition(Invoker);
void Sema::DefineImplicitLambdaToBlockPointerConversion(
   if (BuildBlock.isInvalid()) {
     Diag(CurrentLocation, diag::note_lambda_to_block_conv);
     Conv->setInvalidDecl();
     return;
   }
 
   // Create the return statement that returns the block from the conversion
   // function.
-  StmtResult Return = BuildReturnStmt(Conv->getLocation(), BuildBlock.get());
+  StmtResult Return =
+      BuildReturnStmt(Conv->getLocation(), Conv->getEndLoc(), BuildBlock.get());
   if (Return.isInvalid()) {
     Diag(CurrentLocation, diag::note_lambda_to_block_conv);
     Conv->setInvalidDecl();
     return;
   }
 
   // Set the body of the conversion function.
   Stmt *ReturnS = Return.get();

clang/lib/Sema/SemaStmt.cpp

StmtResult Sema::ActOnWhileStmt(SourceLocation WhileLoc, ConditionResult Cond,
 
   if (isa<NullStmt>(Body))
     getCurCompoundScope().setHasEmptyLoopBodies();
 
   return WhileStmt::Create(Context, CondVal.first, CondVal.second, Body,
                            WhileLoc);
 }
 
-StmtResult
-Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
+StmtResult Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
                              SourceLocation WhileLoc, SourceLocation CondLParen,
-                  Expr *Cond, SourceLocation CondRParen) {
+                             Expr *Cond, SourceLocation CondRParen,
+                             SourceLocation EndLoc) {
   assert(Cond && "ActOnDoStmt(): missing expression");
 
   CheckBreakContinueBinding(Cond);
   ExprResult CondResult = CheckBooleanCondition(DoLoc, Cond);
   if (CondResult.isInvalid())
     return StmtError();
   Cond = CondResult.get();
 
   CondResult = ActOnFinishFullExpr(Cond, DoLoc, /*DiscardedValue*/ false);
   if (CondResult.isInvalid())
     return StmtError();
   Cond = CondResult.get();
 
   // Only call the CommaVisitor for C89 due to differences in scope flags.
   if (Cond && !getLangOpts().C99 && !getLangOpts().CPlusPlus &&
       !Diags.isIgnored(diag::warn_comma_operator, Cond->getExprLoc()))
     CommaVisitor(*this).Visit(Cond);
 
-  return new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen);
+  return new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen, EndLoc);
 }
 
 namespace {
   // Use SetVector since the diagnostic cares about the ordering of the Decl's.
   using DeclSetVector =
       llvm::SetVector<VarDecl *, llvm::SmallVector<VarDecl *, 8>,
                       llvm::SmallPtrSet<VarDecl *, 8>>;
 
StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
   DiagnoseEmptyStmtBody(ForStmt->getRParenLoc(), B,
                         diag::warn_empty_range_based_for_body);
 
   DiagnoseForRangeVariableCopies(*this, ForStmt);
 
   return S;
 }
 
-StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
-                               SourceLocation LabelLoc,
-                               LabelDecl *TheDecl) {
+StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
+                               SourceLocation EndLoc, LabelDecl *TheDecl) {
   setFunctionHasBranchIntoScope();
   TheDecl->markUsed(Context);
-  return new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc);
+  return new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc, EndLoc);
 }
 
-StmtResult
-Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
-                            Expr *E) {
+StmtResult Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc,
+                                       SourceLocation StarLoc,
+                                       SourceLocation EndLoc, Expr *E) {
   // Convert operand to void*
   if (!E->isTypeDependent()) {
     QualType ETy = E->getType();
     QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
     ExprResult ExprRes = E;
     AssignConvertType ConvTy =
       CheckSingleAssignmentConstraints(DestTy, ExprRes);
     if (ExprRes.isInvalid())

 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);
   }
 }
 
-StmtResult
-Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
+StmtResult Sema::ActOnContinueStmt(SourceLocation ContinueLoc,
+                                   SourceLocation EndLoc, 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);
 
-  return new (Context) ContinueStmt(ContinueLoc);
+  return new (Context) ContinueStmt(ContinueLoc, EndLoc);
 }
 
-StmtResult
-Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
+StmtResult Sema::ActOnBreakStmt(SourceLocation BreakLoc, SourceLocation EndLoc,
+                                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);
 
-  return new (Context) BreakStmt(BreakLoc);
+  return new (Context) BreakStmt(BreakLoc, EndLoc);
 }
 
 /// 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
 /// a return statement, this is the return type of the function. If we're
 /// determining the copy elision candidate for a throw expression, this will
static bool hasDeducedReturnType(FunctionDecl *FD) {
   const FunctionProtoType *FPT =
       FD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
   return FPT->getReturnType()->isUndeducedType();
 }
 
 /// ActOnCapScopeReturnStmt - Utility routine to type-check return statements
 /// for capturing scopes.
 ///
-StmtResult
-Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
+StmtResult Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc,
+                                         SourceLocation EndLoc,
+                                         Expr *RetValExp) {
   // If this is the first return we've seen, infer the return type.
   // [expr.prim.lambda]p4 in C++11; block literals follow the same rules.
   CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
   QualType FnRetType = CurCap->ReturnType;
   LambdaScopeInfo *CurLambda = dyn_cast<LambdaScopeInfo>(CurCap);
   bool HasDeducedReturnType =
       CurLambda && hasDeducedReturnType(CurLambda->CallOperator);
 
   if (ExprEvalContexts.back().Context ==
           ExpressionEvaluationContext::DiscardedStatement &&
       (HasDeducedReturnType || CurCap->HasImplicitReturnType)) {
     if (RetValExp) {
       ExprResult ER =
           ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
       if (ER.isInvalid())
         return StmtError();
       RetValExp = ER.get();
     }
-    return ReturnStmt::Create(Context, ReturnLoc, RetValExp,
+    return ReturnStmt::Create(Context, ReturnLoc, EndLoc, RetValExp,
                               /* NRVOCandidate=*/nullptr);
   }
 
   if (HasDeducedReturnType) {
     // In C++1y, the return type may involve 'auto'.
     // FIXME: Blocks might have a return type of 'auto' explicitly specified.
     FunctionDecl *FD = CurLambda->CallOperator;
     if (CurCap->ReturnType.isNull())
StmtResult Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc,
   if (RetValExp) {
     ExprResult ER =
         ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
     if (ER.isInvalid())
       return StmtError();
     RetValExp = ER.get();
   }
   auto *Result =
-      ReturnStmt::Create(Context, ReturnLoc, RetValExp, NRVOCandidate);
+      ReturnStmt::Create(Context, ReturnLoc, EndLoc, RetValExp, NRVOCandidate);
 
   // If we need to check for the named return value optimization,
   // or if we need to infer the return type,
   // save the return statement in our scope for later processing.
   if (CurCap->HasImplicitReturnType || NRVOCandidate)
     FunctionScopes.back()->Returns.push_back(Result);
 
   if (FunctionScopes.back()->FirstReturnLoc.isInvalid())
bool Sema::DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
   } else if (!FD->isInvalidDecl()) {
     // Update all declarations of the function to have the deduced return type.
     Context.adjustDeducedFunctionResultType(FD, Deduced);
   }
 
   return false;
 }
 
-StmtResult
-Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
-                      Scope *CurScope) {
+StmtResult Sema::ActOnReturnStmt(const SourceLocation ReturnLoc,
+                                 const SourceLocation EndLoc,
+                                 Expr *const RetValExp, Scope *const CurScope) {
   // Correct typos, in case the containing function returns 'auto' and
   // RetValExp should determine the deduced type.
   ExprResult RetVal = CorrectDelayedTyposInExpr(RetValExp);
   if (RetVal.isInvalid())
     return StmtError();
-  StmtResult R = BuildReturnStmt(ReturnLoc, RetVal.get());
+  StmtResult R = BuildReturnStmt(ReturnLoc, EndLoc, RetVal.get());
   if (R.isInvalid() || ExprEvalContexts.back().Context ==
                            ExpressionEvaluationContext::DiscardedStatement)
     return R;
 
   if (VarDecl *VD =
       const_cast<VarDecl*>(cast<ReturnStmt>(R.get())->getNRVOCandidate())) {
     CurScope->addNRVOCandidate(VD);
   } else {
     CurScope->setNoNRVO();
   }
 
   CheckJumpOutOfSEHFinally(*this, ReturnLoc, *CurScope->getFnParent());
 
   return R;
 }
 
-StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
+StmtResult Sema::BuildReturnStmt(const SourceLocation ReturnLoc,
+                                 const SourceLocation EndLoc, Expr *RetValExp) {
   // Check for unexpanded parameter packs.
   if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
     return StmtError();
 
   if (isa<CapturingScopeInfo>(getCurFunction()))
-    return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp);
+    return ActOnCapScopeReturnStmt(ReturnLoc, EndLoc, RetValExp);
 
   QualType FnRetType;
   QualType RelatedRetType;
   const AttrVec *Attrs = nullptr;
   bool isObjCMethod = false;
 
   if (const FunctionDecl *FD = getCurFunctionDecl()) {
     FnRetType = FD->getReturnType();
if (ExprEvalContexts.back().Context ==
       FnRetType->getContainedAutoType()) {
     if (RetValExp) {
       ExprResult ER =
           ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
       if (ER.isInvalid())
         return StmtError();
       RetValExp = ER.get();
     }
-    return ReturnStmt::Create(Context, ReturnLoc, RetValExp,
+    return ReturnStmt::Create(Context, ReturnLoc, EndLoc, RetValExp,
                               /* NRVOCandidate=*/nullptr);
   }
 
   // FIXME: Add a flag to the ScopeInfo to indicate whether we're performing
   // deduction.
   if (getLangOpts().CPlusPlus14) {
     if (AutoType *AT = FnRetType->getContainedAutoType()) {
       FunctionDecl *FD = cast<FunctionDecl>(CurContext);
if (RetValExp) {
         ExprResult ER =
             ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
         if (ER.isInvalid())
           return StmtError();
         RetValExp = ER.get();
       }
     }
 
-    Result = ReturnStmt::Create(Context, ReturnLoc, RetValExp,
+    Result = ReturnStmt::Create(Context, ReturnLoc, EndLoc, RetValExp,
                                 /* NRVOCandidate=*/nullptr);
   } else if (!RetValExp && !HasDependentReturnType) {
     FunctionDecl *FD = getCurFunctionDecl();
 
     unsigned DiagID;
     if (getLangOpts().CPlusPlus11 && FD && FD->isConstexpr()) {
       // C++11 [stmt.return]p2
       DiagID = diag::err_constexpr_return_missing_expr;
       FD->setInvalidDecl();
     } else if (getLangOpts().C99) {
       // C99 6.8.6.4p1 (ext_ since GCC warns)
       DiagID = diag::ext_return_missing_expr;
     } else {
       // C90 6.6.6.4p4
       DiagID = diag::warn_return_missing_expr;
     }
 
     if (FD)
       Diag(ReturnLoc, DiagID)
           << FD->getIdentifier() << 0 /*fn*/ << FD->isConsteval();
     else
       Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
 
-    Result = ReturnStmt::Create(Context, ReturnLoc, /* RetExpr=*/nullptr,
-                                /* NRVOCandidate=*/nullptr);
+    Result =
+        ReturnStmt::Create(Context, ReturnLoc, EndLoc, /* RetExpr=*/nullptr,
   } else {
     assert(RetValExp || HasDependentReturnType);
     const VarDecl *NRVOCandidate = nullptr;
 
     QualType RetType = RelatedRetType.isNull() ? FnRetType : RelatedRetType;
 
     // C99 6.8.6.4p3(136): The return statement is not an assignment. The
     // overlap restriction of subclause 6.5.16.1 does not apply to the case of
if (FnRetType->isVoidType()) {
 
     if (RetValExp) {
       ExprResult ER =
           ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
       if (ER.isInvalid())
         return StmtError();
       RetValExp = ER.get();
     }
-    Result = ReturnStmt::Create(Context, ReturnLoc, RetValExp, NRVOCandidate);
+    Result = ReturnStmt::Create(Context, ReturnLoc, EndLoc, RetValExp,
+                                NRVOCandidate);
   }
 
   // If we need to check for the named return value optimization, save the
   // return statement in our scope for later processing.
   if (Result->getNRVOCandidate())
     FunctionScopes.back()->Returns.push_back(Result);
 
   if (FunctionScopes.back()->FirstReturnLoc.isInvalid())

 }
 
 StmtResult Sema::ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block) {
   assert(Block);
   CurrentSEHFinally.pop_back();
   return SEHFinallyStmt::Create(Context, Loc, Block);
 }
 
-StmtResult
-Sema::ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope) {
+StmtResult Sema::ActOnSEHLeaveStmt(SourceLocation Loc, SourceLocation EndLoc,
+                                   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);
 
-  return new (Context) SEHLeaveStmt(Loc);
+  return new (Context) SEHLeaveStmt(Loc, EndLoc);
 }
 
 StmtResult Sema::BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
                                             bool IsIfExists,
                                             NestedNameSpecifierLoc QualifierLoc,
                                             DeclarationNameInfo NameInfo,
                                             Stmt *Nested)
 {

clang/lib/Sema/TreeTransform.h

#include "clang/Basic/OpenMPKinds.def"
   }
 
   /// Build a new do-while statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
                            SourceLocation WhileLoc, SourceLocation LParenLoc,
-                           Expr *Cond, SourceLocation RParenLoc) {
-    return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
-                                 Cond, RParenLoc);
+                           Expr *Cond, SourceLocation RParenLoc,
+                           SourceLocation EndLoc) {
+    return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc, Cond,
+                                 RParenLoc, EndLoc);
   }
 
   /// Build a new for statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
                             Stmt *Init, Sema::ConditionResult Cond,
                             Sema::FullExprArg Inc, SourceLocation RParenLoc,
                             Stmt *Body) {
     return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
                                   Inc, RParenLoc, Body);
   }
 
   /// Build a new goto statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
-                             LabelDecl *Label) {
-    return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
+                             SourceLocation EndLoc, LabelDecl *Label) {
+    return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, EndLoc, Label);
   }
 
   /// Build a new indirect goto statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
                                      SourceLocation StarLoc,
-                                     Expr *Target) {
-    return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
+                                     SourceLocation EndLoc, Expr *Target) {
+    return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, EndLoc, Target);
   }
 
   /// Build a new return statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
-  StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
-    return getSema().BuildReturnStmt(ReturnLoc, Result);
+  StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, SourceLocation EndLoc,
+                               Expr *Result) {
+    return getSema().BuildReturnStmt(ReturnLoc, EndLoc, Result);
   }
 
   /// Build a new declaration statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
                              SourceLocation StartLoc, SourceLocation EndLoc) {
if (Cond.isInvalid())
     return StmtError();
 
   if (!getDerived().AlwaysRebuild() &&
       Cond.get() == S->getCond() &&
       Body.get() == S->getBody())
     return S;
 
   return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
-                                    /*FIXME:*/S->getWhileLoc(), Cond.get(),
-                                    S->getRParenLoc());
+                                    /*FIXME:*/ S->getWhileLoc(), Cond.get(),
+                                    S->getRParenLoc(), S->getEndLoc());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
   if (getSema().getLangOpts().OpenMP)
     getSema().startOpenMPLoop();
 

 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
   Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
                                         S->getLabel());
   if (!LD)
     return StmtError();
 
   // Goto statements must always be rebuilt, to resolve the label.
   return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
-                                      cast<LabelDecl>(LD));
+                                      S->getEndLoc(), cast<LabelDecl>(LD));
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
   ExprResult Target = getDerived().TransformExpr(S->getTarget());
   if (Target.isInvalid())
     return StmtError();
   Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
 
   if (!getDerived().AlwaysRebuild() &&
       Target.get() == S->getTarget())
     return S;
 
   return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
-                                              Target.get());
+                                              S->getEndLoc(), Target.get());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
   return S;
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
   return S;
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
   ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
                                                         /*NotCopyInit*/false);
   if (Result.isInvalid())
     return StmtError();
 
   // FIXME: We always rebuild the return statement because there is no way
   // to tell whether the return type of the function has changed.
-  return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
+  return getDerived().RebuildReturnStmt(S->getReturnLoc(), S->getEndLoc(),
+                                        Result.get());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
   bool DeclChanged = false;
   SmallVector<Decl *, 4> Decls;
   for (auto *D : S->decls()) {