Merge pull request swiftlang#25221 from rjmccall/function-builders

Preliminary support for function builders

Author: rjmccall

include/swift/AST/ASTTypeIDs.h

@@ -27,6 +27,7 @@ struct PropertyWrapperTypeInfo;
 class Type;
 class VarDecl;
 class TypeAliasDecl;
+class Type;
 
 #define SWIFT_AST_TYPEID_ZONE 1
 

include/swift/AST/Attr.def

@@ -407,6 +407,9 @@ SIMPLE_DECL_ATTR(_propertyWrapper, PropertyWrapper,
 SIMPLE_DECL_ATTR(_disfavoredOverload, DisfavoredOverload,
   OnAbstractFunction | OnVar | OnSubscript | UserInaccessible,
   87)
+SIMPLE_DECL_ATTR(_functionBuilder, FunctionBuilder,
+  OnNominalType,
+  88)
 
 SIMPLE_DECL_ATTR(IBSegueAction, IBSegueAction,
   OnFunc,

include/swift/AST/Decl.h

@@ -2709,6 +2709,14 @@ class ValueDecl : public Decl {
   /// `this` must be of a decl type that supports opaque return types, and
   /// must not have previously had an opaque result type set.
   void setOpaqueResultTypeDecl(OpaqueTypeDecl *D);
+
+  /// Retrieve the attribute associating this declaration with a
+  /// function builder, if there is one.
+  CustomAttr *getAttachedFunctionBuilder() const;
+
+  /// Retrieve the @functionBuilder type attached to this declaration,
+  /// if there is one.
+  Type getFunctionBuilderType() const;
 };
 
 /// This is a common base class for declarations which declare a type.
@@ -5334,7 +5342,7 @@ class ParamDecl : public VarDecl {
     assert(isVariadic());
     return getVarargBaseTy(getInterfaceType());
   }
-  
+
   SourceRange getSourceRange() const;
 
   AnyFunctionType::Param toFunctionParam(Type type = Type()) const;

include/swift/AST/DiagnosticsSema.def

@@ -4463,6 +4463,44 @@ ERROR(property_wrapper_type_not_usable_from_inline,none,
       "must be '@usableFromInline' or public",
       (bool, bool))
 
+//------------------------------------------------------------------------------
+// MARK: function builder diagnostics
+//------------------------------------------------------------------------------
+ERROR(function_builder_decl, none,
+      "closure containing a declaration cannot be used with function "
+      "builder %0", (DeclName))
+NOTE(note_function_builder_decl, none,
+      "closure containing a declaration cannot be used with function "
+      "builder %0", (DeclName))
+ERROR(function_builder_control_flow, none,
+      "closure containing control flow statement cannot be used with function "
+      "builder %0", (DeclName))
+NOTE(note_function_builder_control_flow, none,
+      "closure containing control flow statement cannot be used with function "
+      "builder %0", (DeclName))
+ERROR(function_builder_attribute_not_allowed_here, none,
+      "function builder attribute %0 can only be applied to a parameter, "
+      "function, or computed property", (DeclName))
+ERROR(function_builder_attribute_on_storage_without_getter, none,
+      "function builder attribute %0 can only be applied to a "
+      "%select{subscript|property|constant|variable}1 if it defines a getter",
+      (DeclName, unsigned))
+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 "
+      "%select{declaration|parameter}0", (bool))
+NOTE(previous_function_builder_here, none,
+     "previous function builder specified here", ())
+ERROR(function_builder_arguments, none,
+      "function builder attributes cannot have arguments", ())
+
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

include/swift/AST/KnownIdentifiers.def

@@ -31,6 +31,10 @@ IDENTIFIER(Any)
 IDENTIFIER(ArrayLiteralElement)
 IDENTIFIER(atIndexedSubscript)
 IDENTIFIER_(bridgeToObjectiveC)
+IDENTIFIER(buildBlock)
+IDENTIFIER(buildDo)
+IDENTIFIER(buildEither)
+IDENTIFIER(buildIf)
 IDENTIFIER(Change)
 IDENTIFIER_WITH_NAME(code_, "_code")
 IDENTIFIER(CodingKeys)
@@ -59,6 +63,7 @@ IDENTIFIER(Encoder)
 IDENTIFIER(encoder)
 IDENTIFIER(error)
 IDENTIFIER(errorDomain)
+IDENTIFIER(first)
 IDENTIFIER(forKeyedSubscript)
 IDENTIFIER(Foundation)
 IDENTIFIER(for)
@@ -93,6 +98,7 @@ IDENTIFIER(parameter)
 IDENTIFIER(Protocol)
 IDENTIFIER(rawValue)
 IDENTIFIER(RawValue)
+IDENTIFIER(second)
 IDENTIFIER(Selector)
 IDENTIFIER(self)
 IDENTIFIER(Self)

include/swift/AST/TypeCheckRequests.h

@@ -35,6 +35,7 @@ class RequirementRepr;
 class SpecializeAttr;
 class TypeAliasDecl;
 struct TypeLoc;
+class ValueDecl;
 
 /// Display a nominal type or extension thereof.
 void simple_display(
@@ -622,6 +623,57 @@ class StructuralTypeRequest :
   bool isCached() const { return true; }
 };
 
+/// Request the custom attribute which attaches a function builder to the
+/// given declaration.
+class AttachedFunctionBuilderRequest :
+    public SimpleRequest<AttachedFunctionBuilderRequest,
+                         CacheKind::Cached,
+                         CustomAttr *,
+                         ValueDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<CustomAttr *>
+  evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  // Caching
+  bool isCached() const;
+
+  // Cycle handling
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+};
+
+/// Request the function builder type attached to the given declaration,
+/// if any.
+class FunctionBuilderTypeRequest :
+    public SimpleRequest<FunctionBuilderTypeRequest,
+                         CacheKind::Cached,
+                         Type,
+                         ValueDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  llvm::Expected<Type>
+  evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+
+  // Cycle handling
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>
@@ -631,7 +683,7 @@ inline bool AnyValue::Holder<Type>::equals(const HolderBase &other) const {
       static_cast<const Holder<Type> &>(other).value.getPointer();
 }
 
