Store paren locations in IfStmt, WhileStmt, SwitchStmt.

[alexfh]

Summary

Storing the locations of parentheses in the if/while/switch statements
makes it much more straightforward for the tools (e.g. clang-tidy checks) to
operate on these locations. On the other hand, this increases memory usage
somewhat. I'm not sure what the right tradeoff here is, but my gut feeling is
that memory becomes cheaper, while developers' time doesn't.

[alexfh]

Ping.

[doug.gregor]

In non-macro cases, one can extract the locations of the parentheses using the lexer. Personally, I don't think the benefits of being able to extract the locations of the parentheses efficiently or in the macro cases outweigh the disadvantages of bloating the AST further.

[alexfh]

In D5528#5, @doug.gregor wrote:

In non-macro cases, one can extract the locations of the parentheses using the lexer. Personally, I don't think the benefits of being able to extract the locations of the parentheses efficiently or in the macro cases outweigh the disadvantages of bloating the AST further.

For the context: this patch resulted from the discussion on D5395.

I understand your concerns about bloating the AST. Some locations can be relatively easy found by re-lexing small parts of the input. One problem with this approach is that everyone who needs these locations spends time looking for a way to get them and then writing their own implementation. Is there a document or a comment describing the high-level approach to what is considered worthy storing in the AST?

Also, it may be reasonable to add utility methods in the AST classes (or free-standing functions in clang/AST headers) for retrieving some less frequently used locations of syntactic constructs in non-macro cases (e.g. WhileStmt::findRParenLoc() which would find the first non-comment token after getCond()->getLocEnd()). What do you think?

And while you're here, one more question related to D5395:
what is the reason why the statements ending with a semicolon do not include the semicolon in their source range (with exception of the NullStmt)? Is it feasible to extend the source range to include it? (and what would you expect to break in this case?)

include/clang/AST/Stmt.h

 
 /// IfStmt - This represents an if/then/else.
 ///
 class IfStmt : public Stmt {
   enum { VAR, COND, THEN, ELSE, END_EXPR };
   Stmt* SubExprs[END_EXPR];
 
   SourceLocation IfLoc;
+  SourceLocation LParenLoc, RParenLoc;
   SourceLocation ElseLoc;
 
 public:
   IfStmt(const ASTContext &C, SourceLocation IL, VarDecl *var, Expr *cond,
-         Stmt *then, SourceLocation EL = SourceLocation(),
-         Stmt *elsev = nullptr);
+         SourceLocation LP, SourceLocation RP, Stmt *then,
+         SourceLocation EL = SourceLocation(), Stmt *elsev = nullptr);
 
   /// \brief Build an empty if/then/else statement
   explicit IfStmt(EmptyShell Empty) : Stmt(IfStmtClass, Empty) { }
 
   /// \brief Retrieve the variable declared in this "if" statement, if any.
   ///
   /// In the following example, "x" is the condition variable.
   /// \code
public:
   Expr *getCond() { return reinterpret_cast<Expr*>(SubExprs[COND]); }
   Stmt *getThen() { return SubExprs[THEN]; }
   Stmt *getElse() { return SubExprs[ELSE]; }
 
   SourceLocation getIfLoc() const { return IfLoc; }
   void setIfLoc(SourceLocation L) { IfLoc = L; }
   SourceLocation getElseLoc() const { return ElseLoc; }
   void setElseLoc(SourceLocation L) { ElseLoc = L; }
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+  void setLParenLoc(SourceLocation L) { LParenLoc = L; }
+  SourceLocation getRParenLoc() const { return RParenLoc; }
+  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getLocStart() const LLVM_READONLY { return IfLoc; }
   SourceLocation getLocEnd() const LLVM_READONLY {
     if (SubExprs[ELSE])
       return SubExprs[ELSE]->getLocEnd();
     else
       return SubExprs[THEN]->getLocEnd();
   }

 /// SwitchStmt - This represents a 'switch' stmt.
 ///
 class SwitchStmt : public Stmt {
   enum { VAR, COND, BODY, END_EXPR };
   Stmt* SubExprs[END_EXPR];
   // This points to a linked list of case and default statements.
   SwitchCase *FirstCase;
   SourceLocation SwitchLoc;
+  SourceLocation LParenLoc, RParenLoc;
 
   /// If the SwitchStmt is a switch on an enum value, this records whether
   /// all the enum values were covered by CaseStmts.  This value is meant to
   /// be a hint for possible clients.
   unsigned AllEnumCasesCovered : 1;
 
 public:
-  SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond);
+  SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond, SourceLocation LP,
+             SourceLocation RP);
 
   /// \brief Build a empty switch statement.
   explicit SwitchStmt(EmptyShell Empty) : Stmt(SwitchStmtClass, Empty) { }
 
   /// \brief Retrieve the variable declared in this "switch" statement, if any.
   ///
   /// In the following example, "x" is the condition variable.
   /// \code
