Merge pull request #62096 from hamishknight/multifunction

Author: hamishknight

include/swift/Sema/CSBindings.h

@@ -480,6 +480,9 @@ class BindingSet {
   /// if it has only concrete types or would resolve a closure.
   bool favoredOverDisjunction(Constraint *disjunction) const;
 
+  /// Check if this binding is favored over a conjunction.
+  bool favoredOverConjunction(Constraint *conjunction) const;
+
   /// Detect `subtype` relationship between two type variables and
   /// attempt to infer supertype bindings transitively e.g.
   ///

lib/Sema/BuilderTransform.cpp

@@ -1000,73 +1000,85 @@ class ResultBuilderTransform
     return failTransform(stmt);                                                \
   }
 
-  std::pair<NullablePtr<VarDecl>, Optional<UnsupportedElt>>
-  transform(BraceStmt *braceStmt, SmallVectorImpl<ASTNode> &newBody) {
-    SmallVector<Expr *, 4> buildBlockArguments;
-
-    auto failTransform = [&](UnsupportedElt unsupported) {
-      return std::make_pair(nullptr, unsupported);
-    };
-
-    for (auto element : braceStmt->getElements()) {
-      if (auto *returnStmt = getAsStmt<ReturnStmt>(element)) {
-        assert(returnStmt->isImplicit());
-        element = returnStmt->getResult();
-      }
-
-      if (auto *decl = element.dyn_cast<Decl *>()) {
-        switch (decl->getKind()) {
+  /// Visit the element of a brace statement, returning \c None if the element
+  /// was transformed successfully, or an unsupported element if the element
+  /// cannot be handled.
+  Optional<UnsupportedElt>
+  transformBraceElement(ASTNode element, SmallVectorImpl<ASTNode> &newBody,
+                        SmallVectorImpl<Expr *> &buildBlockArguments) {
+    if (auto *returnStmt = getAsStmt<ReturnStmt>(element)) {
+      assert(returnStmt->isImplicit());
+      element = returnStmt->getResult();
+    }
+
+    if (auto *decl = element.dyn_cast<Decl *>()) {
+      switch (decl->getKind()) {
         // Just ignore #if; the chosen children should appear in
         // the surrounding context.  This isn't good for source
         // tools but it at least works.
-        case DeclKind::IfConfig:
+      case DeclKind::IfConfig:
         // Skip #warning/#error; we'll handle them when applying
         // the builder.
-        case DeclKind::PoundDiagnostic:
-        case DeclKind::PatternBinding:
-        case DeclKind::Var:
-        case DeclKind::Param:
-          newBody.push_back(element);
-          break;
-
-        default:
-          return failTransform(decl);
-        }
+      case DeclKind::PoundDiagnostic:
+      case DeclKind::PatternBinding:
+      case DeclKind::Var:
+      case DeclKind::Param:
+        newBody.push_back(element);
+        return None;
+
+      default:
+        return UnsupportedElt(decl);
+      }
+      llvm_unreachable("Unhandled case in switch!");
+    }
 
-        continue;
+    if (auto *stmt = element.dyn_cast<Stmt *>()) {
+      // Throw is allowed as is.
+      if (auto *throwStmt = dyn_cast<ThrowStmt>(stmt)) {
+        newBody.push_back(throwStmt);
+        return None;
       }
 
-      if (auto *stmt = element.dyn_cast<Stmt *>()) {
-        // Throw is allowed as is.
-        if (auto *throwStmt = dyn_cast<ThrowStmt>(stmt)) {
-          newBody.push_back(throwStmt);
-          continue;
-        }
+      // Allocate variable with a placeholder type
+      auto *resultVar = buildPlaceholderVar(stmt->getStartLoc(), newBody);
 
-        // Allocate variable with a placeholder type
-        auto *resultVar = buildPlaceholderVar(stmt->getStartLoc(), newBody);
+      auto result = visit(stmt, resultVar);
+      if (!result)
+        return UnsupportedElt(stmt);
 
-        auto result = visit(stmt, resultVar);
-        if (!result)
-          return failTransform(stmt);
+      newBody.push_back(result.get());
+      buildBlockArguments.push_back(
+          builder.buildVarRef(resultVar, stmt->getStartLoc()));
+      return None;
+    }
 
-        newBody.push_back(result.get());
-        buildBlockArguments.push_back(
-            builder.buildVarRef(resultVar, stmt->getStartLoc()));
-        continue;
-      }
+    auto *expr = element.get<Expr *>();
+    if (builder.supports(ctx.Id_buildExpression)) {
+      expr = builder.buildCall(expr->getLoc(), ctx.Id_buildExpression, {expr},
+                               {Identifier()});
+    }
 
-      auto *expr = element.get<Expr *>();
-      if (builder.supports(ctx.Id_buildExpression)) {
-        expr = builder.buildCall(expr->getLoc(), ctx.Id_buildExpression, {expr},
-                                 {Identifier()});
-      }
+    auto *capture = captureExpr(expr, newBody);
+    // A reference to the synthesized variable is passed as an argument
+    // to buildBlock.
+    buildBlockArguments.push_back(
+        builder.buildVarRef(capture, element.getStartLoc()));
+    return None;
+  }
 
-      auto *capture = captureExpr(expr, newBody);
-      // A reference to the synthesized variable is passed as an argument
-      // to buildBlock.
-      buildBlockArguments.push_back(
-          builder.buildVarRef(capture, element.getStartLoc()));
+  std::pair<NullablePtr<VarDecl>, Optional<UnsupportedElt>>
+  transform(BraceStmt *braceStmt, SmallVectorImpl<ASTNode> &newBody) {
+    SmallVector<Expr *, 4> buildBlockArguments;
+
+    auto failTransform = [&](UnsupportedElt unsupported) {
+      return std::make_pair(nullptr, unsupported);
+    };
+
+    for (auto element : braceStmt->getElements()) {
+      if (auto unsupported =
+              transformBraceElement(element, newBody, buildBlockArguments)) {
+        return failTransform(*unsupported);
+      }
     }
 
     // Synthesize `buildBlock` or `buildPartial` based on captured arguments.

lib/Sema/CMakeLists.txt

@@ -3,7 +3,7 @@ add_swift_host_library(swiftSema STATIC
   BuilderTransform.cpp
   CSApply.cpp
   CSBindings.cpp
-  CSClosure.cpp
+  CSSyntacticElement.cpp
   CSGen.cpp
   CSRanking.cpp
   CSSimplify.cpp

lib/Sema/CSBindings.cpp

@@ -1065,6 +1065,14 @@ bool BindingSet::favoredOverDisjunction(Constraint *disjunction) const {
   return !involvesTypeVariables();
 }
 
+bool BindingSet::favoredOverConjunction(Constraint *conjunction) const {
+  if (CS.shouldAttemptFixes() && isHole()) {
+    if (forClosureResult() || forGenericParameter())
+      return false;
+  }
+  return true;
+}
+
 BindingSet ConstraintSystem::getBindingsFor(TypeVariableType *typeVar,
                                             bool finalize) {
   assert(typeVar->getImpl().getRepresentative(nullptr) == typeVar &&

lib/Sema/CSStep.cpp

@@ -359,6 +359,7 @@ StepResult ComponentStep::take(bool prevFailed) {
   });
 
   auto *disjunction = CS.selectDisjunction();
+  auto *conjunction = CS.selectConjunction();
 
   if (CS.isDebugMode()) {
     if (!potentialBindings.empty()) {
@@ -393,33 +394,45 @@ StepResult ComponentStep::take(bool prevFailed) {
     }
   }
 
-  if (CS.shouldAttemptFixes()) {
-    if ((bestBindings &&
-         (bestBindings->forClosureResult() ||
-          bestBindings->forGenericParameter()) &&
-         bestBindings->isHole()) &&
-        !disjunction) {
-      if (auto *conjunction = CS.selectConjunction()) {
-        return suspend(
-            std::make_unique<ConjunctionStep>(CS, conjunction, Solutions));
-      }
+  enum class StepKind { Binding, Disjunction, Conjunction };
+
+  auto chooseStep = [&]() -> Optional<StepKind> {
+    // Bindings usually happen first, but sometimes we want to prioritize a
+    // disjunction or conjunction.
+    if (bestBindings) {
+      if (disjunction && !bestBindings->favoredOverDisjunction(disjunction))
+        return StepKind::Disjunction;
+
+      if (conjunction && !bestBindings->favoredOverConjunction(conjunction))
+        return StepKind::Conjunction;
+
+      return StepKind::Binding;
+    }
+    if (disjunction)
+      return StepKind::Disjunction;
+
+    if (conjunction)
+      return StepKind::Conjunction;
+
+    return None;
+  };
+
+  if (auto step = chooseStep()) {
+    switch (*step) {
+    case StepKind::Binding:
+      return suspend(
+          std::make_unique<TypeVariableStep>(*bestBindings, Solutions));
+    case StepKind::Disjunction:
+      return suspend(
+          std::make_unique<DisjunctionStep>(CS, disjunction, Solutions));
+    case StepKind::Conjunction:
+      return suspend(
+          std::make_unique<ConjunctionStep>(CS, conjunction, Solutions));
     }
+    llvm_unreachable("Unhandled case in switch!");
   }
 
-  if (bestBindings &&
-      (!disjunction || bestBindings->favoredOverDisjunction(disjunction))) {
-    // Produce a type variable step.
-    return suspend(
-        std::make_unique<TypeVariableStep>(*bestBindings, Solutions));
-  } else if (disjunction) {
-    // Produce a disjunction step.
-    return suspend(
-        std::make_unique<DisjunctionStep>(CS, disjunction, Solutions));
-  } else if (auto *conjunction = CS.selectConjunction()) {
-    return suspend(
-        std::make_unique<ConjunctionStep>(CS, conjunction, Solutions));
-  } else if (!CS.solverState->allowsFreeTypeVariables() &&
-             CS.hasFreeTypeVariables()) {
+  if (!CS.solverState->allowsFreeTypeVariables() && CS.hasFreeTypeVariables()) {
     // If there are no disjunctions or type variables to bind
     // we can't solve this system unless we have free type variables
     // allowed in the solution.