---

yaml
---
r: 340383
b: refs/heads/rxwei-patch-1
c: 0078422
h: refs/heads/master
i:
  340381: ed8a6d7
  340379: 1fdff37
  340375: 020952d
  340367: cba1b78
  340351: 4dc7c2c

Author: rjmccall

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: 2268939f3b23a040e039bcc75c01c33d5e4aea8d
+refs/heads/rxwei-patch-1: 007842261f06a62c2b6a75bf3c6ea3219aff4971
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSema.def

@@ -4475,6 +4475,10 @@ ERROR(function_builder_parameter_not_of_function_type, none,
       "function builder attribute %0 can only be applied to a parameter of "
       "function type",
       (DeclName))
+ERROR(function_builder_parameter_autoclosure, none,
+      "function builder attribute %0 cannot be applied to an autoclosure "
+      "parameter",
+      (DeclName))
 ERROR(function_builder_multiple, none,
       "only one function builder attribute can be attached to a parameter", ())
 NOTE(previous_function_builder_here, none,

branches/rxwei-patch-1/include/swift/AST/TypeCheckRequests.h

@@ -649,38 +649,22 @@ class AttachedFunctionBuilderRequest :
   void noteCycleStep(DiagnosticEngine &diags) const;
 };
 
-/// Kinds of types for CustomAttr.
-enum class CustomAttrTypeKind {
-  /// The type is required to not be expressed in terms of
-  /// any contextual type parameters.
-  NonGeneric,
-
-  /// Property delegates have some funky rules, like allowing
-  /// unbound generic types.
-  PropertyDelegate,
-};
-
-void simple_display(llvm::raw_ostream &out, CustomAttrTypeKind value);
-
 /// Request the type spelled out in a custom attribute.
 ///
 /// Different parameters cannot be used for the same attribute.
-class CustomAttrTypeRequest :
-    public SimpleRequest<CustomAttrTypeRequest,
+class FunctionBuilderTypeRequest :
+    public SimpleRequest<FunctionBuilderTypeRequest,
                          CacheKind::Cached,
                          Type,
-                         CustomAttr *,
-                         DeclContext *,
-                         CustomAttrTypeKind> {
+                         ParamDecl *> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   llvm::Expected<Type>
-  evaluate(Evaluator &evaluator, CustomAttr *attr, DeclContext *dc,
-           CustomAttrTypeKind typeKind) const;
+  evaluate(Evaluator &evaluator, ParamDecl *param) const;
 
 public:
   // Caching

branches/rxwei-patch-1/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -34,4 +34,4 @@ SWIFT_TYPEID(AttachedPropertyWrapperTypeRequest)
 SWIFT_TYPEID(PropertyWrapperBackingPropertyTypeRequest)
 SWIFT_TYPEID(PropertyWrapperBackingPropertyInfoRequest)
 SWIFT_TYPEID(AttachedFunctionBuilderRequest)
-SWIFT_TYPEID(CustomAttrTypeRequest)
+SWIFT_TYPEID(FunctionBuilderTypeRequest)

branches/rxwei-patch-1/lib/AST/Decl.cpp

@@ -5741,15 +5741,14 @@ void ParamDecl::setStoredProperty(VarDecl *var) {
 }
 
 Type ParamDecl::getFunctionBuilderType() const {
-  auto attr = getAttachedFunctionBuilder();
-  if (!attr) return Type();
+  // Fast path: most parameters do not have any attributes at all,
+  // much less custom ones.
+  if (!getAttrs().hasAttribute<CustomAttr>()) return Type();
 
-  auto mutableAttr = const_cast<CustomAttr*>(attr);
   auto &ctx = getASTContext();
-  auto dc = getDeclContext();
+  auto mutableThis = const_cast<ParamDecl *>(this);
   return evaluateOrDefault(ctx.evaluator,
-                           CustomAttrTypeRequest{mutableAttr, dc,
-                             CustomAttrTypeKind::NonGeneric},
+                           FunctionBuilderTypeRequest{mutableThis},
                            Type());
 }
 

branches/rxwei-patch-1/lib/AST/TypeCheckRequests.cpp

@@ -59,6 +59,20 @@ void swift::simple_display(llvm::raw_ostream &out,
   }
 }
 
+template<>
+bool swift::AnyValue::Holder<Type>::equals(const HolderBase &other) const {
+  assert(typeID == other.typeID && "Caller should match type IDs");
+  return value.getPointer() ==
+  static_cast<const Holder<Type> &>(other).value.getPointer();
+}
+
+void swift::simple_display(llvm::raw_ostream &out, Type type) {
+  if (type)
+    type.print(out);
+  else
+    out << "null";
+}
+
 //----------------------------------------------------------------------------//
 // Inherited type computation.
 //----------------------------------------------------------------------------//
@@ -688,20 +702,6 @@ void swift::simple_display(
   out << " }";
 }
 
