[Sema] Corrections for for-await-in syntax to prevent specific bad code-gen scenarios and improve diagnostics

SILGen verification crash when no other async functions are called in a function body not marked as async when a for-await-in syntax is used. This corrects the diagnostics to ensure that the type check effects sees the proper async call that the for-await-in syntax infers.

for-await-in syntax was missing a diagnistic hint for inserting a try when the protocol conformance of the sequence shows a potential of throwing. (also there was a superfluous check for the nominal type in that type check (which was removed).

for-await-in syntax and for-try-await-in syntax did not infer async or throwing to closure constraints, both were added to properly identify the asyncy-ness/throwy-ness of the iteration.

Author: phausler

lib/Sema/ConstraintSystem.cpp

@@ -2295,6 +2295,13 @@ FunctionType::ExtInfo ConstraintSystem::closureEffects(ClosureExpr *expr) {
         return { false, stmt };
       }
 
+      if (auto forEach = dyn_cast<ForEachStmt>(stmt)) {
+        if (forEach->getTryLoc().isValid()) {
+          FoundThrow = true;
+          return { false, nullptr };
+        }
+      }
+
       return { true, stmt };
     }
 
@@ -2332,6 +2339,17 @@ FunctionType::ExtInfo ConstraintSystem::closureEffects(ClosureExpr *expr) {
       return true;
     }
 
+    std::pair<bool, Stmt *> walkToStmtPre(Stmt *stmt) override { 
+      if (auto forEach = dyn_cast<ForEachStmt>(stmt)) {
+        if (forEach->getAwaitLoc().isValid()) {
+          FoundAsync = true;
+          return { false, nullptr };
+        }
+      }
+
+      return { true, stmt };
+    }
+
   public:
     bool foundAsync() { return FoundAsync; }
   };

lib/Sema/TypeCheckConstraints.cpp

@@ -602,27 +602,15 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
         return failed();
       }
     }
-    auto context = Ty->getNominalOrBoundGenericNominal();
-    if (!context) {
-      // if no nominal type can be determined then we must consider this to be
-      // a potential throwing source and concequently this must have a valid try
-      // location to account for that potential ambiguity.
-      if (stmt->getTryLoc().isInvalid()) {
-        auto &diags = dc->getASTContext().Diags;
-        diags.diagnose(stmt->getAwaitLoc(), diag::throwing_call_unhandled);
-        return failed();
-      } else {
-        return false;
-      }
-       
-    }
+    
     auto module = dc->getParentModule();
     auto conformanceRef = module->lookupConformance(Ty, sequenceProto);
 
     if (conformanceRef.classifyAsThrows() && 
         stmt->getTryLoc().isInvalid()) {
       auto &diags = dc->getASTContext().Diags;
-      diags.diagnose(stmt->getAwaitLoc(), diag::throwing_call_unhandled);
+      diags.diagnose(stmt->getAwaitLoc(), diag::throwing_call_unhandled)
+        .fixItInsert(stmt->getAwaitLoc(), "try");
 
       return failed();
     }

lib/Sema/TypeCheckEffects.cpp

@@ -2096,6 +2096,12 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
                         Classification::forThrow(PotentialThrowReason::forThrow(),
                                                  /*async*/false));
     }
+    if (S->getAwaitLoc().isValid() && 
+        !Flags.has(ContextFlags::HasAnyAsyncSite)) {
+      if (!CurContext.handlesAsync()) {
+        CurContext.diagnoseUnhandledAsyncSite(Ctx.Diags, S);
+      }
+    }
     return ShouldRecurse;
   }
 };

test/Concurrency/async_sequence_syntax.swift

@@ -0,0 +1,34 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-concurrency
+// REQUIRES: concurrency
+
+// expected-note@+1{{add 'async' to function 'missingAsync' to make it asynchronous}}
+func missingAsync<T : AsyncSequence>(_ seq: T) throws { 
+  for try await _ in seq { } // expected-error{{'async' in a function that does not support concurrency}}
+}
+
+func missingThrows<T : AsyncSequence>(_ seq: T) async {
+  for try await _ in seq { } // expected-error{{error is not handled because the enclosing function is not declared 'throws'}}
+}
+
+func executeAsync(_ work: () async -> Void) { }
+func execute(_ work: () -> Void) { }
+
+func missingThrowingInBlock<T : AsyncSequence>(_ seq: T) { 
+  executeAsync { // expected-error{{invalid conversion from throwing function of type '() async throws -> Void' to non-throwing function type '() async -> Void'}}
+    for try await _ in seq { }
+  }
+}
+
+func missingTryInBlock<T : AsyncSequence>(_ seq: T) { 
+  executeAsync { 
+    for await _ in seq { } // expected-error{{call can throw, but the error is not handled}}
+  }
+}
+
+func missingAsyncInBlock<T : AsyncSequence>(_ seq: T) { 
+  execute { // expected-error{{invalid conversion from 'async' function of type '() async -> Void' to synchronous function type '() -> Void'}}
+    do { 
+      for try await _ in seq { }
+    } catch { }
+  }
+}