[Sema] Perform actor isolation checking across the whole function at once.

Rather than performing actor isolation checking as part of
"miscellaneous" diagnostics on an expression, do it on the whole
function at once. This should not change behavior by itself.

Author: DougGregor

lib/Sema/MiscDiagnostics.cpp

@@ -4612,7 +4612,6 @@ void swift::performSyntacticExprDiagnostics(const Expr *E,
   if (ctx.LangOpts.EnableObjCInterop)
     diagDeprecatedObjCSelectors(DC, E);
   diagnoseConstantArgumentRequirement(E, DC);
-  checkActorIsolation(E, DC);
 }
 
 void swift::performStmtDiagnostics(const Stmt *S, DeclContext *DC) {

lib/Sema/TypeCheckConcurrency.cpp

@@ -578,8 +578,10 @@ findMemberReference(Expr *expr) {
   return None;
 }
 
-void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
-  class ActorIsolationWalker : public ASTWalker {
+namespace {
+  /// Check for adherence to the actor isolation rules, emitting errors
+  /// when actor-isolated declarations are used in an unsafe manner.
+  class ActorIsolationChecker : public ASTWalker {
     ASTContext &ctx;
     SmallVector<const DeclContext *, 4> contextStack;
 
@@ -588,18 +590,22 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
     }
 
   public:
-    ActorIsolationWalker(const DeclContext *dc) : ctx(dc->getASTContext()) {
+    ActorIsolationChecker(const DeclContext *dc) : ctx(dc->getASTContext()) {
       contextStack.push_back(dc);
     }
 
-    bool shouldWalkIntoSeparatelyCheckedClosure(ClosureExpr *expr) override {
-      return false;
-    }
-
     bool shouldWalkCaptureInitializerExpressions() override { return true; }
 
     bool shouldWalkIntoTapExpression() override { return false; }
 
+    bool walkToDeclPre(Decl *D) override {
+      // Don't walk into functions; they'll be handled separately.
+      if (isa<AbstractFunctionDecl>(D))
+        return false;
+
+      return true;
+    }
+
     std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
       if (auto *closure = dyn_cast<AbstractClosureExpr>(expr)) {
         contextStack.push_back(closure);
@@ -1011,9 +1017,38 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
       llvm_unreachable("unhandled actor isolation kind!");
     }
   };
+}
+
+void swift::checkTopLevelActorIsolation(TopLevelCodeDecl *decl) {
+  ActorIsolationChecker checker(decl);
+  decl->getBody()->walk(checker);
+}
+
+void swift::checkFunctionActorIsolation(AbstractFunctionDecl *decl) {
+  ActorIsolationChecker checker(decl);
+  if (auto body = decl->getBody()) {
+    body->walk(checker);
+  }
+  if (auto ctor = dyn_cast<ConstructorDecl>(decl))
+    if (auto superInit = ctor->getSuperInitCall())
+      superInit->walk(checker);
+}
+
+void swift::checkInitializerActorIsolation(Initializer *init, Expr *expr) {
+  ActorIsolationChecker checker(init);
+  expr->walk(checker);
+}
+
+void swift::checkEnumElementActorIsolation(
+    EnumElementDecl *element, Expr *expr) {
+  ActorIsolationChecker checker(element);
+  expr->walk(checker);
+}
 
-  ActorIsolationWalker walker(dc);
-  const_cast<Expr *>(expr)->walk(walker);
+void swift::checkPropertyWrapperActorIsolation(
+   PatternBindingDecl *binding, Expr *expr) {
+  ActorIsolationChecker checker(binding->getDeclContext());
+  expr->walk(checker);
 }
 
 /// Determine actor isolation solely from attributes.

lib/Sema/TypeCheckConcurrency.h

@@ -22,14 +22,19 @@
 
 namespace swift {
 
+class AbstractFunctionDecl;
 class ActorIsolation;
 class ASTContext;
 class ClassDecl;
 class ConcreteDeclRef;
 class Decl;
 class DeclContext;
+class EnumElementDecl;
 class Expr;
 class FuncDecl;
+class Initializer;
+class PatternBindingDecl;
+class TopLevelCodeDecl;
 class TypeBase;
 class ValueDecl;
 
@@ -38,7 +43,12 @@ class ValueDecl;
 void addAsyncNotes(FuncDecl *func);
 
 /// Check actor isolation rules.
-void checkActorIsolation(const Expr *expr, const DeclContext *dc);
+void checkTopLevelActorIsolation(TopLevelCodeDecl *decl);
+void checkFunctionActorIsolation(AbstractFunctionDecl *decl);
+void checkInitializerActorIsolation(Initializer *init, Expr *expr);
+void checkEnumElementActorIsolation(EnumElementDecl *element, Expr *expr);
+void checkPropertyWrapperActorIsolation(
+    PatternBindingDecl *binding, Expr *expr);
 
 /// The isolation restriction in effect for a given declaration that is
 /// referenced from source.

lib/Sema/TypeCheckDecl.cpp

@@ -1201,6 +1201,7 @@ EnumRawValuesRequest::evaluate(Evaluator &eval, EnumDecl *ED,
       if (TypeChecker::typeCheckExpression(
               exprToCheck, ED,
               /*contextualInfo=*/{rawTy, CTP_EnumCaseRawValue})) {
+        checkEnumElementActorIsolation(elt, exprToCheck);
         TypeChecker::checkEnumElementEffects(elt, exprToCheck);
       }
     }

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -910,6 +910,7 @@ Expr *DefaultArgumentExprRequest::evaluate(Evaluator &evaluator,
     return new (ctx) ErrorExpr(initExpr->getSourceRange(), ErrorType::get(ctx));
   }
 
+  checkInitializerActorIsolation(dc, initExpr);
   TypeChecker::checkInitializerEffects(dc, initExpr);
 
   // Walk the checked initializer and contextualize any closures
@@ -1746,6 +1747,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
               PBD->getInitContext(i));
           if (initContext) {
             // Check safety of error-handling in the declaration, too.
+            checkInitializerActorIsolation(initContext, init);
             TypeChecker::checkInitializerEffects(initContext, init);
             TypeChecker::contextualizeInitializer(initContext, init);
           }

lib/Sema/TypeCheckStmt.cpp

@@ -16,6 +16,7 @@
 
 #include "TypeChecker.h"
 #include "TypeCheckAvailability.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckType.h"
 #include "MiscDiagnostics.h"
 #include "swift/Subsystems.h"
@@ -2066,6 +2067,7 @@ TypeCheckFunctionBodyRequest::evaluate(Evaluator &evaluator,
   if (!hadError)
     performAbstractFuncDeclDiagnostics(AFD);
 
+  checkFunctionActorIsolation(AFD);
   TypeChecker::checkFunctionEffects(AFD);
   TypeChecker::computeCaptures(AFD);
 
@@ -2108,6 +2110,7 @@ void TypeChecker::typeCheckTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {
   BraceStmt *Body = TLCD->getBody();
   StmtChecker(TLCD).typeCheckStmt(Body);
   TLCD->setBody(Body);
+  checkTopLevelActorIsolation(TLCD);
   checkTopLevelEffects(TLCD);
   performTopLevelDeclDiagnostics(TLCD);
 }

lib/Sema/TypeCheckStorage.cpp

@@ -18,6 +18,7 @@
 #include "CodeSynthesis.h"
 #include "TypeChecker.h"
 #include "TypeCheckAvailability.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckDecl.h"
 #include "TypeCheckType.h"
 #include "swift/AST/ASTContext.h"
@@ -2508,6 +2509,7 @@ static void typeCheckSynthesizedWrapperInitializer(
           dyn_cast_or_null<Initializer>(pbd->getInitContext(i))) {
     TypeChecker::contextualizeInitializer(initializerContext, initializer);
   }
+  checkPropertyWrapperActorIsolation(pbd, initializer);
   TypeChecker::checkPropertyWrapperEffects(pbd, initializer);
 }