Merge pull request #32893 from CodaFi/build-a-bear

Fix a Source Break With Function Builders

Author: CodaFi

lib/Sema/BuilderTransform.cpp

@@ -80,10 +80,21 @@ class BuilderClosureVisitor
     auto simplifiedTy = cs->simplifyType(builderType);
     if (!simplifiedTy->hasTypeVariable()) {
       typeExpr = TypeExpr::createImplicitHack(loc, simplifiedTy, ctx);
+    } else if (auto *decl = simplifiedTy->getAnyGeneric()) {
+      // HACK: If there's not enough information to completely resolve the
+      // builder type, but we have the base available to us, form an *explicit*
+      // TypeExpr pointing at it. We cannot form an implicit base without
+      // a fully-resolved concrete type. Really, whatever we put here has no
+      // bearing on the generated solution because we're going to use this node
+      // to stash the builder type and hand it back to the ambient
+      // constraint system.
+      typeExpr = TypeExpr::createForDecl(DeclNameLoc(loc), decl, dc);
     } else {
       // HACK: If there's not enough information in the constraint system,
       // create a garbage base type to force it to diagnose
       // this as an ambiguous expression.
+      // FIXME: We can also construct an UnresolvedMemberExpr here instead of
+      // an UnresolvedDotExpr and get a slightly better diagnostic.
       typeExpr = TypeExpr::createImplicitHack(loc, ErrorType::get(ctx), ctx);
     }
     cs->setType(typeExpr, MetatypeType::get(builderType));

lib/Sema/CSGen.cpp

@@ -1472,6 +1472,13 @@ namespace {
         type = CS.getInstanceType(CS.cacheType(E));
         assert(type && "Implicit type expr must have type set!");
         type = CS.openUnboundGenericTypes(type, locator);
+      } else if (CS.hasType(E)) {
+        // If there's a type already set into the constraint system, honor it.
+        // FIXME: This supports the function builder transform, which sneakily
+        // stashes a type in the constraint system through a TypeExpr in order
+        // to pass it down to the rest of CSGen. This is a terribly
+        // unprincipled thing to do.
+        return CS.getType(E);
       } else {
         auto *repr = E->getTypeRepr();
         assert(repr && "Explicit node has no type repr!");

test/Constraints/rdar64890308.swift

@@ -13,8 +13,7 @@ class ArrayBuilder<Element> {
 
 func foo<T>(@ArrayBuilder<T> fn: () -> [T]) {}
 
-// FIXME(SR-13132): This should compile.
-foo { // expected-error {{type of expression is ambiguous without more context}}
+foo {
   ""
 }
 
@@ -29,3 +28,20 @@ func bar<T>(_ x: T, _ fn: (T, T.Type) -> [T]) {}
 bar("") { x, ty in
   (Builtin.one_way(S(ty).overloaded(x)))
 }
+
+protocol P {}
+extension String : P {}
+
+@_functionBuilder
+struct FooBuilder<T> {}
+
+extension FooBuilder where T : P {
+  static func buildBlock(_ x: Int, _ y: Int) -> String { "" }
+}
+
+func foo<T : P>(@FooBuilder<T> fn: () -> T) {}
+
+foo {
+  0
+  0
+}