Merge pull request #2920 from swiftwasm/katei/merge-main-2021-04-01

Merge main 2021-04-01

Author: MaxDesiatov

CHANGELOG.md

@@ -29,6 +29,36 @@ CHANGELOG
 Swift 5.5
 ---------
 
+* [SE-0293][]:
+
+  Property wrappers can now be applied to function and closure parameters:
+
+  ```swift
+  @propertyWrapper
+  struct Wrapper<Value> {
+    var wrappedValue: Value
+
+    var projectedValue: Self { return self }
+
+    init(wrappedValue: Value) { ... }
+
+    init(projectedValue: Self) { ... }
+  }
+
+  func test(@Wrapper value: Int) {
+    print(value)
+    print($value)
+    print(_value)
+  }
+
+  test(value: 10)
+
+  let projection = Wrapper(wrappedValue: 10)
+  test($value: projection)
+  ```
+
+  The call-site can pass a wrapped value or a projected value, and the property wrapper will be initialized using `init(wrappedValue:)` or `init(projectedValue:)`, respectively.
+
 * [SE-0299][]:
 
   It is now possible to use leading-dot syntax in generic contexts to access static members of protocol extensions where `Self` is constrained to a fully concrete type:

cmake/modules/AddSwift.cmake

@@ -301,6 +301,9 @@ function(_add_host_variant_link_flags target)
     target_link_libraries(${target} PRIVATE
       pthread
       dl)
+    if("${SWIFT_HOST_VARIANT_ARCH}" MATCHES "armv6|armv7|i686")
+      target_link_libraries(${target} PRIVATE atomic)
+    endif()
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL FREEBSD)
     target_link_libraries(${target} PRIVATE
       pthread)

cmake/modules/AddSwiftUnittests.cmake

