Address review comments, and add a test

Author: hokein

clang/lib/Analysis/ReachableCode.cpp

@@ -455,7 +455,7 @@ bool DeadCodeScan::isDeadCodeRoot(const clang::CFGBlock *Block) {
 }
 
 // Check if the given `DeadStmt` is a coroutine statement and is a substmt of
-// the coroutine statement.
+// the coroutine statement. `Block` is the CFGBlock containing the `DeadStmt`.
 static bool isInCoroutineStmt(const Stmt* DeadStmt, const CFGBlock *Block) {
   // The coroutine statement, co_return, co_await, or co_yield.
   const Stmt* CoroStmt = nullptr;
@@ -468,20 +468,20 @@ static bool isInCoroutineStmt(const Stmt* DeadStmt, const CFGBlock *Block) {
       if (S == DeadStmt)
         AfterDeadStmt = true;
       if (AfterDeadStmt &&
+          // For simplicity, we only check simple coroutine statements.
           (llvm::isa<CoreturnStmt>(S) || llvm::isa<CoroutineSuspendExpr>(S))) {
         CoroStmt = S;
         break;
       }
     }
   if (!CoroStmt)
     return false;
-
   struct Checker : RecursiveASTVisitor<Checker> {
-    const Stmt *StmtToCheck;
+    const Stmt *DeadStmt;
     bool CoroutineSubStmt = false;
-    Checker(const Stmt *S) : StmtToCheck(S) {}
+    Checker(const Stmt *S) : DeadStmt(S) {}
     bool VisitStmt(const Stmt *S) {
-      if (S == StmtToCheck)
+      if (S == DeadStmt)
         CoroutineSubStmt = true;
       return true;
     }

clang/test/SemaCXX/coroutine-unreachable-warning.cpp

@@ -2,7 +2,7 @@
 
 #include "Inputs/std-coroutine.h"
 
-extern void abort (void) __attribute__ ((__noreturn__));
+extern void abort(void) __attribute__((__noreturn__));
 
 struct task {
   struct promise_type {
@@ -12,6 +12,13 @@ struct task {
     std::suspend_always yield_value(int) { return {}; }
     task get_return_object();
     void unhandled_exception();
+
+    struct Awaiter {
+      bool await_ready();
+      void await_suspend(auto);
+      int await_resume();
+    };
+    auto await_transform(const int& x) { return Awaiter{}; }
   };
 };
 
@@ -22,7 +29,7 @@ task test1() {
 
 task test2() {
   abort();
-  1; // expected-warning {{code will never be executed}}
+  1;  // expected-warning {{code will never be executed}}
   co_yield 1;
 }
 
@@ -33,33 +40,37 @@ task test3() {
 
 task test4() {
   abort();
-  1; // expected-warning {{code will never be executed}}
+  1;  // expected-warning {{code will never be executed}}
   co_return;
 }
 
-
 task test5() {
   abort();
-  co_await std::suspend_never{};
+  co_await 1;
 }
 
 task test6() {
   abort();
-  1; // expected-warning {{code will never be executed}}
-  co_await std::suspend_never{};
+  1;  // expected-warning {{code will never be executed}}
+  co_await 3;
 }
 
 task test7() {
   // coroutine statements are not considered unreachable.
-  co_await std::suspend_never{};
+  co_await 1;
   abort();
-  co_await std::suspend_never{};
+  co_await 2;
 }
 
 task test8() {
   // coroutine statements are not considered unreachable.
-  // co_await std::suspend_never{};
   abort();
   co_return;
-  1 + 1; // expected-warning {{code will never be executed}}
+  1 + 1;  // expected-warning {{code will never be executed}}
+}
+
+task test9() {
+  abort();
+  // This warning is emit on the declaration itself, rather the coroutine substmt.
+  int x = co_await 1; // expected-warning {{code will never be executed}}
 }