public:
   void setBody(Stmt *S) { SubExprs[BODY] = S; }
   SwitchCase *getSwitchCaseList() { return FirstCase; }
 
   /// \brief Set the case list for this switch statement.
   void setSwitchCaseList(SwitchCase *SC) { FirstCase = SC; }
 
   SourceLocation getSwitchLoc() const { return SwitchLoc; }
   void setSwitchLoc(SourceLocation L) { SwitchLoc = L; }
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+  void setLParenLoc(SourceLocation L) { LParenLoc = L; }
+  SourceLocation getRParenLoc() const { return RParenLoc; }
+  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   void setBody(Stmt *S, SourceLocation SL) {
     SubExprs[BODY] = S;
     SwitchLoc = SL;
   }
   void addSwitchCase(SwitchCase *SC) {
     assert(!SC->getNextSwitchCase()
            && "case/default already added to a switch");

 
 
 /// WhileStmt - This represents a 'while' stmt.
 ///
 class WhileStmt : public Stmt {
   enum { VAR, COND, BODY, END_EXPR };
   Stmt* SubExprs[END_EXPR];
   SourceLocation WhileLoc;
+  SourceLocation LParenLoc, RParenLoc;
 public:
   WhileStmt(const ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body,
-            SourceLocation WL);
+            SourceLocation WL, SourceLocation LP, SourceLocation RP);
 
   /// \brief Build an empty while statement.
   explicit WhileStmt(EmptyShell Empty) : Stmt(WhileStmtClass, Empty) { }
 
   /// \brief Retrieve the variable declared in this "while" statement, if any.
   ///
   /// In the following example, "x" is the condition variable.
   /// \code
public:
   const Expr *getCond() const { return reinterpret_cast<Expr*>(SubExprs[COND]);}
   void setCond(Expr *E) { SubExprs[COND] = reinterpret_cast<Stmt*>(E); }
   Stmt *getBody() { return SubExprs[BODY]; }
   const Stmt *getBody() const { return SubExprs[BODY]; }
   void setBody(Stmt *S) { SubExprs[BODY] = S; }
 
   SourceLocation getWhileLoc() const { return WhileLoc; }
   void setWhileLoc(SourceLocation L) { WhileLoc = L; }
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+  void setLParenLoc(SourceLocation L) { LParenLoc = L; }
+  SourceLocation getRParenLoc() const { return RParenLoc; }
+  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
 
   SourceLocation getLocStart() const LLVM_READONLY { return WhileLoc; }
   SourceLocation getLocEnd() const LLVM_READONLY {
     return SubExprs[BODY]->getLocEnd();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == WhileStmtClass;

include/clang/Parse/Parser.h

private:
   StmtResult ParseCaseStatement(bool MissingCase = false,
                                 ExprResult Expr = ExprResult());
   StmtResult ParseDefaultStatement();
   StmtResult ParseCompoundStatement(bool isStmtExpr = false);
   StmtResult ParseCompoundStatement(bool isStmtExpr,
                                     unsigned ScopeFlags);
   void ParseCompoundStatementLeadingPragmas();
   StmtResult ParseCompoundStatementBody(bool isStmtExpr = false);
-  bool ParseParenExprOrCondition(ExprResult &ExprResult,
-                                 Decl *&DeclResult,
-                                 SourceLocation Loc,
-                                 bool ConvertToBoolean);
+  bool ParseParenExprOrCondition(BalancedDelimiterTracker &Tracker,
+                                 ExprResult &ExprResult, Decl *&DeclResult,
+                                 SourceLocation Loc, bool ConvertToBoolean);
   StmtResult ParseIfStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseSwitchStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseWhileStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseDoStatement();
   StmtResult ParseForStatement(SourceLocation *TrailingElseLoc);
   StmtResult ParseGotoStatement();
   StmtResult ParseContinueStatement();
   StmtResult ParseBreakStatement();

include/clang/Sema/Sema.h

StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
                                       Stmt *SubStmt, Scope *CurScope);
   StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
                             SourceLocation ColonLoc, Stmt *SubStmt);
 
   StmtResult ActOnAttributedStmt(SourceLocation AttrLoc,
                                  ArrayRef<const Attr*> Attrs,
                                  Stmt *SubStmt);
 