-template<>
-bool swift::AnyValue::Holder<Type>::equals(const HolderBase &other) const {
-  assert(typeID == other.typeID && "Caller should match type IDs");
-  return value.getPointer() ==
-  static_cast<const Holder<Type> &>(other).value.getPointer();
-}
-
-void swift::simple_display(llvm::raw_ostream &out, Type type) {
-  if (type)
-    type.print(out);
-  else
-    out << "null";
-}
-
 //----------------------------------------------------------------------------//
 // StructuralTypeRequest.
 //----------------------------------------------------------------------------//
@@ -715,34 +715,7 @@ void StructuralTypeRequest::noteCycleStep(DiagnosticEngine &diags) const {
 }
 
 //----------------------------------------------------------------------------//
-// CustomAttrTypeRequest.
-//----------------------------------------------------------------------------//
-
-void CustomAttrTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
-  auto attr = std::get<0>(getStorage());
-  diags.diagnose(attr->getLocation(), diag::circular_reference);
-}
-
-void CustomAttrTypeRequest::noteCycleStep(DiagnosticEngine &diags) const {
-  auto attr = std::get<0>(getStorage());
-  diags.diagnose(attr->getLocation(), diag::circular_reference_through);
-}
-
-void swift::simple_display(llvm::raw_ostream &out, CustomAttrTypeKind value) {
-  switch (value) {
-  case CustomAttrTypeKind::NonGeneric:
-    out << "non-generic";
-    return;
-
-  case CustomAttrTypeKind::PropertyDelegate:
-    out << "property-delegate";
-    return;
-  }
-  llvm_unreachable("bad kind");
-}
-
-//----------------------------------------------------------------------------//
-// Finding the attached @functionBuilder for a parameter.
+// FunctionBuilder-related requests.
 //----------------------------------------------------------------------------//
 
 bool AttachedFunctionBuilderRequest::isCached() const {
@@ -760,3 +733,11 @@ void AttachedFunctionBuilderRequest::noteCycleStep(
     DiagnosticEngine &diags) const {
   std::get<0>(getStorage())->diagnose(diag::circular_reference_through);
 }
+
+void FunctionBuilderTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
+  std::get<0>(getStorage())->diagnose(diag::circular_reference);
+}
+
+void FunctionBuilderTypeRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  std::get<0>(getStorage())->diagnose(diag::circular_reference_through);
+}

branches/rxwei-patch-1/lib/Sema/TypeCheckAttr.cpp

@@ -2577,17 +2577,6 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
       return;
     }
 
