[Sema] Rename error-handling code to effects-handling code.

The error-handling code is getting generalized for 'async' handling as
well, so rename the various entry points to talk about "effects"
instead.

Author: DougGregor

lib/Sema/CMakeLists.txt

@@ -46,7 +46,7 @@ add_swift_host_library(swiftSema STATIC
   TypeCheckDeclObjC.cpp
   TypeCheckDeclOverride.cpp
   TypeCheckDeclPrimary.cpp
-  TypeCheckError.cpp
+  TypeCheckEffects.cpp
   TypeCheckExpr.cpp
   TypeCheckExprObjC.cpp
   TypeCheckGeneric.cpp

lib/Sema/PCMacro.cpp

@@ -354,7 +354,7 @@ class Instrumenter : InstrumenterBase {
 
         if (NB != B) {
           FD->setBody(NB);
-          TypeChecker::checkFunctionErrorHandling(FD);
+          TypeChecker::checkFunctionEffects(FD);
         }
       }
     } else if (auto *NTD = dyn_cast<NominalTypeDecl>(D)) {
@@ -695,7 +695,7 @@ void swift::performPCMacro(SourceFile &SF) {
             BraceStmt *NewBody = I.transformBraceStmt(Body, true);
             if (NewBody != Body) {
               TLCD->setBody(NewBody);
-              TypeChecker::checkTopLevelErrorHandling(TLCD);
+              TypeChecker::checkTopLevelEffects(TLCD);
               TypeChecker::contextualizeTopLevelCode(TLCD);
             }
             return false;

lib/Sema/PlaygroundTransform.cpp

@@ -294,7 +294,7 @@ class Instrumenter : InstrumenterBase {
         BraceStmt *NB = transformBraceStmt(B);
         if (NB != B) {
           FD->setBody(NB);
-          TypeChecker::checkFunctionErrorHandling(FD);
+          TypeChecker::checkFunctionEffects(FD);
         }
       }
     } else if (auto *NTD = dyn_cast<NominalTypeDecl>(D)) {
@@ -893,7 +893,7 @@ void swift::performPlaygroundTransform(SourceFile &SF, bool HighPerformance) {
             BraceStmt *NewBody = I.transformBraceStmt(Body);
             if (NewBody != Body) {
               FD->setBody(NewBody);
-              TypeChecker::checkFunctionErrorHandling(FD);
+              TypeChecker::checkFunctionEffects(FD);
             }
             return false;
           }
@@ -905,7 +905,7 @@ void swift::performPlaygroundTransform(SourceFile &SF, bool HighPerformance) {
             BraceStmt *NewBody = I.transformBraceStmt(Body, true);
             if (NewBody != Body) {
               TLCD->setBody(NewBody);
-              TypeChecker::checkTopLevelErrorHandling(TLCD);
+              TypeChecker::checkTopLevelEffects(TLCD);
             }
             return false;
           }

lib/Sema/TypeCheckDecl.cpp

@@ -1066,7 +1066,7 @@ EnumRawValuesRequest::evaluate(Evaluator &eval, EnumDecl *ED,
       if (TypeChecker::typeCheckExpression(exprToCheck, ED,
                                            rawTy,
                                            CTP_EnumCaseRawValue)) {
-        TypeChecker::checkEnumElementErrorHandling(elt, exprToCheck);
+        TypeChecker::checkEnumElementEffects(elt, exprToCheck);
       }
     }
 

lib/Sema/TypeCheckDeclPrimary.cpp

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

lib/Sema/TypeCheckError.cpp renamed to lib/Sema/TypeCheckEffects.cpp

@@ -1,4 +1,4 @@
-//===--- TypeCheckError.cpp - Type Checking for Error Coverage ------------===//
+//===--- TypeCheckEffects.cpp - Type Checking for Effects Coverage --------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements semantic analysis to ensure that errors are
-// caught.
+// This file implements semantic analysis to ensure that various effects (such
+// as throwing and async) are properly handled.
 //
 //===----------------------------------------------------------------------===//
 
@@ -184,9 +184,9 @@ enum ShouldRecurse_t : bool {
 };
 
 /// A CRTP ASTWalker implementation that looks for interesting
-/// nodes for error handling.
+/// nodes for effects handling.
 template <class Impl>
-class ErrorHandlingWalker : public ASTWalker {
+class EffectsHandlingWalker : public ASTWalker {
   Impl &asImpl() { return *static_cast<Impl*>(this); }
 public:
   bool walkToDeclPre(Decl *D) override {
@@ -221,7 +221,7 @@ class ErrorHandlingWalker : public ASTWalker {
     } else if (auto interpolated = dyn_cast<InterpolatedStringLiteralExpr>(E)) {
       recurse = asImpl().checkInterpolatedStringLiteral(interpolated);
     }
-    // Error handling validation (via checkTopLevelErrorHandling) happens after
+    // Error handling validation (via checkTopLevelEffects) happens after
     // type checking. If an unchecked expression is still around, the code was
     // invalid.
 #define UNCHECKED_EXPR(KIND, BASE) \
@@ -580,7 +580,7 @@ class ApplyClassifier {
   }
 
   class FunctionBodyClassifier
-      : public ErrorHandlingWalker<FunctionBodyClassifier> {
+      : public EffectsHandlingWalker<FunctionBodyClassifier> {
     ApplyClassifier &Self;
   public:
     bool IsInvalid = false;
@@ -1221,8 +1221,8 @@ class Context {
 
 /// A class to walk over a local context and validate the correctness
 /// of its error coverage.
-class CheckErrorCoverage : public ErrorHandlingWalker<CheckErrorCoverage> {
-  friend class ErrorHandlingWalker<CheckErrorCoverage>;
+class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage> {
+  friend class EffectsHandlingWalker<CheckEffectsCoverage>;
 
   ASTContext &Ctx;
 
@@ -1288,13 +1288,13 @@ class CheckErrorCoverage : public ErrorHandlingWalker<CheckErrorCoverage> {
   /// An RAII object for restoring all the interesting state in an
   /// error-coverage.
   class ContextScope {
-    CheckErrorCoverage &Self;
+  CheckEffectsCoverage &Self;
     Context OldContext;
     DeclContext *OldRethrowsDC;
     ContextFlags OldFlags;
     ThrowingKind OldMaxThrowingKind;
   public:
-    ContextScope(CheckErrorCoverage &self, Optional<Context> newContext)
+    ContextScope(CheckEffectsCoverage &self, Optional<Context> newContext)
       : Self(self), OldContext(self.CurContext),
         OldRethrowsDC(self.Classifier.RethrowsDC),
         OldFlags(self.Flags),
@@ -1379,7 +1379,7 @@ class CheckErrorCoverage : public ErrorHandlingWalker<CheckErrorCoverage> {
   };
 
 public:
-  CheckErrorCoverage(ASTContext &ctx, Context initialContext)
+  CheckEffectsCoverage(ASTContext &ctx, Context initialContext)
     : Ctx(ctx), CurContext(initialContext),
       MaxThrowingKind(ThrowingKind::None) {
 
@@ -1528,8 +1528,8 @@ class CheckErrorCoverage : public ErrorHandlingWalker<CheckErrorCoverage> {
     // Check the inactive regions of a #if block to disable warnings that may
     // be due to platform specific code.
     struct ConservativeThrowChecker : public ASTWalker {
-      CheckErrorCoverage &CEC;
-      ConservativeThrowChecker(CheckErrorCoverage &CEC) : CEC(CEC) {}
+      CheckEffectsCoverage &CEC;
+      ConservativeThrowChecker(CheckEffectsCoverage &CEC) : CEC(CEC) {}
 
       Expr *walkToExprPost(Expr *E) override {
         if (isa<TryExpr>(E))
@@ -1694,9 +1694,9 @@ class CheckErrorCoverage : public ErrorHandlingWalker<CheckErrorCoverage> {
 
 } // end anonymous namespace
 
-void TypeChecker::checkTopLevelErrorHandling(TopLevelCodeDecl *code) {
+void TypeChecker::checkTopLevelEffects(TopLevelCodeDecl *code) {
   auto &ctx = code->getDeclContext()->getASTContext();
-  CheckErrorCoverage checker(ctx, Context::forTopLevelCode(code));
+  CheckEffectsCoverage checker(ctx, Context::forTopLevelCode(code));
 
   // In some language modes, we allow top-level code to omit 'try' marking.
   if (ctx.LangOpts.EnableThrowWithoutTry)
@@ -1705,16 +1705,16 @@ void TypeChecker::checkTopLevelErrorHandling(TopLevelCodeDecl *code) {
   code->getBody()->walk(checker);
 }
 
-void TypeChecker::checkFunctionErrorHandling(AbstractFunctionDecl *fn) {
+void TypeChecker::checkFunctionEffects(AbstractFunctionDecl *fn) {
 #ifndef NDEBUG
-  PrettyStackTraceDecl debugStack("checking error handling for", fn);
+  PrettyStackTraceDecl debugStack("checking effects handling for", fn);
 #endif
 
   auto isDeferBody = isa<FuncDecl>(fn) && cast<FuncDecl>(fn)->isDeferBody();
   auto context =
       isDeferBody ? Context::forDeferBody() : Context::forFunction(fn);
   auto &ctx = fn->getASTContext();
-  CheckErrorCoverage checker(ctx, context);
+  CheckEffectsCoverage checker(ctx, context);
 
   // If this is a debugger function, suppress 'try' marking at the top level.
   if (fn->getAttrs().hasAttribute<LLDBDebuggerFunctionAttr>())
@@ -1728,30 +1728,30 @@ void TypeChecker::checkFunctionErrorHandling(AbstractFunctionDecl *fn) {
       superInit->walk(checker);
 }
 
-void TypeChecker::checkInitializerErrorHandling(Initializer *initCtx,
+void TypeChecker::checkInitializerEffects(Initializer *initCtx,
                                                 Expr *init) {
   auto &ctx = initCtx->getASTContext();
-  CheckErrorCoverage checker(ctx, Context::forInitializer(initCtx));
+  CheckEffectsCoverage checker(ctx, Context::forInitializer(initCtx));
   init->walk(checker);
 }
 
-/// Check the correctness of error handling within the given enum
+/// Check the correctness of effects within the given enum
 /// element's raw value expression.
 ///
 /// The syntactic restrictions on such expressions should make it
 /// impossible for errors to ever arise, but checking them anyway (1)
 /// ensures correctness if those restrictions are ever loosened,
 /// perhaps accidentally, and (2) allows the verifier to assert that
 /// all calls have been checked.
-void TypeChecker::checkEnumElementErrorHandling(EnumElementDecl *elt, Expr *E) {
+void TypeChecker::checkEnumElementEffects(EnumElementDecl *elt, Expr *E) {
   auto &ctx = elt->getASTContext();
-  CheckErrorCoverage checker(ctx, Context::forEnumElementInitializer(elt));
+  CheckEffectsCoverage checker(ctx, Context::forEnumElementInitializer(elt));
   E->walk(checker);
 }
 
-void TypeChecker::checkPropertyWrapperErrorHandling(
+void TypeChecker::checkPropertyWrapperEffects(
     PatternBindingDecl *binding, Expr *expr) {
   auto &ctx = binding->getASTContext();
-  CheckErrorCoverage checker(ctx, Context::forPatternBinding(binding));
+  CheckEffectsCoverage checker(ctx, Context::forPatternBinding(binding));
   expr->walk(checker);
 }

lib/Sema/TypeCheckStmt.cpp

@@ -1698,7 +1698,7 @@ static Type getFunctionBuilderType(FuncDecl *FD) {
 bool TypeChecker::typeCheckAbstractFunctionBody(AbstractFunctionDecl *AFD) {
   auto res = evaluateOrDefault(AFD->getASTContext().evaluator,
                                TypeCheckFunctionBodyRequest{AFD}, true);
-  TypeChecker::checkFunctionErrorHandling(AFD);
+  TypeChecker::checkFunctionEffects(AFD);
   TypeChecker::computeCaptures(AFD);
   return res;
 }
@@ -2152,7 +2152,7 @@ void TypeChecker::typeCheckTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {
   BraceStmt *Body = TLCD->getBody();
   StmtChecker(TLCD).typeCheckStmt(Body);
   TLCD->setBody(Body);
-  checkTopLevelErrorHandling(TLCD);
+  checkTopLevelEffects(TLCD);
   performTopLevelDeclDiagnostics(TLCD);
 }
 

lib/Sema/TypeCheckStorage.cpp

@@ -2491,7 +2491,7 @@ static void typeCheckSynthesizedWrapperInitializer(
           dyn_cast_or_null<Initializer>(pbd->getInitContext(i))) {
     TypeChecker::contextualizeInitializer(initializerContext, initializer);
   }
-  TypeChecker::checkPropertyWrapperErrorHandling(pbd, initializer);
+  TypeChecker::checkPropertyWrapperEffects(pbd, initializer);
 }
 
 static PropertyWrapperMutability::Value

lib/Sema/TypeChecker.h

@@ -1147,11 +1147,11 @@ void diagnoseIfDeprecated(SourceRange SourceRange,
 void checkForForbiddenPrefix(ASTContext &C, DeclBaseName Name);
 
 /// Check error handling in the given type-checked top-level code.
-void checkTopLevelErrorHandling(TopLevelCodeDecl *D);
-void checkFunctionErrorHandling(AbstractFunctionDecl *D);
-void checkInitializerErrorHandling(Initializer *I, Expr *E);
-void checkEnumElementErrorHandling(EnumElementDecl *D, Expr *expr);
-void checkPropertyWrapperErrorHandling(PatternBindingDecl *binding,
+void checkTopLevelEffects(TopLevelCodeDecl *D);
+void checkFunctionEffects(AbstractFunctionDecl *D);
+void checkInitializerEffects(Initializer *I, Expr *E);
+void checkEnumElementEffects(EnumElementDecl *D, Expr *expr);
+void checkPropertyWrapperEffects(PatternBindingDecl *binding,
                                        Expr *expr);
 
 /// If an expression references 'self.init' or 'super.init' in an