-  StmtResult ActOnIfStmt(SourceLocation IfLoc,
+  StmtResult ActOnIfStmt(SourceLocation IfLoc, SourceLocation CondLParen,
                          FullExprArg CondVal, Decl *CondVar,
-                         Stmt *ThenVal,
+                         SourceLocation CondRParen, Stmt *ThenVal,
                          SourceLocation ElseLoc, Stmt *ElseVal);
   StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
-                                            Expr *Cond,
-                                            Decl *CondVar);
+                                    SourceLocation CondLParen, Expr *Cond,
+                                    Decl *CondVar, SourceLocation CondRParen);
   StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
                                            Stmt *Switch, Stmt *Body);
-  StmtResult ActOnWhileStmt(SourceLocation WhileLoc,
-                            FullExprArg Cond,
-                            Decl *CondVar, Stmt *Body);
+  StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation CondLParen,
+                            FullExprArg Cond, Decl *CondVar,
+                            SourceLocation CondRParen, Stmt *Body);
   StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
                                  SourceLocation WhileLoc,
                                  SourceLocation CondLParen, Expr *Cond,
                                  SourceLocation CondRParen);
 
   StmtResult ActOnForStmt(SourceLocation ForLoc,
                           SourceLocation LParenLoc,
                           Stmt *First, FullExprArg Second,

lib/AST/Stmt.cpp

VarDecl *CXXForRangeStmt::getLoopVariable() {
   return cast<VarDecl>(LV);
 }
 
 const VarDecl *CXXForRangeStmt::getLoopVariable() const {
   return const_cast<CXXForRangeStmt*>(this)->getLoopVariable();
 }
 
 IfStmt::IfStmt(const ASTContext &C, SourceLocation IL, VarDecl *var, Expr *cond,
-               Stmt *then, SourceLocation EL, Stmt *elsev)
-  : Stmt(IfStmtClass), IfLoc(IL), ElseLoc(EL)
-{
+               SourceLocation LP, SourceLocation RP, Stmt *then,
+               SourceLocation EL, Stmt *elsev)
+    : Stmt(IfStmtClass), IfLoc(IL), LParenLoc(LP), RParenLoc(RP), ElseLoc(EL) {
   setConditionVariable(C, var);
   SubExprs[COND] = cond;
   SubExprs[THEN] = then;
   SubExprs[ELSE] = elsev;
 }
 
 VarDecl *IfStmt::getConditionVariable() const {
   if (!SubExprs[VAR])
if (!V) {
     return;
   }
 
   SourceRange VarRange = V->getSourceRange();
   SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
                                        VarRange.getEnd());
 }
 