-    // If we can't resolve an interface type here, we should be in invalid
-    // code.
-    Type type = param->getInterfaceType();
-    if (type && !type->is<FunctionType>()) {
-      TC.diagnose(attr->getLocation(),
-                  diag::function_builder_parameter_not_of_function_type,
-                  nominal->getFullName());
-      attr->setInvalid();
-      return;
-    }
-
     // Diagnose and ignore arguments.
     if (attr->getArg()) {
       TC.diagnose(attr->getLocation(), diag::function_builder_arguments)

branches/rxwei-patch-1/lib/Sema/TypeCheckRequestFunctions.cpp

@@ -173,40 +173,53 @@ AttachedFunctionBuilderRequest::evaluate(Evaluator &evaluator,
 }
 
 llvm::Expected<Type>
-CustomAttrTypeRequest::evaluate(Evaluator &evaluator,
-                                CustomAttr *attr, DeclContext *dc,
-                                CustomAttrTypeKind typeKind) const {
-  auto resolution = TypeResolution::forContextual(dc);
-  TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
-
-  // Property delegates allow their type to be an unbound generic.
-  if (typeKind == CustomAttrTypeKind::PropertyDelegate)
-    options |= TypeResolutionFlags::AllowUnboundGenerics;
-
-  ASTContext &ctx = dc->getASTContext();
-  auto &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
-  if (tc.validateType(attr->getTypeLoc(), resolution, options))
-    return ErrorType::get(ctx);
-
-  // We always require the type to resolve to a nominal type.
-  Type type = attr->getTypeLoc().getType();
-  if (!type->getAnyNominal()) {
+FunctionBuilderTypeRequest::evaluate(Evaluator &evaluator,
+                                     ParamDecl *param) const {
+  // Look for a function-builder custom attribute.
+  auto attr = param->getAttachedFunctionBuilder();
+  if (!attr) return Type();
+
+  // Resolve a type for the attribute.
+  auto mutableAttr = const_cast<CustomAttr*>(attr);
+  auto dc = param->getDeclContext();
+  auto &ctx = dc->getASTContext();
+  Type type = resolveCustomAttrType(mutableAttr, dc,
+                                    CustomAttrTypeKind::NonGeneric);
+  if (!type) return Type();
+
+  // The type must not be contextually-dependent.
+  if (type->hasArchetype()) {
+    ctx.Diags.diagnose(attr->getLocation(),
+                       diag::function_builder_type_contextual, type);
+    return Type();
+  }
+
+  auto nominal = type->getAnyNominal();
+  if (!nominal) {
     assert(ctx.Diags.hadAnyError());
-    return ErrorType::get(ctx);
+    return Type();
   }
 
-  switch (typeKind) {
-  case CustomAttrTypeKind::NonGeneric:
-    if (type->hasArchetype()) {
-      ctx.Diags.diagnose(attr->getLocation(),
-                         diag::function_builder_type_contextual, type);
-      return ErrorType::get(ctx);
-    }
-    break;
+  // The parameter had better already have an interface type.
+  Type paramType = param->getInterfaceType();
+  assert(paramType);
+  auto paramFnType = paramType->getAs<FunctionType>();
+
+  // Require the parameter to be an interface type.
+  if (!paramFnType) {
+    ctx.Diags.diagnose(attr->getLocation(),
+                       diag::function_builder_parameter_not_of_function_type,
+                       nominal->getFullName());
+    mutableAttr->setInvalid();
+    return Type();
+  }
 
-  case CustomAttrTypeKind::PropertyDelegate:
-    // No further logic required here.
-    break;
+  if (param->isAutoClosure()) {
+    ctx.Diags.diagnose(attr->getLocation(),
+                       diag::function_builder_parameter_autoclosure,
+                       nominal->getFullName());
+    mutableAttr->setInvalid();
+    return Type();
   }
 
   return type;

branches/rxwei-patch-1/lib/Sema/TypeCheckType.cpp

@@ -3580,3 +3580,27 @@ void TypeChecker::checkUnsupportedProtocolType(GenericParamList *genericParams)
   UnsupportedProtocolVisitor visitor(*this, /*checkStatements=*/false);
   visitor.visitRequirements(genericParams->getRequirements());
 }
+
+Type swift::resolveCustomAttrType(CustomAttr *attr, DeclContext *dc,
+                                  CustomAttrTypeKind typeKind) {
+  auto resolution = TypeResolution::forContextual(dc);
+  TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
+
+  // Property delegates allow their type to be an unbound generic.
+  if (typeKind == CustomAttrTypeKind::PropertyDelegate)
+    options |= TypeResolutionFlags::AllowUnboundGenerics;
+
+  ASTContext &ctx = dc->getASTContext();
+  auto &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
+  if (tc.validateType(attr->getTypeLoc(), resolution, options))
+    return Type();
+
+  // We always require the type to resolve to a nominal type.
+  Type type = attr->getTypeLoc().getType();
+  if (!type->getAnyNominal()) {
+    assert(ctx.Diags.hadAnyError());
+    return Type();
+  }
+
+  return type;
+}

branches/rxwei-patch-1/lib/Sema/TypeCheckType.h

@@ -377,6 +377,21 @@ class TypeResolution {
   bool areSameType(Type type1, Type type2) const;
 };
 
+/// Kinds of types for CustomAttr.
+enum class CustomAttrTypeKind {
+  /// The type is required to not be expressed in terms of
+  /// any contextual type parameters.
+  NonGeneric,
+
+  /// Property delegates have some funky rules, like allowing
+  /// unbound generic types.
+  PropertyDelegate,
+};
+
+/// Attempt to resolve a concrete type for a custom attribute.
+Type resolveCustomAttrType(CustomAttr *attr, DeclContext *dc,
+                           CustomAttrTypeKind typeKind);
+
 } // end namespace swift
 
 #endif /* SWIFT_SEMA_TYPE_CHECK_TYPE_H */

branches/rxwei-patch-1/test/decl/var/function_builders.swift

@@ -44,6 +44,9 @@ func makerParamMissing2(@Maker
 func makerParamExtra(@Maker(5) // expected-error {{function builder attributes cannot have arguments}}
                      fn: () -> ()) {}
 
+func makerParamAutoclosure(@Maker // expected-error {{function builder attribute 'Maker' cannot be applied to an autoclosure parameter}}
+                           fn: @autoclosure () -> ()) {}
+
 @_functionBuilder
 struct GenericMaker<T> {} // expected-note {{generic type 'GenericMaker' declared here}}
 

branches/rxwei-patch-1/test/multifile/Inputs/function_builder_definition.swift

@@ -0,0 +1,26 @@
+@_functionBuilder
+struct TupleBuilder {
+  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)
+  }
+}
+
+func tuplify<T>(@TupleBuilder body: () -> T) -> T {
+  return body()
+}

branches/rxwei-patch-1/test/multifile/function_builder_multifile.swift

@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend -typecheck %S/Inputs/function_builder_definition.swift -primary-file %s
+
+func test0() -> (Int, Float, String) {
+  return tuplify {
+    17
+    3.14159
+    "Hello"
+  }
+}