Merge pull request swiftlang#27955 from AnthonyLatsis/bracestmt_cleanup

CodaFi · web-flow · commit 8a69f886ad60 · 2019-10-31T13:48:40.000-07:00
NFC: Solidify and tidy up the BraceStmt interface
diff --git a/include/swift/AST/Stmt.h b/include/swift/AST/Stmt.h
@@ -173,10 +173,13 @@ class BraceStmt final : public Stmt,
   
   SourceRange getSourceRange() const { return SourceRange(LBLoc, RBLoc); }
 
+  bool empty() const { return getNumElements() == 0; }
   unsigned getNumElements() const { return Bits.BraceStmt.NumElements; }
 
-  ASTNode getElement(unsigned i) const { return getElements()[i]; }
-  void setElement(unsigned i, ASTNode node) { getElements()[i] = node; }
+  ASTNode getFirstElement() const { return getElements().front(); }
+  ASTNode getLastElement() const { return getElements().back(); }
+
+  void setFirstElement(ASTNode node) { getElements().front() = node; }
 
   /// The elements contained within the BraceStmt.
   MutableArrayRef<ASTNode> getElements() {
diff --git a/lib/AST/ASTScopeCreation.cpp b/lib/AST/ASTScopeCreation.cpp
@@ -640,8 +640,7 @@ class ScopeCreator final {
     // Can occur in illegal code
     if (auto *const s = n.dyn_cast<Stmt *>()) {
       if (auto *const bs = dyn_cast<BraceStmt>(s))
-        ASTScopeAssert(bs->getNumElements() == 0,
-                       "Might mess up insertion point");
+        ASTScopeAssert(bs->empty(), "Might mess up insertion point");
     }
     return !n.isDecl(DeclKind::Var);
   }
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -609,7 +609,7 @@ Expr *AbstractFunctionDecl::getSingleExpressionBody() const {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
   auto braceStmt = getBody();
   assert(braceStmt != nullptr && "No body currently available.");
-  auto body = getBody()->getElement(0);
+  auto body = getBody()->getFirstElement();
   if (auto *stmt = body.dyn_cast<Stmt *>()) {
     if (auto *returnStmt = dyn_cast<ReturnStmt>(stmt)) {
       return returnStmt->getResult();
@@ -626,7 +626,7 @@ Expr *AbstractFunctionDecl::getSingleExpressionBody() const {
 
 void AbstractFunctionDecl::setSingleExpressionBody(Expr *NewBody) {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
-  auto body = getBody()->getElement(0);
+  auto body = getBody()->getFirstElement();
   if (auto *stmt = body.dyn_cast<Stmt *>()) {
     if (auto *returnStmt = dyn_cast<ReturnStmt>(stmt)) {
       returnStmt->setResult(NewBody);
@@ -642,7 +642,7 @@ void AbstractFunctionDecl::setSingleExpressionBody(Expr *NewBody) {
       return;
     }
   }
-  getBody()->setElement(0, NewBody);
+  getBody()->setFirstElement(NewBody);
 }
 
 bool AbstractStorageDecl::isTransparent() const {
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -1854,24 +1854,24 @@ FORWARD_SOURCE_LOCS_TO(ClosureExpr, Body.getPointer())
 
 Expr *ClosureExpr::getSingleExpressionBody() const {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
-  auto body = getBody()->getElement(0);
+  auto body = getBody()->getFirstElement();
   if (body.is<Stmt *>())
     return cast<ReturnStmt>(body.get<Stmt *>())->getResult();
   return body.get<Expr *>();
 }
 
 void ClosureExpr::setSingleExpressionBody(Expr *NewBody) {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
-  auto body = getBody()->getElement(0);
+  auto body = getBody()->getFirstElement();
   if (body.is<Stmt *>()) {
     cast<ReturnStmt>(body.get<Stmt *>())->setResult(NewBody);
     return;
   }
-  getBody()->setElement(0, NewBody);
+  getBody()->setFirstElement(NewBody);
 }
 
 bool ClosureExpr::hasEmptyBody() const {
-  return getBody()->getNumElements() == 0;
+  return getBody()->empty();
 }
 
 FORWARD_SOURCE_LOCS_TO(AutoClosureExpr, Body)
@@ -1883,7 +1883,7 @@ void AutoClosureExpr::setBody(Expr *E) {
 }
 
 Expr *AutoClosureExpr::getSingleExpressionBody() const {
-  return cast<ReturnStmt>(Body->getElement(0).get<Stmt *>())->getResult();
+  return cast<ReturnStmt>(Body->getFirstElement().get<Stmt *>())->getResult();
 }
 
 FORWARD_SOURCE_LOCS_TO(UnresolvedPatternExpr, subPattern)
@@ -2222,14 +2222,14 @@ TapExpr::TapExpr(Expr * SubExpr, BraceStmt *Body)
     : Expr(ExprKind::Tap, /*Implicit=*/true),
       SubExpr(SubExpr), Body(Body) {
   if (Body) {
-    assert(Body->getNumElements() > 0 &&
-         Body->getElement(0).isDecl(DeclKind::Var) &&
+    assert(!Body->empty() &&
+         Body->getFirstElement().isDecl(DeclKind::Var) &&
          "First element of Body should be a variable to init with the subExpr");
   }
 }
 
 VarDecl * TapExpr::getVar() const {
-  return dyn_cast<VarDecl>(Body->getElement(0).dyn_cast<Decl *>());
+  return dyn_cast<VarDecl>(Body->getFirstElement().dyn_cast<Decl *>());
 }
 
 SourceLoc TapExpr::getEndLoc() const {
diff --git a/lib/IDE/ExprContextAnalysis.cpp b/lib/IDE/ExprContextAnalysis.cpp
@@ -756,7 +756,7 @@ class ExprContextAnalyzer {
   /// in order to avoid a base expression affecting the type. However, now that
   /// we've typechecked, we will take the context type into account.
   static bool isSingleExpressionBodyForCodeCompletion(BraceStmt *body) {
-    return body->getNumElements() == 1 && body->getElements()[0].is<Expr *>();
+    return body->getNumElements() == 1 && body->getFirstElement().is<Expr *>();
   }
 
 public:
diff --git a/lib/IDE/IDERequests.cpp b/lib/IDE/IDERequests.cpp
@@ -486,7 +486,7 @@ struct RangeResolver::Implementation {
           // Unbox the brace statement to find its type.
           if (auto BS = dyn_cast<BraceStmt>(N.get<Stmt*>())) {
             if (!BS->getElements().empty()) {
-              return resolveNodeType(BS->getElements().back(),
+              return resolveNodeType(BS->getLastElement(),
                                      RangeKind::SingleStatement);
             }
           }
diff --git a/lib/IDE/Refactoring.cpp b/lib/IDE/Refactoring.cpp
@@ -1692,7 +1692,7 @@ findCollapseNestedIfTarget(ResolvedCursorInfo CursorInfo) {
     return {};
 
   IfStmt *InnerIf =
-      dyn_cast_or_null<IfStmt>(Body->getElement(0).dyn_cast<Stmt *>());
+      dyn_cast_or_null<IfStmt>(Body->getFirstElement().dyn_cast<Stmt *>());
   if (!InnerIf)
     return {};
 
@@ -2119,8 +2119,8 @@ bool RefactoringActionConvertIfLetExprToGuardExpr::performChange() {
   auto Body = dyn_cast_or_null<BraceStmt>(If->getThenStmt());
   
   // Get if-let then body.
-  auto firstElement = Body->getElements()[0];
-  auto lastElement = Body->getElements().back();
+  auto firstElement = Body->getFirstElement();
+  auto lastElement = Body->getLastElement();
   SourceRange bodyRange = firstElement.getSourceRange();
   bodyRange.widen(lastElement.getSourceRange());
   auto BodyCharRange = Lexer::getCharSourceRangeFromSourceRange(SM, bodyRange);
@@ -2138,8 +2138,8 @@ bool RefactoringActionConvertIfLetExprToGuardExpr::performChange() {
   
   // Get if-let else body.
   if (auto *ElseBody = dyn_cast_or_null<BraceStmt>(If->getElseStmt())) {
-    auto firstElseElement = ElseBody->getElements()[0];
-    auto lastElseElement = ElseBody->getElements().back();
+    auto firstElseElement = ElseBody->getFirstElement();
+    auto lastElseElement = ElseBody->getLastElement();
     SourceRange elseBodyRange = firstElseElement.getSourceRange();
     elseBodyRange.widen(lastElseElement.getSourceRange());
     auto ElseBodyCharRange = Lexer::getCharSourceRangeFromSourceRange(SM, elseBodyRange);
@@ -2225,9 +2225,9 @@ bool RefactoringActionConvertGuardExprToIfLetExpr::performChange() {
   // Get guard body
   auto Body = dyn_cast_or_null<BraceStmt>(Guard->getBody());
   
-  if (Body && Body->getElements().size() > 1) {
-    auto firstElement = Body->getElements()[0];
-    auto lastElement = Body->getElements().back();
+  if (Body && Body->getNumElements() > 1) {
+    auto firstElement = Body->getFirstElement();
+    auto lastElement = Body->getLastElement();
     SourceRange bodyRange = firstElement.getSourceRange();
     bodyRange.widen(lastElement.getSourceRange());
     auto BodyCharRange = Lexer::getCharSourceRangeFromSourceRange(SM, bodyRange);
diff --git a/lib/IRGen/GenClass.cpp b/lib/IRGen/GenClass.cpp
@@ -1466,7 +1466,7 @@ namespace {
       // If we have the destructor body, we know whether SILGen
       // generated a -dealloc body.
       if (auto braceStmt = destructor->getBody())
-        return braceStmt->getNumElements() != 0;
+        return !braceStmt->empty();
 
       // We don't have a destructor body, so hunt for the SIL function
       // for it.
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -5580,7 +5580,7 @@ void Parser::parseAbstractFunctionBody(AbstractFunctionDecl *AFD) {
     // may be incomplete and the type mismatch in return statement will just
     // confuse the type checker.
     if (!Body.hasCodeCompletion() && BS->getNumElements() == 1) {
-      auto Element = BS->getElement(0);
+      auto Element = BS->getFirstElement();
       if (auto *stmt = Element.dyn_cast<Stmt *>()) {
         if (isa<FuncDecl>(AFD)) {
           if (auto *returnStmt = dyn_cast<ReturnStmt>(stmt)) {
@@ -5605,15 +5605,15 @@ void Parser::parseAbstractFunctionBody(AbstractFunctionDecl *AFD) {
         }
         if (auto F = dyn_cast<FuncDecl>(AFD)) {
           auto RS = new (Context) ReturnStmt(SourceLoc(), E);
-          BS->setElement(0, RS); 
+          BS->setFirstElement(RS);
           AFD->setHasSingleExpressionBody();
           AFD->setSingleExpressionBody(E);
         } else if (auto *F = dyn_cast<ConstructorDecl>(AFD)) {
           if (F->isFailable() && isa<NilLiteralExpr>(E)) {
             // If it's a nil literal, just insert return.  This is the only 
             // legal thing to return.
             auto RS = new (Context) ReturnStmt(E->getStartLoc(), E);
-            BS->setElement(0, RS); 
+            BS->setFirstElement(RS);
             AFD->setHasSingleExpressionBody();
             AFD->setSingleExpressionBody(E);
           }
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -982,7 +982,7 @@ void SILGenModule::emitObjCAllocatorDestructor(ClassDecl *cd,
 
   // Emit the Objective-C -dealloc entry point if it has
   // something to do beyond messaging the superclass's -dealloc.
-  if (dd->hasBody() && dd->getBody()->getNumElements() != 0)
+  if (dd->hasBody() && !dd->getBody()->empty())
     emitObjCDestructorThunk(dd);
 
   // Emit the ivar initializer, if needed.
diff --git a/lib/SILGen/SILGenPattern.cpp b/lib/SILGen/SILGenPattern.cpp
@@ -2319,7 +2319,7 @@ void PatternMatchEmission::emitCaseBody(CaseStmt *caseBlock) {
             RegularLocation::getAutoGeneratedLocation(caseBlock->getEndLoc());
     if (auto *braces = dyn_cast<BraceStmt>(caseBlock->getBody()))
       if (braces->getNumElements() == 1 &&
-          dyn_cast_or_null<DoStmt>(braces->getElement(0).dyn_cast<Stmt *>()))
+          dyn_cast_or_null<DoStmt>(braces->getFirstElement().dyn_cast<Stmt *>()))
         cleanupLoc = CleanupLocation(caseBlock);
     SGF.emitBreakOutOf(cleanupLoc, PatternMatchStmt);
   }
diff --git a/lib/SILOptimizer/Mandatory/DataflowDiagnostics.cpp b/lib/SILOptimizer/Mandatory/DataflowDiagnostics.cpp
@@ -60,9 +60,8 @@ static void diagnoseMissingReturn(const UnreachableInst *UI,
 
   SILLocation L = UI->getLoc();
   assert(L && ResTy);
-  auto numElements = BS->getNumElements();
-  if (numElements > 0) {
-    auto element = BS->getElement(numElements - 1);
+  if (!BS->empty()) {
+    auto element = BS->getLastElement();
     if (auto expr = element.dyn_cast<Expr *>()) {
       if (expr->getType()->isEqual(ResTy)) {
         Context.Diags.diagnose(
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -5591,7 +5591,7 @@ ClosureExpr *ExprRewriter::coerceClosureExprToVoid(ClosureExpr *closureExpr) {
 
   // A single-expression body contains a single return statement
   // prior to this transformation.
-  auto member = closureExpr->getBody()->getElement(0);
+  auto member = closureExpr->getBody()->getFirstElement();
  
   if (member.is<Stmt *>()) {
     auto returnStmt = cast<ReturnStmt>(member.get<Stmt *>());
@@ -5643,7 +5643,7 @@ ClosureExpr *ExprRewriter::coerceClosureExprFromNever(ClosureExpr *closureExpr)
 
   // A single-expression body contains a single return statement
   // prior to this transformation.
-  auto member = closureExpr->getBody()->getElement(0);
+  auto member = closureExpr->getBody()->getFirstElement();
 
   if (member.is<Stmt *>()) {
     auto returnStmt = cast<ReturnStmt>(member.get<Stmt *>());
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -2673,7 +2673,7 @@ void ContextualFailure::tryComputedPropertyFixIts(Expr *expr) const {
 
   if (auto TLCD = dyn_cast<TopLevelCodeDecl>(getDC())) {
     if (TLCD->getBody()->isImplicit()) {
-      if (auto decl = TLCD->getBody()->getElement(0).dyn_cast<Decl *>()) {
+      if (auto decl = TLCD->getBody()->getFirstElement().dyn_cast<Decl *>()) {
         if (auto binding = dyn_cast<PatternBindingDecl>(decl)) {
           PBD = binding;
         }
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
@@ -46,7 +46,7 @@ extractEnumElement(TypeChecker &TC, DeclContext *DC, SourceLoc UseLoc,
   if (!body || body->getNumElements() != 1)
     return nullptr;
 
-  auto *retStmtRaw = body->getElement(0).dyn_cast<Stmt *>();
+  auto *retStmtRaw = body->getFirstElement().dyn_cast<Stmt *>();
   auto *retStmt = dyn_cast_or_null<ReturnStmt>(retStmtRaw);
   if (!retStmt)
     return nullptr;
diff --git a/lib/Sema/TypeCheckREPL.cpp b/lib/Sema/TypeCheckREPL.cpp
@@ -443,7 +443,7 @@ void TypeChecker::processREPLTopLevel(SourceFile &SF, TopLevelContext &TLC,
     if (!TLCD || TLCD->getBody()->getElements().empty())
       continue;
 
-    auto Entry = TLCD->getBody()->getElement(0);
+    auto Entry = TLCD->getBody()->getFirstElement();
 
     // Check to see if the TLCD has an expression that we have to transform.
     if (auto *E = Entry.dyn_cast<Expr*>())
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
@@ -1758,9 +1758,9 @@ Stmt *StmtChecker::visitBraceStmt(BraceStmt *BS) {
   // BraceStmt does not start a TopLevelDecl).
   if (IsBraceStmtFromTopLevelDecl) {
     IsBraceStmtFromTopLevelDecl = false;
-  } else if (BS->getNumElements() > 0) {
+  } else if (!BS->empty()) {
     if (auto stmt =
-            BS->getElement(BS->getNumElements() - 1).dyn_cast<Stmt *>()) {
+            BS->getLastElement().dyn_cast<Stmt *>()) {
       if (auto deferStmt = dyn_cast<DeferStmt>(stmt)) {
         TC.diagnose(deferStmt->getStartLoc(), diag::defer_stmt_at_block_end)
             .fixItReplace(deferStmt->getStartLoc(), "do");
@@ -2084,12 +2084,12 @@ TypeCheckFunctionBodyUntilRequest::evaluate(Evaluator &evaluator,
       if (resultTypeLoc.isNull() || resultTypeLoc.getType()->isVoid()) {
         // The function returns void.  We don't need an explicit return, no matter
         // what the type of the expression is.  Take the inserted return back out.
-        body->setElement(0, expr);
+        body->setFirstElement(expr);
       }
     }
   } else if (isa<ConstructorDecl>(AFD) &&
-             (body->getNumElements() == 0 ||
-                !isKnownEndOfConstructor(body->getElements().back()))) {
+             (body->empty() ||
+                !isKnownEndOfConstructor(body->getLastElement()))) {
     // For constructors, we make sure that the body ends with a "return" stmt,
     // which we either implicitly synthesize, or the user can write.  This
     // simplifies SILGen.
@@ -2111,12 +2111,12 @@ TypeCheckFunctionBodyUntilRequest::evaluate(Evaluator &evaluator,
   // that we have eagerly converted something like `{ fatalError() }`
   // into `{ return fatalError() }` that has to be corrected here.
   if (isa<FuncDecl>(AFD) && cast<FuncDecl>(AFD)->hasSingleExpressionBody()) {
-    if (auto *stmt = body->getElement(0).dyn_cast<Stmt *>()) {
+    if (auto *stmt = body->getFirstElement().dyn_cast<Stmt *>()) {
       if (auto *retStmt = dyn_cast<ReturnStmt>(stmt)) {
         if (retStmt->isImplicit() && retStmt->hasResult()) {
           auto returnType = retStmt->getResult()->getType();
           if (returnType && returnType->isUninhabited())
-            body->setElement(0, retStmt->getResult());
+            body->setFirstElement(retStmt->getResult());
         }
       }
     }

Original file line number	Diff line number	Diff line change
`@@ -640,8 +640,7 @@ class ScopeCreator final {`
`640`	`640`	`// Can occur in illegal code`
`641`	`641`	`if (auto const s = n.dyn_cast<Stmt >()) {`
`642`	`642`	`if (auto *const bs = dyn_cast<BraceStmt>(s))`
`643`		`- ASTScopeAssert(bs->getNumElements() == 0,`
`644`		`- "Might mess up insertion point");`
	`643`	`+ ASTScopeAssert(bs->empty(), "Might mess up insertion point");`
`645`	`644`	`}`
`646`	`645`	`return !n.isDecl(DeclKind::Var);`
`647`	`646`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1854,24 +1854,24 @@ FORWARD_SOURCE_LOCS_TO(ClosureExpr, Body.getPointer())`
`1854`	`1854`
`1855`	`1855`	`Expr *ClosureExpr::getSingleExpressionBody() const {`
`1856`	`1856`	`assert(hasSingleExpressionBody() && "Not a single-expression body");`
`1857`		`- auto body = getBody()->getElement(0);`
	`1857`	`+ auto body = getBody()->getFirstElement();`
`1858`	`1858`	`if (body.is<Stmt *>())`
`1859`	`1859`	`return cast<ReturnStmt>(body.get<Stmt *>())->getResult();`
`1860`	`1860`	`return body.get<Expr *>();`
`1861`	`1861`	`}`
`1862`	`1862`
`1863`	`1863`	`void ClosureExpr::setSingleExpressionBody(Expr *NewBody) {`
`1864`	`1864`	`assert(hasSingleExpressionBody() && "Not a single-expression body");`
`1865`		`- auto body = getBody()->getElement(0);`
	`1865`	`+ auto body = getBody()->getFirstElement();`
`1866`	`1866`	`if (body.is<Stmt *>()) {`
`1867`	`1867`	`cast<ReturnStmt>(body.get<Stmt *>())->setResult(NewBody);`
`1868`	`1868`	`return;`
`1869`	`1869`	`}`
`1870`		`- getBody()->setElement(0, NewBody);`
	`1870`	`+ getBody()->setFirstElement(NewBody);`
`1871`	`1871`	`}`
`1872`	`1872`
`1873`	`1873`	`bool ClosureExpr::hasEmptyBody() const {`
`1874`		`- return getBody()->getNumElements() == 0;`
	`1874`	`+ return getBody()->empty();`
`1875`	`1875`	`}`
`1876`	`1876`
`1877`	`1877`	`FORWARD_SOURCE_LOCS_TO(AutoClosureExpr, Body)`
`@@ -1883,7 +1883,7 @@ void AutoClosureExpr::setBody(Expr *E) {`
`1883`	`1883`	`}`
`1884`	`1884`
`1885`	`1885`	`Expr *AutoClosureExpr::getSingleExpressionBody() const {`
`1886`		`- return cast<ReturnStmt>(Body->getElement(0).get<Stmt *>())->getResult();`
	`1886`	`+ return cast<ReturnStmt>(Body->getFirstElement().get<Stmt *>())->getResult();`
`1887`	`1887`	`}`
`1888`	`1888`
`1889`	`1889`	`FORWARD_SOURCE_LOCS_TO(UnresolvedPatternExpr, subPattern)`
`@@ -2222,14 +2222,14 @@ TapExpr::TapExpr(Expr * SubExpr, BraceStmt *Body)`
`2222`	`2222`	`: Expr(ExprKind::Tap, /Implicit=/true),`
`2223`	`2223`	`SubExpr(SubExpr), Body(Body) {`
`2224`	`2224`	`if (Body) {`
`2225`		`- assert(Body->getNumElements() > 0 &&`
`2226`		`- Body->getElement(0).isDecl(DeclKind::Var) &&`
	`2225`	`+ assert(!Body->empty() &&`
	`2226`	`+ Body->getFirstElement().isDecl(DeclKind::Var) &&`
`2227`	`2227`	`"First element of Body should be a variable to init with the subExpr");`
`2228`	`2228`	`}`
`2229`	`2229`	`}`
`2230`	`2230`
`2231`	`2231`	`VarDecl * TapExpr::getVar() const {`
`2232`		`- return dyn_cast<VarDecl>(Body->getElement(0).dyn_cast<Decl *>());`
	`2232`	`+ return dyn_cast<VarDecl>(Body->getFirstElement().dyn_cast<Decl *>());`
`2233`	`2233`	`}`
`2234`	`2234`
`2235`	`2235`	`SourceLoc TapExpr::getEndLoc() const {`
Original file line number	Diff line number	Diff line change
`@@ -756,7 +756,7 @@ class ExprContextAnalyzer {`
`756`	`756`	`/// in order to avoid a base expression affecting the type. However, now that`
`757`	`757`	`/// we've typechecked, we will take the context type into account.`
`758`	`758`	`static bool isSingleExpressionBodyForCodeCompletion(BraceStmt *body) {`
`759`		`- return body->getNumElements() == 1 && body->getElements()[0].is<Expr *>();`
	`759`	`+ return body->getNumElements() == 1 && body->getFirstElement().is<Expr *>();`
`760`	`760`	`}`
`761`	`761`
`762`	`762`	`public:`
Original file line number	Diff line number	Diff line change
`@@ -486,7 +486,7 @@ struct RangeResolver::Implementation {`
`486`	`486`	`// Unbox the brace statement to find its type.`
`487`	`487`	`if (auto BS = dyn_cast<BraceStmt>(N.get<Stmt*>())) {`
`488`	`488`	`if (!BS->getElements().empty()) {`
`489`		`- return resolveNodeType(BS->getElements().back(),`
	`489`	`+ return resolveNodeType(BS->getLastElement(),`
`490`	`490`	`RangeKind::SingleStatement);`
`491`	`491`	`}`
`492`	`492`	`}`