Use constraint solver results for main resolution

This is effectively reverting #40577.
The mechanism that I tried to use didn't respect `where` clauses on
extensions and, as a result, could select a totally unrelated and
incorrect main function. This results in beautiful explosions in the
rest of the typesystem.

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 *