-SwitchStmt::SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond)
-  : Stmt(SwitchStmtClass), FirstCase(nullptr), AllEnumCasesCovered(0)
-{
+SwitchStmt::SwitchStmt(const ASTContext &C, VarDecl *Var, Expr *cond,
+                       SourceLocation LP, SourceLocation RP)
+    : Stmt(SwitchStmtClass), FirstCase(nullptr), LParenLoc(LP), RParenLoc(RP),
+      AllEnumCasesCovered(0) {
   setConditionVariable(C, Var);
   SubExprs[COND] = cond;
   SubExprs[BODY] = nullptr;
 }
 
 VarDecl *SwitchStmt::getConditionVariable() const {
   if (!SubExprs[VAR])
     return nullptr;

 
 Stmt *SwitchCase::getSubStmt() {
   if (isa<CaseStmt>(this))
     return cast<CaseStmt>(this)->getSubStmt();
   return cast<DefaultStmt>(this)->getSubStmt();
 }
 
 WhileStmt::WhileStmt(const ASTContext &C, VarDecl *Var, Expr *cond, Stmt *body,
-                     SourceLocation WL)
-  : Stmt(WhileStmtClass) {
+                     SourceLocation WL, SourceLocation LP, SourceLocation RP)
+  : Stmt(WhileStmtClass), WhileLoc(WL), LParenLoc(LP), RParenLoc(RP) {
   setConditionVariable(C, Var);
   SubExprs[COND] = cond;
   SubExprs[BODY] = body;
-  WhileLoc = WL;
 }
 
 VarDecl *WhileStmt::getConditionVariable() const {
   if (!SubExprs[VAR])
     return nullptr;
 
   DeclStmt *DS = cast<DeclStmt>(SubExprs[VAR]);
   return cast<VarDecl>(DS->getSingleDecl());

lib/Analysis/BodyFarm.cpp

M.makeLvalueToRvalue(
         PredicateTy),
     PredicateTy);
   
   UnaryOperator *UO = new (C) UnaryOperator(LValToRval, UO_LNot, C.IntTy,
                                            VK_RValue, OK_Ordinary,
                                            SourceLocation());
   
   // (5) Create the 'if' statement.
-  IfStmt *If = new (C) IfStmt(C, SourceLocation(), nullptr, UO, CS);
+  IfStmt *If = new (C) IfStmt(C, SourceLocation(), nullptr, UO,
+                              SourceLocation(), SourceLocation(), CS);
   return If;
 }
 
 /// Create a fake body for dispatch_sync.
 static Stmt *create_dispatch_sync(ASTContext &C, const FunctionDecl *D) {
   // Check if we have at least two parameters.
   if (D->param_size() != 2)
     return nullptr;
static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D)
   // Construct the else clause.
   BoolVal = M.makeObjCBool(false);
   RetVal = isBoolean ? M.makeIntegralCastToBoolean(BoolVal)
                      : M.makeIntegralCast(BoolVal, ResultTy);
   Stmt *Else = M.makeReturn(RetVal);
   
   /// Construct the If.
   Stmt *If =
-    new (C) IfStmt(C, SourceLocation(), nullptr, Comparison, Body,
-                   SourceLocation(), Else);
+      new (C) IfStmt(C, SourceLocation(), nullptr, Comparison, SourceLocation(),
+                     SourceLocation(), Body, SourceLocation(), Else);
 
   return If;  
 }
 
 Stmt *BodyFarm::getBody(const FunctionDecl *D) {
   D = D->getCanonicalDecl();
   
   Optional<Stmt *> &Val = Bodies[D];

lib/Parse/ParseStmt.cpp

 ///
 /// This function parses and performs error recovery on the specified condition
 /// or expression (depending on whether we're in C++ or C mode).  This function
 /// goes out of its way to recover well.  It returns true if there was a parser
 /// error (the right paren couldn't be found), which indicates that the caller
 /// should try to recover harder.  It returns false if the condition is
 /// successfully parsed.  Note that a successful parse can still have semantic
 /// errors in the condition.
-bool Parser::ParseParenExprOrCondition(ExprResult &ExprResult,
-                                       Decl *&DeclResult,
-                                       SourceLocation Loc,
+bool Parser::ParseParenExprOrCondition(BalancedDelimiterTracker &Tracker,
+                                       ExprResult &ExprResult,
+                                       Decl *&DeclResult, SourceLocation Loc,
                                        bool ConvertToBoolean) {
-  BalancedDelimiterTracker T(*this, tok::l_paren);
-  T.consumeOpen();
+  Tracker.consumeOpen();
 
   if (getLangOpts().CPlusPlus)
     ParseCXXCondition(ExprResult, DeclResult, Loc, ConvertToBoolean);
   else {
     ExprResult = ParseExpression();
     DeclResult = nullptr;
 
     // If required, convert to a boolean value.
if (ExprResult.isInvalid() && !DeclResult && Tok.isNot(tok::r_paren)) {
     SkipUntil(tok::semi);
     // Skipping may have stopped if it found the containing ')'.  If so, we can
     // continue parsing the if statement.
     if (Tok.isNot(tok::r_paren))
       return true;
   }
 
   // Otherwise the condition is valid or the rparen is present.
-  T.consumeClose();
+  Tracker.consumeClose();
 
   // Check for extraneous ')'s to catch things like "if (foo())) {".  We know
   // that all callers are looking for a statement after the condition, so ")"
   // isn't valid.
   while (Tok.is(tok::r_paren)) {
     Diag(Tok, diag::err_extraneous_rparen_in_condition)
       << FixItHint::CreateRemoval(Tok.getLocation());
     ConsumeParen();
StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
   // while, for, and switch statements are local to the if, while, for, or
   // switch statement (including the controlled statement).
   //
   ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX);
 
   // Parse the condition.
   ExprResult CondExp;
   Decl *CondVar = nullptr;
-  if (ParseParenExprOrCondition(CondExp, CondVar, IfLoc, true))
+  BalancedDelimiterTracker T(*this, tok::l_paren);
+  if (ParseParenExprOrCondition(T, CondExp, CondVar, IfLoc, true))
     return StmtError();
 
   FullExprArg FullCondExp(Actions.MakeFullExpr(CondExp.get(), IfLoc));
 
   // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
   // there is no compound stmt.  C90 does not have this clause.  We only do this
   // if the body isn't a compound statement to avoid push/pop in common cases.
   //
StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
   }
 
   // Now if either are invalid, replace with a ';'.
   if (ThenStmt.isInvalid())
     ThenStmt = Actions.ActOnNullStmt(ThenStmtLoc);
   if (ElseStmt.isInvalid())
     ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc);
 
-  return Actions.ActOnIfStmt(IfLoc, FullCondExp, CondVar, ThenStmt.get(),
-                             ElseLoc, ElseStmt.get());
+  return Actions.ActOnIfStmt(IfLoc, T.getOpenLocation(), FullCondExp, CondVar,
+                             T.getCloseLocation(), ThenStmt.get(), ElseLoc,
+                             ElseStmt.get());
 }
 
 /// ParseSwitchStatement
 ///       switch-statement:
 ///         'switch' '(' expression ')' statement
 /// [C++]   'switch' '(' condition ')' statement
 StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) {
   assert(Tok.is(tok::kw_switch) && "Not a switch stmt!");
StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) {
   unsigned ScopeFlags = Scope::SwitchScope;
   if (C99orCXX)
     ScopeFlags |= Scope::DeclScope | Scope::ControlScope;
   ParseScope SwitchScope(this, ScopeFlags);
 
   // Parse the condition.
   ExprResult Cond;
   Decl *CondVar = nullptr;
-  if (ParseParenExprOrCondition(Cond, CondVar, SwitchLoc, false))
+  BalancedDelimiterTracker T(*this, tok::l_paren);
+  if (ParseParenExprOrCondition(T, Cond, CondVar, SwitchLoc, false))
     return StmtError();
 
-  StmtResult Switch
-    = Actions.ActOnStartOfSwitchStmt(SwitchLoc, Cond.get(), CondVar);
+  StmtResult Switch =
+      Actions.ActOnStartOfSwitchStmt(SwitchLoc, T.getOpenLocation(), Cond.get(),
+                                     CondVar, T.getCloseLocation());
 
   if (Switch.isInvalid()) {
     // Skip the switch body.
     // FIXME: This is not optimal recovery, but parsing the body is more
     // dangerous due to the presence of case and default statements, which
     // will have no place to connect back with the switch.
     if (Tok.is(tok::l_brace)) {
       ConsumeBrace();
ScopeFlags = Scope::BreakScope | Scope::ContinueScope |
                  Scope::DeclScope  | Scope::ControlScope;
   else
     ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
   ParseScope WhileScope(this, ScopeFlags);
 
   // Parse the condition.
   ExprResult Cond;
   Decl *CondVar = nullptr;
-  if (ParseParenExprOrCondition(Cond, CondVar, WhileLoc, true))
+  BalancedDelimiterTracker T(*this, tok::l_paren);
+  if (ParseParenExprOrCondition(T, Cond, CondVar, WhileLoc, true))
     return StmtError();
 
   FullExprArg FullCond(Actions.MakeFullExpr(Cond.get(), WhileLoc));
 
   // C99 6.8.5p5 - In C99, the body of the while statement is a scope, even if
   // there is no compound stmt.  C90 does not have this clause.  We only do this
   // if the body isn't a compound statement to avoid push/pop in common cases.
   //
StmtResult Parser::ParseWhileStatement(SourceLocation *TrailingElseLoc) {
 
   // Pop the body scope if needed.
   InnerScope.Exit();
   WhileScope.Exit();
 
   if ((Cond.isInvalid() && !CondVar) || Body.isInvalid())
     return StmtError();
 
-  return Actions.ActOnWhileStmt(WhileLoc, FullCond, CondVar, Body.get());
+  return Actions.ActOnWhileStmt(WhileLoc, T.getOpenLocation(), FullCond,
+                                CondVar, T.getCloseLocation(), 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!");

lib/Sema/SemaStmt.cpp

 StmtResult Sema::ActOnAttributedStmt(SourceLocation AttrLoc,
                                      ArrayRef<const Attr*> Attrs,
                                      Stmt *SubStmt) {
   // Fill in the declaration and return it.
   AttributedStmt *LS = AttributedStmt::Create(Context, AttrLoc, Attrs, SubStmt);
   return LS;
 }
 
-StmtResult
-Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
-                  Stmt *thenStmt, SourceLocation ElseLoc,
-                  Stmt *elseStmt) {
+StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, SourceLocation CondLParen,
+                             FullExprArg CondVal, Decl *CondVar,
+                             SourceLocation CondRParen, Stmt *thenStmt,
+                             SourceLocation ElseLoc, Stmt *elseStmt) {
   // If the condition was invalid, discard the if statement.  We could recover
   // better by replacing it with a valid expr, but don't do that yet.
   if (!CondVal.get() && !CondVar) {
     getCurFunction()->setHasDroppedStmt();
     return StmtError();
   }
 
   ExprResult CondResult(CondVal.release());
StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, SourceLocation CondLParen,
 
   if (!elseStmt) {
     DiagnoseEmptyStmtBody(ConditionExpr->getLocEnd(), thenStmt,
                           diag::warn_empty_if_body);
   }
 
   DiagnoseUnusedExprResult(elseStmt);
 
-  return new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
-                              thenStmt, ElseLoc, elseStmt);
+  return new (Context)
+      IfStmt(Context, IfLoc, ConditionVar, ConditionExpr, CondLParen,
+             CondRParen, thenStmt, ElseLoc, elseStmt);
 }
 
 namespace {
   struct CaseCompareFunctor {
     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
                     const llvm::APSInt &RHS) {
       return LHS.first < RHS;
     }
if (ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(expr))
     expr = cleanups->getSubExpr();
   while (ImplicitCastExpr *impcast = dyn_cast<ImplicitCastExpr>(expr)) {
     if (impcast->getCastKind() != CK_IntegralCast) break;
     expr = impcast->getSubExpr();
   }
   return expr->getType();
 }
 
-StmtResult
-Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
-                             Decl *CondVar) {
+StmtResult Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
+                                        SourceLocation CondLParen, Expr *Cond,
+                                        Decl *CondVar,
+                                        SourceLocation CondRParen) {
   ExprResult CondResult;
 
   VarDecl *ConditionVar = nullptr;
   if (CondVar) {
     ConditionVar = cast<VarDecl>(CondVar);
     CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
     if (CondResult.isInvalid())
       return StmtError();
if (!CondVar) {
     CondResult = ActOnFinishFullExpr(Cond, SwitchLoc);
     if (CondResult.isInvalid())
       return StmtError();
     Cond = CondResult.get();
   }
 
   getCurFunction()->setHasBranchIntoScope();
 
-  SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
+  SwitchStmt *SS = new (Context)
+      SwitchStmt(Context, ConditionVar, Cond, CondLParen, CondRParen);
   getCurFunction()->SwitchStack.push_back(SS);
   return SS;
 }
 
 static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
   Val = Val.extOrTrunc(BitWidth);
   Val.setIsSigned(IsSigned);
 }
if (!Context.hasSameUnqualifiedType(SrcType, DstType) &&
         if (EI == EIend || EI->first != RhsVal) {
           Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignment)
               << DstType.getUnqualifiedType();
         }
       }
     }
 }
 
