Merge pull request #70013 from ahoppen/ahoppen/remove-leaveclosurebodiesunchecked

ahoppen · web-flow · commit 6ac7915dae11 · 2023-11-27T14:03:18.000-08:00
[Sema] Remove `LeaveClosureBodiesUnchecked`
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -2212,9 +2212,7 @@ class PatternBindingDecl final : public Decl,
   }
 
   /// Returns the typechecked binding entry at the given index.
-  const PatternBindingEntry *
-  getCheckedPatternBindingEntry(unsigned i,
-                                bool leaveClosureBodiesUnchecked = false) const;
+  const PatternBindingEntry *getCheckedPatternBindingEntry(unsigned i) const;
 
   /// Clean up walking the initializers for the pattern
   class InitIterator {
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -2327,7 +2327,7 @@ class ResultTypeRequest
 class PatternBindingEntryRequest
     : public SimpleRequest<PatternBindingEntryRequest,
                            const PatternBindingEntry *(PatternBindingDecl *,
-                                                       unsigned, bool),
+                                                       unsigned),
                            RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2336,9 +2336,8 @@ class PatternBindingEntryRequest
   friend SimpleRequest;
 
   // Evaluation.
-  const PatternBindingEntry *evaluate(Evaluator &evaluator,
-                                      PatternBindingDecl *PBD, unsigned i,
-                                      bool LeaveClosureBodiesUnchecked) const;
+  const PatternBindingEntry *
+  evaluate(Evaluator &evaluator, PatternBindingDecl *PBD, unsigned i) const;
 
 public:
   // Separate caching.
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -256,7 +256,7 @@ SWIFT_REQUEST(TypeChecker, OverriddenDeclsRequest,
               llvm::TinyPtrVector<ValueDecl *>(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PatternBindingEntryRequest,
-              const PatternBindingEntry *(PatternBindingDecl *, unsigned, bool),
+              const PatternBindingEntry *(PatternBindingDecl *, unsigned),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PatternBindingCheckedAndContextualizedInitRequest,
               Expr *(PatternBindingDecl *, unsigned),
diff --git a/include/swift/Sema/ConstraintSystem.h b/include/swift/Sema/ConstraintSystem.h
@@ -1806,14 +1806,10 @@ enum class ConstraintSystemFlags {
   /// \c DebugConstraintSolverOnLines.
   DebugConstraints = 0x08,
 
-  /// Don't try to type check closure bodies, and leave them unchecked. This is
-  /// used for source tooling functionalities.
-  LeaveClosureBodyUnchecked = 0x10,
-
   /// If set, we are solving specifically to determine the type of a
   /// CodeCompletionExpr, and should continue in the presence of errors wherever
   /// possible.
-  ForCodeCompletion = 0x20,
+  ForCodeCompletion = 0x10,
 
   /// Include Clang function types when checking equality for function types.
   ///
@@ -1824,13 +1820,13 @@ enum class ConstraintSystemFlags {
   /// should be treated as semantically different, as they may have different
   /// calling conventions, say due to Clang attributes such as
   /// `__attribute__((ns_consumed))`.
-  UseClangFunctionTypes = 0x40,
+  UseClangFunctionTypes = 0x20,
 
   /// When set, ignore async/sync mismatches
-  IgnoreAsyncSyncMismatch = 0x80,
+  IgnoreAsyncSyncMismatch = 0x40,
 
   /// Disable macro expansions.
-  DisableMacroExpansions = 0x100,
+  DisableMacroExpansions = 0x80,
 };
 
 /// Options that affect the constraint system as a whole.
@@ -5210,17 +5206,15 @@ class ConstraintSystem {
   /// \param replaceInvalidRefsWithErrors Indicates whether it's allowed
   /// to replace any discovered invalid member references with `ErrorExpr`.
   static bool preCheckTarget(SyntacticElementTarget &target,
-                             bool replaceInvalidRefsWithErrors,
-                             bool leaveClosureBodiesUnchecked);
+                             bool replaceInvalidRefsWithErrors);
 
   /// Pre-check the expression, validating any types that occur in the
   /// expression and folding sequence expressions.
   ///
   /// \param replaceInvalidRefsWithErrors Indicates whether it's allowed
   /// to replace any discovered invalid member references with `ErrorExpr`.
   static bool preCheckExpression(Expr *&expr, DeclContext *dc,
-                                 bool replaceInvalidRefsWithErrors,
-                                 bool leaveClosureBodiesUnchecked);
+                                 bool replaceInvalidRefsWithErrors);
 
   /// Solve the system of constraints generated from provided target.
   ///
diff --git a/include/swift/Sema/IDETypeChecking.h b/include/swift/Sema/IDETypeChecking.h
@@ -58,8 +58,7 @@ namespace swift {
   }
 
   /// Typecheck binding initializer at \p bindingIndex.
-  void typeCheckPatternBinding(PatternBindingDecl *PBD, unsigned bindingIndex,
-                               bool leaveClosureBodiesUnchecked);
+  void typeCheckPatternBinding(PatternBindingDecl *PBD, unsigned bindingIndex);
 
   /// Check if T1 is convertible to T2.
   ///
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -2220,12 +2220,11 @@ bool PatternBindingDecl::hasStorage() const {
   return false;
 }
 
-const PatternBindingEntry *PatternBindingDecl::getCheckedPatternBindingEntry(
-    unsigned i, bool leaveClosureBodiesUnchecked) const {
+const PatternBindingEntry *
+PatternBindingDecl::getCheckedPatternBindingEntry(unsigned i) const {
   return evaluateOrDefault(
       getASTContext().evaluator,
-      PatternBindingEntryRequest{const_cast<PatternBindingDecl *>(this), i,
-                                 leaveClosureBodiesUnchecked},
+      PatternBindingEntryRequest{const_cast<PatternBindingDecl *>(this), i},
       nullptr);
 }
 
@@ -2428,8 +2427,7 @@ bool PatternBindingDecl::isComputingPatternBindingEntry(
     const VarDecl *vd) const {
   unsigned i = getPatternEntryIndexForVarDecl(vd);
   return getASTContext().evaluator.hasActiveRequest(
-      PatternBindingEntryRequest{const_cast<PatternBindingDecl *>(this), i,
-                                 /*LeaveClosureBodyUnchecked=*/false});
+      PatternBindingEntryRequest{const_cast<PatternBindingDecl *>(this), i});
 }
 
 bool PatternBindingDecl::isExplicitlyInitialized(unsigned i) const {
diff --git a/lib/IDE/PostfixCompletion.cpp b/lib/IDE/PostfixCompletion.cpp
@@ -328,8 +328,7 @@ getOperatorCompletionTypes(DeclContext *DC, Type LHSType, OperatorDecl *Op) {
     llvm_unreachable("unexpected operator kind");
   }
 
-  CS.preCheckExpression(OpCallExpr, DC, /*replaceInvalidRefsWithErrors=*/true,
-                        /*leaveClosureBodyUnchecked=*/false);
+  CS.preCheckExpression(OpCallExpr, DC, /*replaceInvalidRefsWithErrors=*/true);
   OpCallExpr = CS.generateConstraints(OpCallExpr, DC);
 
   CS.assignFixedType(CS.getType(&LHS)->getAs<TypeVariableType>(), LHSType);
diff --git a/lib/Sema/BuilderTransform.cpp b/lib/Sema/BuilderTransform.cpp
@@ -1310,8 +1310,7 @@ class PreCheckResultBuilderApplication : public ASTWalker {
       DiagnosticTransaction transaction(diagEngine);
 
       HasError |= ConstraintSystem::preCheckExpression(
-          E, DC, /*replaceInvalidRefsWithErrors=*/true,
-          /*leaveClosureBodiesUnchecked=*/false);
+          E, DC, /*replaceInvalidRefsWithErrors=*/true);
 
       HasError |= transaction.hasErrors();
 
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -8749,11 +8749,8 @@ namespace {
         return true;
 
       case SolutionApplicationToFunctionResult::Delay: {
-        if (!Rewriter.cs.Options
-                .contains(ConstraintSystemFlags::LeaveClosureBodyUnchecked)) {
-          auto closure = cast<ClosureExpr>(fn.getAbstractClosureExpr());
-          ClosuresToTypeCheck.push_back(closure);
-        }
+        auto closure = cast<ClosureExpr>(fn.getAbstractClosureExpr());
+        ClosuresToTypeCheck.push_back(closure);
         return false;
       }
       }
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -10514,8 +10514,7 @@ static bool inferEnumMemberThroughTildeEqualsOperator(
 
   DiagnosticTransaction diagnostics(ctx.Diags);
   {
-    if (cs.preCheckTarget(target, /*replaceInvalidRefWithErrors=*/true,
-                          /*leaveClosureBodyUnchecked=*/false)) {
+    if (cs.preCheckTarget(target, /*replaceInvalidRefWithErrors=*/true)) {
       // Skip diagnostics if they are disabled, otherwise it would result in
       // duplicate diagnostics, since this operation is going to be repeated
       // in diagnostic mode.
diff --git a/lib/Sema/CSSyntacticElement.cpp b/lib/Sema/CSSyntacticElement.cpp
@@ -539,8 +539,7 @@ class SyntacticElementConstraintGenerator
   void visitExprPattern(ExprPattern *EP) {
     auto target = SyntacticElementTarget::forExprPattern(EP);
 
-    if (cs.preCheckTarget(target, /*replaceInvalidRefWithErrors=*/true,
-                          /*leaveClosureBodyUnchecked=*/false)) {
+    if (cs.preCheckTarget(target, /*replaceInvalidRefWithErrors=*/true)) {
       hadError = true;
       return;
     }
@@ -757,8 +756,7 @@ class SyntacticElementConstraintGenerator
           /*bindPatternVarsOneWay=*/false);
 
       if (ConstraintSystem::preCheckTarget(
-              target, /*replaceInvalidRefsWithErrors=*/true,
-              /*LeaveCLosureBodyUnchecked=*/false))
+              target, /*replaceInvalidRefsWithErrors=*/true))
         return llvm::None;
 
       return target;
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -7407,9 +7407,6 @@ bool ConstraintSystem::participatesInInference(ClosureExpr *closure) const {
   if (getAppliedResultBuilderTransform(closure))
     return true;
 
-  if (Options.contains(ConstraintSystemFlags::LeaveClosureBodyUnchecked))
-    return false;
-
   if (closure->hasEmptyBody())
     return false;
 
diff --git a/lib/Sema/PreCheckExpr.cpp b/lib/Sema/PreCheckExpr.cpp
@@ -939,8 +939,6 @@ namespace {
     /// implicit `ErrorExpr` in place of invalid references.
     bool UseErrorExprs;
 
-    bool LeaveClosureBodiesUnchecked;
-
     /// A stack of expressions being walked, used to determine where to
     /// insert RebindSelfInConstructorExpr nodes.
     llvm::SmallVector<Expr *, 8> ExprStack;
@@ -1009,11 +1007,9 @@ namespace {
 
   public:
     PreCheckExpression(DeclContext *dc, Expr *parent,
-                       bool replaceInvalidRefsWithErrors,
-                       bool leaveClosureBodiesUnchecked)
-        : Ctx(dc->getASTContext()), DC(dc),
-          ParentExpr(parent), UseErrorExprs(replaceInvalidRefsWithErrors),
-          LeaveClosureBodiesUnchecked(leaveClosureBodiesUnchecked) {}
+                       bool replaceInvalidRefsWithErrors)
+        : Ctx(dc->getASTContext()), DC(dc), ParentExpr(parent),
+          UseErrorExprs(replaceInvalidRefsWithErrors) {}
 
     ASTContext &getASTContext() const { return Ctx; }
 
@@ -1394,9 +1390,7 @@ namespace {
 /// true when we want the body to be considered part of this larger expression.
 bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
   // If we have a single statement that can become an expression, turn it
-  // into an expression now. This needs to happen before we check
-  // LeaveClosureBodiesUnchecked, as the closure may become a single expression
-  // closure.
+  // into an expression now.
   auto *body = closure->getBody();
   if (auto *S = body->getSingleActiveStatement()) {
     if (S->mayProduceSingleValue(Ctx)) {
@@ -1408,12 +1402,6 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
     }
   }
 
-  // If we won't be checking the body of the closure, don't walk into it here.
-  if (!closure->hasSingleExpressionBody()) {
-    if (LeaveClosureBodiesUnchecked)
-      return false;
-  }
-
   // Update the current DeclContext to be the closure we're about to
   // recurse into.
   assert((closure->getParent() == DC ||
@@ -2310,15 +2298,13 @@ Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {
 }
 
 bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target,
-                                      bool replaceInvalidRefsWithErrors,
-                                      bool leaveClosureBodiesUnchecked) {
+                                      bool replaceInvalidRefsWithErrors) {
   auto *DC = target.getDeclContext();
 
   bool hadErrors = false;
 
   if (auto *expr = target.getAsExpr()) {
-    hadErrors |= preCheckExpression(expr, DC, replaceInvalidRefsWithErrors,
-                                    leaveClosureBodiesUnchecked);
+    hadErrors |= preCheckExpression(expr, DC, replaceInvalidRefsWithErrors);
     // Even if the pre-check fails, expression still has to be re-set.
     target.setExpr(expr);
   }
@@ -2330,13 +2316,11 @@ bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target,
     auto *whereExpr = stmt->getWhere();
 
     hadErrors |= preCheckExpression(sequenceExpr, DC,
-                                    /*replaceInvalidRefsWithErrors=*/true,
-                                    /*leaveClosureBodiesUnchecked=*/false);
+                                    /*replaceInvalidRefsWithErrors=*/true);
 
     if (whereExpr) {
       hadErrors |= preCheckExpression(whereExpr, DC,
-                                      /*replaceInvalidRefsWithErrors=*/true,
-                                      /*leaveClosureBodiesUnchecked=*/false);
+                                      /*replaceInvalidRefsWithErrors=*/true);
     }
 
     // Update sequence and where expressions to pre-checked versions.
@@ -2354,14 +2338,11 @@ bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target,
 /// Pre-check the expression, validating any types that occur in the
 /// expression and folding sequence expressions.
 bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc,
-                                          bool replaceInvalidRefsWithErrors,
-                                          bool leaveClosureBodiesUnchecked) {
+                                          bool replaceInvalidRefsWithErrors) {
   auto &ctx = dc->getASTContext();
   FrontendStatsTracer StatsTracer(ctx.Stats, "precheck-expr", expr);
 
-  PreCheckExpression preCheck(dc, expr,
-                              replaceInvalidRefsWithErrors,
-                              leaveClosureBodiesUnchecked);
+  PreCheckExpression preCheck(dc, expr, replaceInvalidRefsWithErrors);
 
   // Perform the pre-check.
   if (auto result = expr->walk(preCheck)) {
diff --git a/lib/Sema/TypeCheckCodeCompletion.cpp b/lib/Sema/TypeCheckCodeCompletion.cpp
@@ -77,9 +77,6 @@ getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
 
   ConstraintSystemOptions options;
   options |= ConstraintSystemFlags::SuppressDiagnostics;
-  if (!Context.CompletionCallback) {
-    options |= ConstraintSystemFlags::LeaveClosureBodyUnchecked;
-  }
 
   // Construct a constraint system from this expression.
   ConstraintSystem cs(dc, options);
@@ -223,8 +220,7 @@ bool TypeChecker::typeCheckForCodeCompletion(
     // expression and folding sequence expressions.
     auto failedPreCheck =
         ConstraintSystem::preCheckTarget(target,
-                                         /*replaceInvalidRefsWithErrors=*/true,
-                                         /*leaveClosureBodiesUnchecked=*/true);
+                                         /*replaceInvalidRefsWithErrors=*/true);
 
     if (failedPreCheck)
       return false;
@@ -238,10 +234,7 @@ bool TypeChecker::typeCheckForCodeCompletion(
     options |= ConstraintSystemFlags::AllowFixes;
     options |= ConstraintSystemFlags::SuppressDiagnostics;
     options |= ConstraintSystemFlags::ForCodeCompletion;
-    if (!Context.CompletionCallback) {
-      options |= ConstraintSystemFlags::LeaveClosureBodyUnchecked;
-    }
-
+    
     ConstraintSystem cs(DC, options);
 
     llvm::SmallVector<Solution, 4> solutions;
@@ -309,8 +302,7 @@ getTypeOfCompletionContextExpr(DeclContext *DC, CompletionTypeCheckKind kind,
                                ConcreteDeclRef &referencedDecl) {
   if (constraints::ConstraintSystem::preCheckExpression(
           parsedExpr, DC,
-          /*replaceInvalidRefsWithErrors=*/true,
-          /*leaveClosureBodiesUnchecked=*/true))
+          /*replaceInvalidRefsWithErrors=*/true))
     return llvm::None;
 
   switch (kind) {
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -448,8 +448,7 @@ TypeChecker::typeCheckTarget(SyntacticElementTarget &target,
   // First, pre-check the target, validating any types that occur in the
   // expression and folding sequence expressions.
   if (ConstraintSystem::preCheckTarget(
-          target, /*replaceInvalidRefsWithErrors=*/true,
-          options.contains(TypeCheckExprFlags::LeaveClosureBodyUnchecked))) {
+          target, /*replaceInvalidRefsWithErrors=*/true)) {
     return llvm::None;
   }
 
@@ -468,9 +467,6 @@ TypeChecker::typeCheckTarget(SyntacticElementTarget &target,
   if (DiagnosticSuppression::isEnabled(Context.Diags))
     csOptions |= ConstraintSystemFlags::SuppressDiagnostics;
 
-  if (options.contains(TypeCheckExprFlags::LeaveClosureBodyUnchecked))
-    csOptions |= ConstraintSystemFlags::LeaveClosureBodyUnchecked;
-
   if (options.contains(TypeCheckExprFlags::DisableMacroExpansions))
     csOptions |= ConstraintSystemFlags::DisableMacroExpansions;
 
diff --git a/lib/Sema/TypeCheckDeclPrimary.cpp b/lib/Sema/TypeCheckDeclPrimary.cpp
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
diff --git a/lib/Sema/TypeCheckStorage.cpp b/lib/Sema/TypeCheckStorage.cpp
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h

Original file line number	Diff line number	Diff line change
`@@ -2212,9 +2212,7 @@ class PatternBindingDecl final : public Decl,`
`2212`	`2212`	`}`
`2213`	`2213`
`2214`	`2214`	`/// Returns the typechecked binding entry at the given index.`
`2215`		`- const PatternBindingEntry *`
`2216`		`- getCheckedPatternBindingEntry(unsigned i,`
`2217`		`- bool leaveClosureBodiesUnchecked = false) const;`
	`2215`	`+ const PatternBindingEntry *getCheckedPatternBindingEntry(unsigned i) const;`
`2218`	`2216`
`2219`	`2217`	`/// Clean up walking the initializers for the pattern`
`2220`	`2218`	`class InitIterator {`
Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,7 @@ namespace swift {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`/// Typecheck binding initializer at \p bindingIndex.`
`61`		`- void typeCheckPatternBinding(PatternBindingDecl *PBD, unsigned bindingIndex,`
`62`		`- bool leaveClosureBodiesUnchecked);`
	`61`	`+ void typeCheckPatternBinding(PatternBindingDecl *PBD, unsigned bindingIndex);`
`63`	`62`
`64`	`63`	`/// Check if T1 is convertible to T2.`
`65`	`64`	`///`
Original file line number	Diff line number	Diff line change
`@@ -328,8 +328,7 @@ getOperatorCompletionTypes(DeclContext DC, Type LHSType, OperatorDecl Op) {`
`328`	`328`	`llvm_unreachable("unexpected operator kind");`
`329`	`329`	`}`
`330`	`330`
`331`		`- CS.preCheckExpression(OpCallExpr, DC, /replaceInvalidRefsWithErrors=/true,`
`332`		`- /leaveClosureBodyUnchecked=/false);`
	`331`	`+ CS.preCheckExpression(OpCallExpr, DC, /replaceInvalidRefsWithErrors=/true);`
`333`	`332`	`OpCallExpr = CS.generateConstraints(OpCallExpr, DC);`
`334`	`333`
`335`	`334`	`CS.assignFixedType(CS.getType(&LHS)->getAs<TypeVariableType>(), LHSType);`
Original file line number	Diff line number	Diff line change
`@@ -8749,11 +8749,8 @@ namespace {`
`8749`	`8749`	`return true;`
`8750`	`8750`
`8751`	`8751`	`case SolutionApplicationToFunctionResult::Delay: {`
`8752`		`- if (!Rewriter.cs.Options`
`8753`		`- .contains(ConstraintSystemFlags::LeaveClosureBodyUnchecked)) {`
`8754`		`- auto closure = cast<ClosureExpr>(fn.getAbstractClosureExpr());`
`8755`		`- ClosuresToTypeCheck.push_back(closure);`
`8756`		`- }`
	`8752`	`+ auto closure = cast<ClosureExpr>(fn.getAbstractClosureExpr());`
	`8753`	`+ ClosuresToTypeCheck.push_back(closure);`
`8757`	`8754`	`return false;`
`8758`	`8755`	`}`
`8759`	`8756`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10514,8 +10514,7 @@ static bool inferEnumMemberThroughTildeEqualsOperator(`
`10514`	`10514`
`10515`	`10515`	`DiagnosticTransaction diagnostics(ctx.Diags);`
`10516`	`10516`	`{`
`10517`		`- if (cs.preCheckTarget(target, /replaceInvalidRefWithErrors=/true,`
`10518`		`- /leaveClosureBodyUnchecked=/false)) {`
	`10517`	`+ if (cs.preCheckTarget(target, /replaceInvalidRefWithErrors=/true)) {`
`10519`	`10518`	`// Skip diagnostics if they are disabled, otherwise it would result in`
`10520`	`10519`	`// duplicate diagnostics, since this operation is going to be repeated`
`10521`	`10520`	`// in diagnostic mode.`