[ConstraintSystem] Integrate IgnoreInvalidFunctionBuilderBody into the solver

Author: xedin

lib/Sema/BuilderTransform.cpp

@@ -1622,16 +1622,23 @@ ConstraintSystem::matchFunctionBuilder(
   // Pre-check the body: pre-check any expressions in it and look
   // for return statements.
   auto request =
-      PreCheckFunctionBuilderRequest{{fn, /*SuppressDiagnostics=*/false}};
+      PreCheckFunctionBuilderRequest{{fn, /*SuppressDiagnostics=*/true}};
   switch (evaluateOrDefault(getASTContext().evaluator, request,
                             FunctionBuilderBodyPreCheck::Error)) {
   case FunctionBuilderBodyPreCheck::Okay:
     // If the pre-check was okay, apply the function-builder transform.
     break;
 
-  case FunctionBuilderBodyPreCheck::Error:
-    // If the pre-check had an error, flag that.
-    return getTypeMatchFailure(locator);
+  case FunctionBuilderBodyPreCheck::Error: {
+    if (!shouldAttemptFixes())
+      return getTypeMatchFailure(locator);
+
+    if (recordFix(IgnoreInvalidFunctionBuilderBody::create(
+            *this, getConstraintLocator(fn.getBody()))))
+      return getTypeMatchFailure(locator);
+
+    return getTypeMatchSuccess();
+  }
 
   case FunctionBuilderBodyPreCheck::HasReturnStmt:
     // If the body has a return statement, suppress the transform but

lib/Sema/CSBindings.cpp

@@ -1206,7 +1206,14 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
       } else if (TypeVar->getImpl().isClosureParameterType()) {
         fix = SpecifyClosureParameterType::create(cs, dstLocator);
       } else if (TypeVar->getImpl().isClosureResultType()) {
-        fix = SpecifyClosureReturnType::create(cs, dstLocator);
+        auto *locator = TypeVar->getImpl().getLocator();
+        auto *closure = castToExpr<ClosureExpr>(locator->getAnchor());
+        // If the whole body is being ignored due to a pre-check failure,
+        // let's not record a fix about result type since there is
+        // just not enough context to infer it without a body.
+        if (!cs.hasFixFor(cs.getConstraintLocator(closure->getBody()),
+                          FixKind::IgnoreInvalidFunctionBuilderBody))
+          fix = SpecifyClosureReturnType::create(cs, dstLocator);
       } else if (srcLocator->directlyAt<ObjectLiteralExpr>()) {
         fix = SpecifyObjectLiteralTypeImport::create(cs, dstLocator);
       } else if (srcLocator->isKeyPathRoot()) {

test/Constraints/function_builder_diags.swift

@@ -6,7 +6,7 @@ enum Either<T,U> {
 }
 
 @_functionBuilder
-struct TupleBuilder { // expected-note 3{{struct 'TupleBuilder' declared here}}
+struct TupleBuilder { // expected-note 2 {{struct 'TupleBuilder' declared here}}
   static func buildBlock() -> () { }
 
   static func buildBlock<T1>(_ t1: T1) -> T1 {
@@ -87,7 +87,7 @@ func testDiags() {
   // For loop
   tuplify(true) { _ in
     17
-    for c in name { // expected-error{{closure containing control flow statement cannot be used with function builder 'TupleBuilder'}}
+    for c in name {
     // expected-error@-1 {{cannot find 'name' in scope}}
     }
   }
@@ -418,13 +418,16 @@ func testNonExhaustiveSwitch(e: E) {
 // rdar://problem/59856491
 struct TestConstraintGenerationErrors {
   @TupleBuilder var buildTupleFnBody: String {
-    let a = nil // expected-error {{'nil' requires a contextual type}}
+    let a = nil // There is no diagnostic here because next line fails to pre-check, so body is invalid
     String(nothing) // expected-error {{cannot find 'nothing' in scope}}
   }
 
+  @TupleBuilder var nilWithoutContext: String {
+    let a = nil // expected-error {{'nil' requires a contextual type}}
+  }
+
   func buildTupleClosure() {
-    // FIXME: suppress the ambiguity error
-    tuplify(true) { _ in // expected-error {{type of expression is ambiguous without more context}}
+    tuplify(true) { _ in
       let a = nothing // expected-error {{cannot find 'nothing' in scope}}
       String(nothing) // expected-error {{cannot find 'nothing' in scope}}
     }

test/Constraints/rdar65320500.swift

@@ -0,0 +1,43 @@
+// RUN: %target-typecheck-verify-swift
+
+struct Result {}
+
+@_functionBuilder
+struct Builder {
+  static func buildBlock() -> Result {
+    Result()
+  }
+}
+
+func test_builder<T>(@Builder _: () -> T) {}
+func test_builder(@Builder _: () -> Int) {}
+
+test_builder {
+  let _ = 0
+
+  if let x = does_not_exist { // expected-error {{cannot find 'does_not_exist' in scope}}
+  }
+}
+
+func test(_: Int) -> Bool {
+  return false
+}
+
+test_builder {
+  let totalSeconds = 42000
+  test(totalseconds / 3600) // expected-error {{cannot find 'totalseconds' in scope}}
+}
+
+test_builder {
+  test(doesntExist()) // expected-error {{cannot find 'doesntExist' in scope}}
+
+  if let result = doesntExist() { // expected-error {{cannot find 'doesntExist' in scope}}
+  }
+
+  if bar = test(42) {} // expected-error {{cannot find 'bar' in scope}}
+
+  let foo = bar() // expected-error {{cannot find 'bar' in scope}}
+
+  switch (doesntExist()) { // expected-error {{cannot find 'doesntExist' in scope}}
+  }
+}