-StmtResult
-Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
-                     Decl *CondVar, Stmt *Body) {
+StmtResult Sema::ActOnWhileStmt(SourceLocation WhileLoc,
+                                SourceLocation CondLParen, FullExprArg Cond,
+                                Decl *CondVar, SourceLocation CondRParen,
+                                Stmt *Body) {
   ExprResult CondResult(Cond.release());
 
   VarDecl *ConditionVar = nullptr;
   if (CondVar) {
     ConditionVar = cast<VarDecl>(CondVar);
     CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
     if (CondResult.isInvalid())
       return StmtError();
   }
   Expr *ConditionExpr = CondResult.get();
   if (!ConditionExpr)
     return StmtError();
   CheckBreakContinueBinding(ConditionExpr);
 
   DiagnoseUnusedExprResult(Body);
 
   if (isa<NullStmt>(Body))
     getCurCompoundScope().setHasEmptyLoopBodies();
 
-  return new (Context)
-      WhileStmt(Context, ConditionVar, ConditionExpr, Body, WhileLoc);
+  return new (Context) WhileStmt(Context, ConditionVar, ConditionExpr, Body,
+                                 WhileLoc, CondLParen, CondRParen);
 }
 
 StmtResult
 Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
                   SourceLocation WhileLoc, SourceLocation CondLParen,
                   Expr *Cond, SourceLocation CondRParen) {
   assert(Cond && "ActOnDoStmt(): missing expression");
 

lib/Sema/TreeTransform.h

StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
                                    Stmt *SubStmt) {
     return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
   }
 
   /// \brief Build a new "if" statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
