[TypeCheckEffects] Downgrade missing await to a warning for initializer calls with a single unlabeled parameter

Mitigation for a historic incorrect type-checker behavior
caused by one of the performance hacks that used to favor
sync constructor overload over async one in async context
if initializers take a single unlabeled argument.

```swift
struct S {
  init(_: Int) {}
  init(_: Int) async {}
}

func test(v: Int) async { S(v) }
```

The type-checker should use `init(_: Int) async` in `test` context
but used to select the sync overload. The hack is now gone but we
need to downgrade an error to a warning to give the developers time
to fix their code.

Author: xedin

lib/Sema/TypeCheckEffects.cpp

@@ -1400,6 +1400,29 @@ class ApplyClassifier {
           // then look at all of the closure arguments.
           LLVM_FALLTHROUGH;
         } else {
+          // Mitigation for a historic incorrect type-checker behavior
+          // caused by one of the performance hacks that used to favor
+          // sync constructor overload over async one in async context
+          // if initializers take a single unlabeled argument.
+          //
+          // struct S {
+          //   init(_: Int) {}
+          //   init(_: Int) async {}
+          // }
+          //
+          // func test(v: Int) async { S(v) }
+          //
+          // The type-checker should use `init(_: Int) async` in `test` context
+          // but used to select the sync overload. The hack is now gone but we
+          // need to downgrade an error to a warning to give the developers time
+          // to fix their code.
+          if (kind == EffectKind::Async &&
+              fnRef.getKind() == AbstractFunction::Function) {
+            if (auto *ctor = dyn_cast<ConstructorRefCallExpr>(E->getFn())) {
+              if (ctor->getFn()->isImplicit() && args->isUnlabeledUnary())
+                result.setDowngradeToWarning(true);
+            }
+          }
           break;
         }
 

test/Constraints/async.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift 
+// RUN: %target-typecheck-verify-swift
 
 // REQUIRES: concurrency
 
@@ -197,3 +197,24 @@ func test_sync_in_closure_context() {
     test(42) // Ok (select sync overloads and discards the result)
   }
 }
+
+@available(SwiftStdlib 5.5, *)
+func test_async_calls_in_async_context(v: Int) async {
+  final class Test : Sendable {
+    init(_: Int) {}
+    init(_: Int) async {}
+
+    func test(_: Int) {}
+    func test(_: Int) async {}
+
+    static func test(_: Int) {}
+    static func test(_: Int) async {}
+  }
+
+  // Only implicit `.init` should be accepted with a warning due type-checker previously picking an incorrect overload.
+  _ = Test(v) // expected-warning {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}} expected-note {{call is 'async'}}
+  _ = Test.init(v) // expected-error {{expression is 'async' but is not marked with 'await'}} expected-note {{call is 'async'}}
+
+  Test.test(v) // expected-error {{expression is 'async' but is not marked with 'await'}} expected-note {{call is 'async'}}
+  Test(v).test(v) // expected-error {{expression is 'async' but is not marked with 'await'}} expected-note 2 {{call is 'async'}}
+}