[Function builders] Support buildOptional(_:) in lieu of buildIf(_:).

Line up with the function builders pitch, which uses buildOptional(_:)
to build optional values.

Author: DougGregor

include/swift/AST/KnownIdentifiers.def

@@ -37,6 +37,7 @@ IDENTIFIER(buildEither)
 IDENTIFIER(buildExpression)
 IDENTIFIER(buildFinalResult)
 IDENTIFIER(buildIf)
+IDENTIFIER(buildOptional)
 IDENTIFIER(callAsFunction)
 IDENTIFIER(Change)
 IDENTIFIER_WITH_NAME(code_, "_code")

lib/Sema/BuilderTransform.cpp

@@ -49,6 +49,7 @@ class BuilderClosureVisitor
   ASTContext &ctx;
   Type builderType;
   NominalTypeDecl *builder = nullptr;
+  Identifier buildOptionalId;
   llvm::SmallDenseMap<Identifier, bool> supportedOps;
 
   SkipUnhandledConstructInFunctionBuilder::UnhandledNode unhandledNode;
@@ -201,6 +202,14 @@ class BuilderClosureVisitor
     builder = builderType->getAnyNominal();
     applied.builderType = builderType;
     applied.bodyResultType = bodyResultType;
+
+    // Use buildOptional(_:) if available, otherwise fall back to buildIf
+    // when available.
+    if (builderSupports(ctx.Id_buildOptional) ||
+        !builderSupports(ctx.Id_buildIf))
+      buildOptionalId = ctx.Id_buildOptional;
+    else
+      buildOptionalId = ctx.Id_buildIf;
   }
 
   /// Apply the builder transform to the given statement.
@@ -416,8 +425,8 @@ class BuilderClosureVisitor
     if (!isBuildableIfChainRecursive(ifStmt, numPayloads, isOptional))
       return false;
 
-    // If there's a missing 'else', we need 'buildIf' to exist.
-    if (isOptional && !builderSupports(ctx.Id_buildIf))
+    // If there's a missing 'else', we need 'buildOptional' to exist.
+    if (isOptional && !builderSupports(buildOptionalId))
       return false;
 
     // If there are multiple clauses, we need 'buildEither(first:)' and
@@ -523,9 +532,9 @@ class BuilderClosureVisitor
     // The operand should have optional type if we had optional results,
     // so we just need to call `buildIf` now, since we're at the top level.
     if (isOptional && isTopLevel) {
-      thenExpr = buildCallIfWanted(ifStmt->getEndLoc(), ctx.Id_buildIf,
+      thenExpr = buildCallIfWanted(ifStmt->getEndLoc(), buildOptionalId,
                                    thenExpr,  /*argLabels=*/{ });
-      elseExpr = buildCallIfWanted(ifStmt->getEndLoc(), ctx.Id_buildIf,
+      elseExpr = buildCallIfWanted(ifStmt->getEndLoc(), buildOptionalId,
                                    elseExpr,  /*argLabels=*/{ });
     }
 

test/Constraints/function_builder.swift

@@ -617,3 +617,50 @@ testSwitchCombined(getE(1))
 // CHECK: testSwitchCombined
 // CHECK-SAME: second("just 42")
 testSwitchCombined(getE(2))
+
+
+// Test buildOptional(_:) as an alternative to buildIf(_:).
+@_functionBuilder
+struct TupleBuilderWithOpt {
+  static func buildBlock<T1>(_ t1: T1) -> (T1) {
+    return (t1)
+  }
+
+  static func buildBlock<T1, T2>(_ t1: T1, _ t2: T2) -> (T1, T2) {
+    return (t1, t2)
+  }
+  
+  static func buildBlock<T1, T2, T3>(_ t1: T1, _ t2: T2, _ t3: T3)
+      -> (T1, T2, T3) {
+    return (t1, t2, t3)
+  }
+
+  static func buildBlock<T1, T2, T3, T4>(_ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4)
+      -> (T1, T2, T3, T4) {
+    return (t1, t2, t3, t4)
+  }
+
+  static func buildBlock<T1, T2, T3, T4, T5>(
+    _ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4, _ t5: T5
+  ) -> (T1, T2, T3, T4, T5) {
+    return (t1, t2, t3, t4, t5)
+  }
+
+  static func buildDo<T>(_ value: T) -> T { return value }
+  static func buildOptional<T>(_ value: T?) -> T? { return value }
+
+  static func buildEither<T,U>(first value: T) -> Either<T,U> {
+    return .first(value)
+  }
+  static func buildEither<T,U>(second value: U) -> Either<T,U> {
+    return .second(value)
+  }
+}
+
+func tuplifyWithOpt<T>(_ cond: Bool, @TupleBuilderWithOpt body: (Bool) -> T) {
+  print(body(cond))
+}
+tuplifyWithOpt(true) { c in
+  "1"
+  3.14159
+}