-void simple_display(llvm::raw_ostream &out, const Type &type);
+void simple_display(llvm::raw_ostream &out, Type value);
 
 /// The zone number for the type checker.
 #define SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE 10

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -33,3 +33,5 @@ SWIFT_TYPEID(AttachedPropertyWrapperRequest)
 SWIFT_TYPEID(AttachedPropertyWrapperTypeRequest)
 SWIFT_TYPEID(PropertyWrapperBackingPropertyTypeRequest)
 SWIFT_TYPEID(PropertyWrapperBackingPropertyInfoRequest)
+SWIFT_TYPEID(AttachedFunctionBuilderRequest)
+SWIFT_TYPEID(FunctionBuilderTypeRequest)

include/swift/AST/Types.h

@@ -3113,12 +3113,32 @@ BEGIN_CAN_TYPE_WRAPPER(FunctionType, AnyFunctionType)
   }
 END_CAN_TYPE_WRAPPER(FunctionType, AnyFunctionType)
 
-/// Map the given parameter list onto a bitvector describing whether
-/// the argument type at each index has a default argument associated with
-/// it.
-SmallBitVector
-computeDefaultMap(ArrayRef<AnyFunctionType::Param> params,
-                  const ValueDecl *paramOwner, bool skipCurriedSelf);
+/// Provides information about the parameter list of a given declaration, including whether each parameter
+/// has a default argument.
+struct ParameterListInfo {
+  SmallBitVector defaultArguments;
+  std::vector<Type> functionBuilderTypes;
+
+public:
+  ParameterListInfo() { }
+
+  ParameterListInfo(ArrayRef<AnyFunctionType::Param> params,
+                    const ValueDecl *paramOwner, bool skipCurriedSelf);
+
+  /// Whether the parameter at the given index has a default argument.
+  bool hasDefaultArgument(unsigned paramIdx) const;
+
+  /// Retrieve the number of non-defaulted parameters.
+  unsigned numNonDefaultedParameters() const {
+    return defaultArguments.count();
+  }
+
+  /// Retrieve the number of parameters for which we have information.
+  unsigned size() const { return defaultArguments.size(); }
+
+  /// Retrieve the function builder type for the given parameter.
+  Type getFunctionBuilderType(unsigned paramIdx) const;
+};
 
 /// Turn a param list into a symbolic and printable representation that does not
 /// include the types, something like (: , b:, c:)

include/swift/Parse/CodeCompletionCallbacks.h

@@ -116,7 +116,7 @@ class CodeCompletionCallbacks {
   };
 
   /// Set target decl for attribute if the CC token is in attribute of the decl.
-  virtual void setAttrTargetDecl(Decl *D) {}
+  virtual void setAttrTargetDeclKind(Optional<DeclKind> DK) {}
 
   /// Complete the whole expression.  This is a fallback that should
   /// produce results when more specific completion methods failed.

lib/AST/ASTPrinter.cpp

@@ -2590,6 +2590,7 @@ void PrintAST::printOneParameter(const ParamDecl *param,
 
   auto TheTypeLoc = param->getTypeLoc();
 
+  printAttributes(param);
   printArgName();
 
   if (!TheTypeLoc.getTypeRepr() && param->hasInterfaceType())