-  StmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond,
-                           VarDecl *CondVar, Stmt *Then,
+  StmtResult RebuildIfStmt(SourceLocation IfLoc, SourceLocation LParenLoc,
+                           Sema::FullExprArg Cond, VarDecl *CondVar,
+                           SourceLocation RParenLoc, Stmt *Then,
                            SourceLocation ElseLoc, Stmt *Else) {
-    return getSema().ActOnIfStmt(IfLoc, Cond, CondVar, Then, ElseLoc, Else);
+    return getSema().ActOnIfStmt(IfLoc, LParenLoc, Cond, CondVar, RParenLoc,
+                                 Then, ElseLoc, Else);
   }
 
   /// \brief Start building a new switch statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
-                                    Expr *Cond, VarDecl *CondVar) {
-    return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Cond,
-                                            CondVar);
+                                    SourceLocation LParenLoc, Expr *Cond,
+                                    VarDecl *CondVar,
+                                    SourceLocation RParenLoc) {
+    return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Cond, CondVar,
+                                            RParenLoc);
   }
 
   /// \brief Attach the body to the switch statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
                                    Stmt *Switch, Stmt *Body) {
     return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
   }
 
   /// \brief Build a new while statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
-  StmtResult RebuildWhileStmt(SourceLocation WhileLoc, Sema::FullExprArg Cond,
-                              VarDecl *CondVar, Stmt *Body) {
-    return getSema().ActOnWhileStmt(WhileLoc, Cond, CondVar, Body);
+  StmtResult RebuildWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
+                              Sema::FullExprArg Cond, VarDecl *CondVar,
+                              SourceLocation RParenLoc, Stmt *Body) {
+    return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, CondVar,
+                                    RParenLoc, Body);
   }
 
   /// \brief 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,
TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
 
   if (!getDerived().AlwaysRebuild() &&
       FullCond.get() == S->getCond() &&
       ConditionVar == S->getConditionVariable() &&
       Then.get() == S->getThen() &&
       Else.get() == S->getElse())
     return S;
 
-  return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar,
-                                    Then.get(),
+  return getDerived().RebuildIfStmt(S->getIfLoc(), S->getLParenLoc(), FullCond,
+                                    ConditionVar, S->getRParenLoc(), Then.get(),
                                     S->getElseLoc(), Else.get());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
   // Transform the condition.
   ExprResult Cond;
TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
   } else {
     Cond = getDerived().TransformExpr(S->getCond());
 
     if (Cond.isInvalid())
       return StmtError();
   }
 
   // Rebuild the switch statement.
-  StmtResult Switch
-    = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(),
-                                          ConditionVar);
+  StmtResult Switch = getDerived().RebuildSwitchStmtStart(
+      S->getSwitchLoc(), S->getLParenLoc(), Cond.get(), ConditionVar,
+      S->getRParenLoc());
   if (Switch.isInvalid())
     return StmtError();
 
   // Transform the body of the switch statement.
   StmtResult Body = getDerived().TransformStmt(S->getBody());
   if (Body.isInvalid())
     return StmtError();
 
if (Body.isInvalid())
     return StmtError();
 
   if (!getDerived().AlwaysRebuild() &&
       FullCond.get() == S->getCond() &&
       ConditionVar == S->getConditionVariable() &&
       Body.get() == S->getBody())
     return Owned(S);
 