@@ -56,6 +56,9 @@ function(add_swift_unittest test_dirname)
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
       target_compile_options(${test_dirname} PRIVATE
         -march=core2)
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "armv6|armv7|i686")
+      set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_LIBRARIES
+        "atomic")
     endif()
   elseif("${SWIFT_HOST_VARIANT}" STREQUAL "windows")
     target_compile_definitions("${test_dirname}" PRIVATE

docs/ABI/Mangling.rst

@@ -560,24 +560,24 @@ Types
   FUNCTION-KIND ::= 'zC' C-TYPE              // C function pointer type with with non-canonical C type
   FUNCTION-KIND ::= 'A'                      // @auto_closure function type (escaping)
   FUNCTION-KIND ::= 'E'                      // function type (noescape)
-  FUNCTION-KIND ::= 'F'                      // @differentiable function type
-  FUNCTION-KIND ::= 'G'                      // @differentiable function type (escaping)
-  FUNCTION-KIND ::= 'H'                      // @differentiable(_linear) function type
-  FUNCTION-KIND ::= 'I'                      // @differentiable(_linear) function type (escaping)
 
   C-TYPE is mangled according to the Itanium ABI, and prefixed with the length.
   Non-ASCII identifiers are preserved as-is; we do not use Punycode.
 
-  function-signature ::= params-type params-type async? sendable? throws? // results and parameters
+  function-signature ::= params-type params-type async? sendable? throws? differentiable? // results and parameters
 
-  params-type ::= type 'z'? 'h'?              // tuple in case of multiple parameters or a single parameter with a single tuple type
+  params-type ::= type 'z'? 'h'?             // tuple in case of multiple parameters or a single parameter with a single tuple type
                                              // with optional inout convention, shared convention. parameters don't have labels,
                                              // they are mangled separately as part of the entity.
-  params-type ::= empty-list                  // shortcut for no parameters
+  params-type ::= empty-list                 // shortcut for no parameters
 
-  sendable ::= 'J'                         // @Sendable on function types
+  sendable ::= 'J'                           // @Sendable on function types
   async ::= 'Y'                              // 'async' annotation on function types
   throws ::= 'K'                             // 'throws' annotation on function types
+  differentiable ::= 'jf'                    // @differentiable(_forward) on function type
+  differentiable ::= 'jr'                    // @differentiable(reverse) on function type
+  differentiable ::= 'jd'                    // @differentiable on function type
+  differentiable ::= 'jl'                    // @differentiable(_linear) on function type
 
   type-list ::= list-type '_' list-type*     // list of types
   type-list ::= empty-list

docs/SIL.rst

@@ -3302,7 +3302,7 @@ hop_to_executor
 
   hop_to_executor %0 : $T
 
-  // $T must conform to the Actor protocol
+  // $T must be Builtin.Executor or conform to the Actor protocol
 
 Ensures that all instructions, which need to run on the actor's executor
 actually run on that executor.
@@ -3312,6 +3312,11 @@ Checks if the current executor is the one which is bound to the operand actor.
 If not, begins a suspension point and enqueues the continuation to the executor
 which is bound to the operand actor.
 
+SIL generation emits this instruction with operands of actor type as
+well as of type ``Builtin.Executor``.  The former are expected to be
+lowered by the SIL pipeline, so that IR generation only operands of type
+``Builtin.Executor`` remain.
+
 The operand is a guaranteed operand, i.e. not consumed.
 
 dealloc_stack

include/swift/ABI/Metadata.h

@@ -1338,18 +1338,20 @@ using ClassMetadata = TargetClassMetadata<InProcess>;
 /// dispatch expects to see, with padding to place them at the expected offsets.
 template <typename Runtime>
 struct TargetDispatchClassMetadata : public TargetHeapMetadata<Runtime> {
-  using DummyVTableCall = void (*)(void);
+  using InvokeCall = void (*)(void *, void *, uint32_t);
 
-  TargetDispatchClassMetadata(MetadataKind Kind,
-                              DummyVTableCall DummyVTableEntry)
-      : TargetHeapMetadata<Runtime>(Kind), DummyVTableEntry(DummyVTableEntry) {}
+  TargetDispatchClassMetadata(MetadataKind Kind, unsigned long VTableType,
+                              InvokeCall Invoke)
+      : TargetHeapMetadata<Runtime>(Kind), VTableType(VTableType),
+        VTableInvoke(Invoke) {}
 
   TargetPointer<Runtime, void> Opaque;
 #if SWIFT_OBJC_INTEROP
   TargetPointer<Runtime, void> OpaqueObjC[3];
 #endif
 
-  TargetSignedPointer<Runtime, DummyVTableCall> DummyVTableEntry;
+  unsigned long VTableType;
+  TargetSignedPointer<Runtime, InvokeCall __ptrauth_swift_dispatch_invoke_function> VTableInvoke;
 };
 using DispatchClassMetadata = TargetDispatchClassMetadata<InProcess>;
 
@@ -1658,6 +1660,7 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   bool isAsync() const { return Flags.isAsync(); }
   bool isThrowing() const { return Flags.isThrowing(); }
   bool isSendable() const { return Flags.isSendable(); }
+  bool isDifferentiable() const { return Flags.isDifferentiable(); }
   bool hasParameterFlags() const { return Flags.hasParameterFlags(); }
   bool isEscaping() const { return Flags.isEscaping(); }
 
@@ -1675,6 +1678,28 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
     return reinterpret_cast<const uint32_t *>(getParameters() +
                                               getNumParameters());
   }
+
+  TargetFunctionMetadataDifferentiabilityKind<StoredSize> *
+  getDifferentiabilityKindAddress() {
+    assert(isDifferentiable());
+    void *previousEndAddr = hasParameterFlags()
+        ? reinterpret_cast<void *>(getParameterFlags() + getNumParameters())
+        : reinterpret_cast<void *>(getParameters() + getNumParameters());
+    return reinterpret_cast<
+        TargetFunctionMetadataDifferentiabilityKind<StoredSize> *>(
+        llvm::alignAddr(previousEndAddr,
+                        llvm::Align(alignof(typename Runtime::StoredPointer))));
+  }
+
+  TargetFunctionMetadataDifferentiabilityKind<StoredSize>
+  getDifferentiabilityKind() const {
+    if (isDifferentiable()) {
+      return *const_cast<TargetFunctionTypeMetadata<Runtime> *>(this)
+          ->getDifferentiabilityKindAddress();
+    }
+    return TargetFunctionMetadataDifferentiabilityKind<StoredSize>
+        ::NonDifferentiable;
+  }
 };
 using FunctionTypeMetadata = TargetFunctionTypeMetadata<InProcess>;
 

