Merge pull request #41573 from etcwilde/ewilde/revert-async-main-resolution

Revert async-main lookup resolution

Author: etcwilde

lib/Sema/TypeCheckAttr.cpp

@@ -2018,65 +2018,23 @@ synthesizeMainBody(AbstractFunctionDecl *fn, void *arg) {
 static FuncDecl *resolveMainFunctionDecl(DeclContext *declContext,
                                          ResolvedMemberResult &resolution,
                                          ASTContext &ctx) {
-  // The normal resolution mechanism won't choose the asynchronous main function
-  // unless no other options are available because extensions and generic types
-  // (structs/classes) are not considered asynchronous contexts.
-  // We want them to be promoted to a viable entrypoint if the deployment target
-  // is high enough.
-  SmallVector<FuncDecl *, 4> viableCandidates;
-  for (ValueDecl *candidate : resolution.getMemberDecls(Viable)) {
-    if (FuncDecl *function = dyn_cast<FuncDecl>(candidate)) {
-      if (function->isMainTypeMainMethod())
-        viableCandidates.push_back(function);
+  // Choose the best overload if it's a main function
+  if (resolution.hasBestOverload()) {
+    ValueDecl *best = resolution.getBestOverload();
+    if (FuncDecl *func = dyn_cast<FuncDecl>(best)) {
+      if (func->isMainTypeMainMethod()) {
+        return func;
+      }
     }
   }
-  if (viableCandidates.empty()) {
-    return nullptr;
-  }
-
-  AvailabilityContext contextAvailability =
-      AvailabilityContext::forDeploymentTarget(ctx);
-  const bool hasAsyncSupport = contextAvailability.isContainedIn(
-      ctx.getBackDeployedConcurrencyAvailability());
-
-  FuncDecl *best = nullptr;
-  for (FuncDecl *candidate : viableCandidates) {
-    // The candidate will work if it's synchronous, or if we support concurrency
-    // and it is async, or if we are in YOLO mode
-    const bool candidateWorks = !candidate->hasAsync() ||
-                                (hasAsyncSupport && candidate->hasAsync()) ||
-                                ctx.LangOpts.DisableAvailabilityChecking;
-
-    // Skip it if it won't work
-    if (!candidateWorks)
-      continue;
-
-    // If we don't have a best, the candidate is the best so far
-    if (!best) {
-      best = candidate;
-      continue;
+  // Look for the most highly-ranked main-function candidate
+  for (ValueDecl *candidate : resolution.getMemberDecls(Viable)) {
+    if (FuncDecl *func = dyn_cast<FuncDecl>(candidate)) {
+      if (func->isMainTypeMainMethod())
+        return func;
     }
-
-    // If the candidate is better and it's synchronous, just swap it right in.
-    // If the candidate is better and it's async, make sure we support async
-    // before selecting it.
-    //
-    // If it's unordered (equally bestest), use the async version if we support
-    // it or use the sync version if we don't.
-    const Comparison rank =
-        TypeChecker::compareDeclarations(declContext, candidate, best);
-    const bool isBetter = rank == Comparison::Better;
-    const bool isUnordered = rank == Comparison::Unordered;
-    const bool swapForAsync =
-        hasAsyncSupport && candidate->hasAsync() && !best->hasAsync();
-    const bool swapForSync =
-        !hasAsyncSupport && !candidate->hasAsync() && best->hasAsync();
-    const bool selectCandidate =
-        isBetter || (isUnordered && (swapForAsync || swapForSync));
-    if (selectCandidate)
-      best = candidate;
-  }
-  return best;
+  }
+  return nullptr;
 }
 
 FuncDecl *

test/Concurrency/async_main_resolution.swift

@@ -6,6 +6,8 @@
 // sync main is nested deeper in protocols than async, use async
 // async and sync are same level, use async
 
+// REQUIRES: rdar89500797
+
 // REQUIRES: concurrency
 // UNSUPPORTED: VENDOR=apple
 

test/Concurrency/async_main_resolution_macos.swift

@@ -2,6 +2,8 @@
 // sync main is nested deeper in protocols than async, use async if supported
 // async and sync are same level, use async if supported
 
+// REQUIRES: rdar89500797
+
 // async main is nested in the protocol chain from `MyMain`
 // Always choose Sync overload
 // RUN: %target-swift-frontend -target x86_64-apple-macosx10.9 -DASYNC_NESTED -DINHERIT_SYNC -typecheck -dump-ast -parse-as-library %s | %FileCheck %s --check-prefix=CHECK-IS-SYNC

test/Concurrency/where_clause_main_resolution.swift

@@ -0,0 +1,45 @@
+// RUN: %target-swift-frontend -disable-availability-checking -D CONFIG1 -dump-ast -parse-as-library %s | %FileCheck %s --check-prefix=CHECK-CONFIG1
+// RUN: %target-swift-frontend -disable-availability-checking -D CONFIG2 -dump-ast -parse-as-library %s | %FileCheck %s --check-prefix=CHECK-CONFIG2
+// RUN: %target-swift-frontend -disable-availability-checking -D CONFIG3 -dump-ast -parse-as-library %s | %FileCheck %s --check-prefix=CHECK-CONFIG3
+
+// REQUIRES: concurrency
+
+protocol AppConfiguration { }
+
+struct Config1: AppConfiguration {}
+struct Config2: AppConfiguration {}
+struct Config3: AppConfiguration {}
+
+protocol App {
+    associatedtype Configuration: AppConfiguration
+}
+
+extension App where Configuration == Config1 {
+// CHECK-CONFIG1: (func_decl implicit "$main()" interface type='(MainType.Type) -> () -> ()'
+// CHECK-CONFIG1: where_clause_main_resolution.swift:[[# @LINE+1 ]]
+    static func main() { }
+}
+
+extension App where Configuration == Config2 {
+// CHECK-CONFIG2: (func_decl implicit "$main()" interface type='(MainType.Type) -> () async -> ()'
+// CHECK-CONFIG2: where_clause_main_resolution.swift:[[# @LINE+1 ]]
+    static func main() async { }
+}
+
+extension App {
+// CHECK-CONFIG3: (func_decl implicit "$main()" interface type='(MainType.Type) -> () async -> ()'
+// CHECK-CONFIG3: where_clause_main_resolution.swift:[[# @LINE+1 ]]
+    static func main() async { }
+}
+
+@main
+struct MainType : App {
+
+#if CONFIG1
+    typealias Configuration = Config1
+#elseif CONFIG2
+    typealias Configuration = Config2
+#elseif CONFIG3
+    typealias Configuration = Config3
+#endif
+}