-  return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond,
-                                       ConditionVar, Body.get());
+  return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
+                                       FullCond, ConditionVar,
+                                       S->getRParenLoc(), Body.get());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
   // Transform the body
   StmtResult Body = getDerived().TransformStmt(S->getBody());
   if (Body.isInvalid())

lib/Serialization/ASTReaderStmt.cpp

 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
   S->setConditionVariable(Reader.getContext(),
                           ReadDeclAs<VarDecl>(Record, Idx));
   S->setCond(Reader.ReadSubExpr());
   S->setThen(Reader.ReadSubStmt());
   S->setElse(Reader.ReadSubStmt());
   S->setIfLoc(ReadSourceLocation(Record, Idx));
+  S->setLParenLoc(ReadSourceLocation(Record, Idx));
+  S->setRParenLoc(ReadSourceLocation(Record, Idx));
   S->setElseLoc(ReadSourceLocation(Record, Idx));
 }
 
 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
   VisitStmt(S);
   S->setConditionVariable(Reader.getContext(),
                           ReadDeclAs<VarDecl>(Record, Idx));
   S->setCond(Reader.ReadSubExpr());
   S->setBody(Reader.ReadSubStmt());
   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
+  S->setLParenLoc(ReadSourceLocation(Record, Idx));
+  S->setRParenLoc(ReadSourceLocation(Record, Idx));
   if (Record[Idx++])
     S->setAllEnumCasesCovered();
 
   SwitchCase *PrevSC = nullptr;
   for (unsigned N = Record.size(); Idx != N; ++Idx) {
     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
     if (PrevSC)
       PrevSC->setNextSwitchCase(SC);
     else
       S->setSwitchCaseList(SC);
 
     PrevSC = SC;
   }
 }
 
 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
   VisitStmt(S);
   S->setConditionVariable(Reader.getContext(),
                           ReadDeclAs<VarDecl>(Record, Idx));
 
   S->setCond(Reader.ReadSubExpr());
   S->setBody(Reader.ReadSubStmt());
   S->setWhileLoc(ReadSourceLocation(Record, Idx));
+  S->setLParenLoc(ReadSourceLocation(Record, Idx));
+  S->setRParenLoc(ReadSourceLocation(Record, Idx));
 }
 
 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
   VisitStmt(S);
   S->setCond(Reader.ReadSubExpr());
   S->setBody(Reader.ReadSubStmt());
   S->setDoLoc(ReadSourceLocation(Record, Idx));
   S->setWhileLoc(ReadSourceLocation(Record, Idx));

lib/Serialization/ASTWriterStmt.cpp

 
 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
   Writer.AddDeclRef(S->getConditionVariable(), Record);
   Writer.AddStmt(S->getCond());
   Writer.AddStmt(S->getThen());
   Writer.AddStmt(S->getElse());
   Writer.AddSourceLocation(S->getIfLoc(), Record);
+  Writer.AddSourceLocation(S->getLParenLoc(), Record);
+  Writer.AddSourceLocation(S->getRParenLoc(), Record);
   Writer.AddSourceLocation(S->getElseLoc(), Record);
   Code = serialization::STMT_IF;
 }
 
 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
   VisitStmt(S);
   Writer.AddDeclRef(S->getConditionVariable(), Record);
   Writer.AddStmt(S->getCond());
   Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getSwitchLoc(), Record);
+  Writer.AddSourceLocation(S->getLParenLoc(), Record);
+  Writer.AddSourceLocation(S->getRParenLoc(), Record);
   Record.push_back(S->isAllEnumCasesCovered());
   for (SwitchCase *SC = S->getSwitchCaseList(); SC;
        SC = SC->getNextSwitchCase())
     Record.push_back(Writer.RecordSwitchCaseID(SC));
   Code = serialization::STMT_SWITCH;
 }
 
 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
   VisitStmt(S);
   Writer.AddDeclRef(S->getConditionVariable(), Record);
   Writer.AddStmt(S->getCond());
   Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getWhileLoc(), Record);
+  Writer.AddSourceLocation(S->getLParenLoc(), Record);
+  Writer.AddSourceLocation(S->getRParenLoc(), Record);
   Code = serialization::STMT_WHILE;
 }
 
 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
   VisitStmt(S);
   Writer.AddStmt(S->getCond());
   Writer.AddStmt(S->getBody());
   Writer.AddSourceLocation(S->getDoLoc(), Record);