include/swift/ABI/MetadataValues.h

@@ -787,13 +787,29 @@ enum class FunctionMetadataConvention: uint8_t {
 
 /// Differentiability kind for function type metadata.
 /// Duplicates `DifferentiabilityKind` in AST/AutoDiff.h.
-enum class FunctionMetadataDifferentiabilityKind: uint8_t {
-  NonDifferentiable = 0b00000,
-  Forward           = 0b00001,
-  Reverse           = 0b00010,
-  Normal            = 0b00011,
-  Linear            = 0b10000,
+template <typename int_type>
+struct TargetFunctionMetadataDifferentiabilityKind {
+  enum Value : int_type {
+    NonDifferentiable = 0,
+    Forward           = 1,
+    Reverse           = 2,
+    Normal            = 3,
+    Linear            = 4,
+  } Value;
+
+  constexpr TargetFunctionMetadataDifferentiabilityKind(
+      enum Value value = NonDifferentiable) : Value(value) {}
+
+  int_type getIntValue() const {
+    return (int_type)Value;
+  }
+
+  bool isDifferentiable() const {
+    return Value != NonDifferentiable;
+  }
 };
+using FunctionMetadataDifferentiabilityKind =
+    TargetFunctionMetadataDifferentiabilityKind<size_t>;
 
 /// Flags in a function type metadata record.
 template <typename int_type>
@@ -808,8 +824,7 @@ class TargetFunctionTypeFlags {
     ThrowsMask             = 0x01000000U,
     ParamFlagsMask         = 0x02000000U,
     EscapingMask           = 0x04000000U,
-    DifferentiabilityMask  = 0x98000000U,
-    DifferentiabilityShift = 27U,
+    DifferentiableMask     = 0x08000000U,
     AsyncMask              = 0x20000000U,
     SendableMask           = 0x40000000U,
   };
@@ -842,10 +857,10 @@ class TargetFunctionTypeFlags {
                                              (throws ? ThrowsMask : 0));
   }
 
-  constexpr TargetFunctionTypeFlags<int_type> withDifferentiabilityKind(
-      FunctionMetadataDifferentiabilityKind differentiabilityKind) const {
-    return TargetFunctionTypeFlags((Data & ~DifferentiabilityMask)
-        | (int_type(differentiabilityKind) << DifferentiabilityShift));
+  constexpr TargetFunctionTypeFlags<int_type>
+  withDifferentiable(bool differentiable) const {
+    return TargetFunctionTypeFlags<int_type>((Data & ~DifferentiableMask) |
+                                     (differentiable ? DifferentiableMask : 0));
   }
 
   constexpr TargetFunctionTypeFlags<int_type>
@@ -888,13 +903,7 @@ class TargetFunctionTypeFlags {
   bool hasParameterFlags() const { return bool(Data & ParamFlagsMask); }
 
   bool isDifferentiable() const {
-    return getDifferentiabilityKind() !=
-        FunctionMetadataDifferentiabilityKind::NonDifferentiable;
-  }
-
-  FunctionMetadataDifferentiabilityKind getDifferentiabilityKind() const {
-    return FunctionMetadataDifferentiabilityKind(
-        (Data & DifferentiabilityMask) >> DifferentiabilityShift);
+    return bool (Data & DifferentiableMask);
   }
 
   int_type getIntValue() const {
@@ -947,6 +956,12 @@ class TargetParameterTypeFlags {
         (Data & ~AutoClosureMask) | (isAutoClosure ? AutoClosureMask : 0));
   }
 
+  constexpr TargetParameterTypeFlags<int_type>
+  withNoDerivative(bool isNoDerivative) const {
+    return TargetParameterTypeFlags<int_type>(
+        (Data & ~NoDerivativeMask) | (isNoDerivative ? NoDerivativeMask : 0));
+  }
+
   bool isNone() const { return Data == 0; }
   bool isVariadic() const { return Data & VariadicMask; }
   bool isAutoClosure() const { return Data & AutoClosureMask; }
@@ -1212,6 +1227,9 @@ namespace SpecialPointerAuthDiscriminators {
 
   /// Swift async context parameter stored in the extended frame info.
   const uint16_t SwiftAsyncContextExtendedFrameEntry = 0xc31a; // = 49946
+
+  /// Dispatch integration.
+  const uint16_t DispatchInvokeFunction = 0xf493; // = 62611
 }
 
 /// The number of arguments that will be passed directly to a generic

include/swift/ABI/Task.h

@@ -40,14 +40,20 @@ extern FullMetadata<DispatchClassMetadata> jobHeapMetadata;
 
 /// A schedulable job.
 class alignas(2 * alignof(void*)) Job : public HeapObject {
-protected:
+public:
   // Indices into SchedulerPrivate, for use by the runtime.
   enum {
     /// The next waiting task link, an AsyncTask that is waiting on a future.
     NextWaitingTaskIndex = 0,
+
+    /// An opaque field used by Dispatch when enqueueing Jobs directly.
+    DispatchLinkageIndex = 0,
+
+    /// The dispatch queue being used when enqueueing a Job directly with
+    /// Dispatch.
+    DispatchQueueIndex = 1,
   };
 
-public:
   // Reserved for the use of the scheduler.
   void *SchedulerPrivate[2];
 

include/swift/AST/ASTDemangler.h

@@ -97,8 +97,10 @@ class ASTBuilder {
 
   Type createTupleType(ArrayRef<Type> eltTypes, StringRef labels);
 
-  Type createFunctionType(ArrayRef<Demangle::FunctionParam<Type>> params,
-                          Type output, FunctionTypeFlags flags);
+  Type createFunctionType(
+      ArrayRef<Demangle::FunctionParam<Type>> params,
+      Type output, FunctionTypeFlags flags,
+      FunctionMetadataDifferentiabilityKind diffKind);
 
   Type createImplFunctionType(
       Demangle::ImplParameterConvention calleeConvention,

include/swift/AST/ASTSynthesis.h

@@ -135,7 +135,7 @@ struct VariadicSynthesizerStorage<> {
   constexpr VariadicSynthesizerStorage() {}
 
   template <class Fn>
-  void visit(const Fn &fn) const {}
+  void visit(Fn &&fn) const {}
 };
 template <class Head, class... Tail>
 struct VariadicSynthesizerStorage<Head, Tail...> {
@@ -145,7 +145,7 @@ struct VariadicSynthesizerStorage<Head, Tail...> {
     : head(head), tail(tail...) {}
 
   template <class Fn>
-  void visit(const Fn &fn) const {
+  void visit(Fn &&fn) const {
     fn(head);
     tail.visit(fn);
   }

include/swift/AST/AnyFunctionRef.h

@@ -110,9 +110,9 @@ class AnyFunctionRef {
     return TheFunction.get<AbstractClosureExpr *>()->getParameters();
   }
 
-  bool hasPropertyWrapperParameters() const {
+  bool hasExternalPropertyWrapperParameters() const {
     return llvm::any_of(*getParameters(), [](const ParamDecl *param) {
-      return param->hasAttachedPropertyWrapper();
+      return param->hasExternalPropertyWrapper();
     });
   }
 

include/swift/AST/Attr.def

@@ -625,7 +625,7 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   110)
 
 DECL_ATTR(completionHandlerAsync, CompletionHandlerAsync,
-  OnAbstractFunction | ConcurrencyOnly |
+  OnAbstractFunction | ConcurrencyOnly | LongAttribute |
   ABIStableToAdd | ABIStableToRemove |
   APIStableToAdd | APIStableToRemove,
   111)
@@ -637,6 +637,15 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
   APIBreakingToAdd | APIStableToRemove,
   112)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(_unsafeSendable, UnsafeSendable,
+  OnParam | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  113)
+
+CONTEXTUAL_SIMPLE_DECL_ATTR(_unsafeMainActor, UnsafeMainActor,
+  OnParam | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove,
+  114)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS