[Revert][Sema] Revert ApplyClassifier changes and add regression test

Author: LucianoPAlmeida

lib/Sema/TypeCheckEffects.cpp

@@ -724,12 +724,6 @@ class ApplyClassifier {
   DeclContext *RethrowsDC = nullptr;
   DeclContext *ReasyncDC = nullptr;
 
-  // Indicates if `classifyApply` will attempt to classify SelfApplyExpr
-  // because that should be done only in certain contexts like when infering
-  // if "async let" implicit auto closure wrapping initialize expression can
-  // throw.
-  bool ClassifySelfApplyExpr = false;
-
   DeclContext *getPolymorphicEffectDeclContext(EffectKind kind) const {
     switch (kind) {
     case EffectKind::Throws: return RethrowsDC;
@@ -758,19 +752,6 @@ class ApplyClassifier {
 
     if (auto *SAE = dyn_cast<SelfApplyExpr>(E)) {
       assert(!E->isImplicitlyAsync());
-
-      if (ClassifySelfApplyExpr) {
-        // Do not consider throw properties in SelfAssignExpr with an implicit
-        // conversion base.
-        if (isa<ImplicitConversionExpr>(SAE->getBase()))
-          return Classification();
-
-        auto fnType = E->getType()->getAs<AnyFunctionType>();
-        if (fnType && fnType->isThrowing()) {
-          return Classification::forUnconditional(
-              EffectKind::Throws, PotentialEffectReason::forApply());
-        }
-      }
       return Classification();
     }
 
@@ -2983,7 +2964,6 @@ void TypeChecker::checkPropertyWrapperEffects(
 
 bool TypeChecker::canThrow(Expr *expr) {
   ApplyClassifier classifier;
-  classifier.ClassifySelfApplyExpr = true;
   return (classifier.classifyExpr(expr, EffectKind::Throws) ==
           ConditionalEffectKind::Always);
 }

test/Concurrency/sr15049.swift

@@ -1,43 +1,45 @@
 // RUN: %target-typecheck-verify-swift -disable-availability-checking -strict-concurrency=targeted
 // REQUIRES: concurrency
 
+// FIXME: Those cases should compile, but currently ApplyClassifier doesn't handle throws/no-throws properly.
+
 func testAsyncSequenceTypedPatternSendable<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int, Seq: Sendable {
-   async let result: Int = seq.reduce(0) { $0 + $1 } // OK
+   async let result: Int = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
    // expected-warning@-1{{immutable value 'result' was never used; consider replacing with '_' or removing it}}
 }
 
 func testAsyncSequenceTypedPattern1Sendable<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int, Seq: Sendable {
-   async let _: Int = seq.reduce(0) { $0 + $1 } // OK
+   async let _: Int = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
 }
 
 func testAsyncSequenceSendable<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int, Seq: Sendable {
-   async let result = seq.reduce(0) { $0 + $1 } // OK
+   async let result = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
    // expected-warning@-1{{initialization of immutable value 'result' was never used; consider replacing with assignment to '_' or removing it}}
 }
 
 func testAsyncSequence1Sendable<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int, Seq: Sendable {
-   async let _ = seq.reduce(0) { $0 + $1 } // OK
+   async let _ = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
 }
 
 func testAsyncSequenceTypedPattern<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int { // expected-note{{consider making generic parameter 'Seq' conform to the 'Sendable' protocol}} {{54-54=, Sendable}}
-   async let result: Int = seq.reduce(0) { $0 + $1 } // OK
+   async let result: Int = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
    // expected-warning@-1{{immutable value 'result' was never used; consider replacing with '_' or removing it}}
    // expected-warning@-2{{capture of 'seq' with non-sendable type 'Seq' in 'async let' binding}}
 }
 
 func testAsyncSequenceTypedPattern1<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int { // expected-note{{consider making generic parameter 'Seq' conform to the 'Sendable' protocol}} {{55-55=, Sendable}}
-   async let _: Int = seq.reduce(0) { $0 + $1 } // OK
+   async let _: Int = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
    // expected-warning@-1{{capture of 'seq' with non-sendable type 'Seq' in 'async let' binding}}
 }
 
 func testAsyncSequence<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int { // expected-note{{consider making generic parameter 'Seq' conform to the 'Sendable' protocol}} {{42-42=, Sendable}}
-   async let result = seq.reduce(0) { $0 + $1 } // OK
+   async let result = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
    // expected-warning@-1{{initialization of immutable value 'result' was never used; consider replacing with assignment to '_' or removing it}}
    // expected-warning@-2{{capture of 'seq' with non-sendable type 'Seq' in 'async let' binding}}
 }
 
 func testAsyncSequence1<Seq: AsyncSequence>(_ seq: Seq) async throws where Seq.Element == Int { // expected-note{{consider making generic parameter 'Seq' conform to the 'Sendable' protocol}} {{43-43=, Sendable}}
-   async let _ = seq.reduce(0) { $0 + $1 } // OK
+   async let _ = seq.reduce(0) { $0 + $1 } // expected-error{{call can throw, but it is executed in a non-throwing autoclosure}} expected-note{{call is to 'rethrows' function, but a conformance has a throwing witness}}
    // expected-warning@-1{{capture of 'seq' with non-sendable type 'Seq' in 'async let' binding}}
 }
 
@@ -49,3 +51,8 @@ func testAsyncSequence3<Seq>(_ seq: Seq) async throws where Seq: AsyncSequence,
 func testAsyncSequence4<Seq>(_ seq: Seq) async throws where Seq: AsyncSequence, Seq.Element == Int { // expected-note{{consider making generic parameter 'Seq' conform to the 'Sendable' protocol}} {{28-28=: Sendable}}
    async let _ = seq // expected-warning{{capture of 'seq' with non-sendable type 'Seq' in 'async let' binding}}
 }
+
+func search(query: String, entities: [String]) async throws -> [String] {
+  async let r = entities.filter { $0.contains(query) }.map { String($0) }
+  return await r // OK
+}