Merge main 2021-01-30

cmake/modules/AddSwift.cmake

@@ -437,14 +437,15 @@ function(add_swift_host_library name)
   endif()
 
   if(XCODE)
-    get_filename_component(dir ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
-
+    get_filename_component(base_dir ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+  
     file(GLOB_RECURSE ASHL_HEADERS
-      ${SWIFT_SOURCE_DIR}/include/swift${dir}/*.h
-      ${SWIFT_SOURCE_DIR}/include/swift${dir}/*.def
+      ${SWIFT_SOURCE_DIR}/include/swift/${base_dir}/*.h
+      ${SWIFT_SOURCE_DIR}/include/swift/${base_dir}/*.def
+      ${CMAKE_CURRENT_SOURCE_DIR}/*.h
       ${CMAKE_CURRENT_SOURCE_DIR}/*.def)
     file(GLOB_RECURSE ASHL_TDS
-      ${SWIFT_SOURCE_DIR}/include/swift${dir}/*.td)
+      ${SWIFT_SOURCE_DIR}/include/swift${base_dir}/*.td)
 
     set_source_files_properties(${ASHL_HEADERS} ${ASHL_TDS} PROPERTIES
       HEADER_FILE_ONLY true)

docs/ABI/Mangling.rst

@@ -556,13 +556,14 @@ Types
   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? throws? // results and parameters
+  function-signature ::= params-type params-type async? concurrent? throws? // results and parameters
 
   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
 
+  concurrent ::= 'J'                         // @concurrent on function types
   async ::= 'Y'                              // 'async' annotation on function types
   throws ::= 'K'                             // 'throws' annotation on function types
 
@@ -624,7 +625,7 @@ mangled in to disambiguate.
   impl-function-type ::= type* 'I' FUNC-ATTRIBUTES '_'
   impl-function-type ::= type* generic-signature 'I' FUNC-ATTRIBUTES '_'
 
-  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? ASYNC? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION RESULT-DIFFERENTIABILITY?)?
+  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? CONCURRENT? ASYNC? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION RESULT-DIFFERENTIABILITY?)?
 
   PATTERN-SUBS ::= 's'                       // has pattern substitutions
   INVOCATION-SUB ::= 'I'                     // has invocation substitutions
@@ -653,6 +654,7 @@ mangled in to disambiguate.
   COROUTINE-KIND ::= 'A'                     // yield-once coroutine
   COROUTINE-KIND ::= 'G'                     // yield-many coroutine
 
+  CONCURRENT ::= 'h'                         // @concurrent
   ASYNC ::= 'H'                              // @async
 
   PARAM-CONVENTION ::= 'i'                   // indirect in

include/swift/ABI/Metadata.h

@@ -1637,6 +1637,7 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   }
   bool isAsync() const { return Flags.isAsync(); }
   bool isThrowing() const { return Flags.isThrowing(); }
+  bool isConcurrent() const { return Flags.isConcurrent(); }
   bool hasParameterFlags() const { return Flags.hasParameterFlags(); }
   bool isEscaping() const { return Flags.isEscaping(); }
 

include/swift/ABI/MetadataValues.h

@@ -779,6 +779,7 @@ class TargetFunctionTypeFlags {
     DifferentiableMask = 0x08000000U,
     LinearMask        = 0x10000000U,
     AsyncMask         = 0x20000000U,
+    ConcurrentMask    = 0x40000000U,
   };
   int_type Data;
 
@@ -831,6 +832,13 @@ class TargetFunctionTypeFlags {
                                              (isEscaping ? EscapingMask : 0));
   }
 
+  constexpr TargetFunctionTypeFlags<int_type>
+  withConcurrent(bool isConcurrent) const {
+    return TargetFunctionTypeFlags<int_type>(
+        (Data & ~ConcurrentMask) |
+        (isConcurrent ? ConcurrentMask : 0));
+  }
+
   unsigned getNumParameters() const { return Data & NumParametersMask; }
 
   FunctionMetadataConvention getConvention() const {
@@ -845,6 +853,10 @@ class TargetFunctionTypeFlags {
     return bool (Data & EscapingMask);
   }
 
+  bool isConcurrent() const {
+    return bool (Data & ConcurrentMask);
+  }
+
   bool hasParameterFlags() const { return bool(Data & ParamFlagsMask); }
 
   bool isDifferentiable() const {

include/swift/AST/AnyFunctionRef.h

@@ -181,6 +181,17 @@ class AnyFunctionRef {
     return false;
   }
 
+  /// Whether this function is @concurrent.
+  bool isConcurrent() const {
+    if (!hasType())
+      return false;
+
+    if (auto *fnType = getType()->getAs<AnyFunctionType>())
+      return fnType->isConcurrent();
+
+    return false;
+  }
+
   bool isObjC() const {
     if (auto afd = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
       return afd->isObjC();

include/swift/AST/Attr.def

@@ -54,6 +54,7 @@ TYPE_ATTR(escaping)
 TYPE_ATTR(differentiable)
 TYPE_ATTR(noDerivative)
 TYPE_ATTR(async)
+TYPE_ATTR(concurrent)
 
 // SIL-specific attributes
 TYPE_ATTR(block_storage)
@@ -599,6 +600,12 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
   APIBreakingToAdd | APIBreakingToRemove,
   106)
 
+SIMPLE_DECL_ATTR(concurrent, Concurrent,
+  OnFunc | OnConstructor | OnAccessor | ConcurrencyOnly |
+  ABIStableToAdd | ABIStableToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  107)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -5773,6 +5773,11 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// type of the function will be `async` as well.
   bool hasAsync() const { return Bits.AbstractFunctionDecl.Async; }
 
+  /// Determine whether the given function is concurrent.
+  ///
+  /// A function is concurrent if it has the @concurrent attribute.
+  bool isConcurrent() const;
+
   /// Returns true if the function is a suitable 'async' context.
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.

include/swift/AST/DiagnosticsSema.def

@@ -3727,26 +3727,30 @@ NOTE(silence_debug_description_in_interpolation_segment_call,none,
      "use 'String(describing:)' to silence this warning", ())
 
 NOTE(noescape_parameter,none,
-    "parameter %0 is implicitly non-escaping",
-     (Identifier))
+    "parameter %1 is implicitly %select{non-escaping|non-concurrent}0",
+     (unsigned, Identifier))
 NOTE(generic_parameters_always_escaping,none,
      "generic parameters are always considered '@escaping'", ())
 
-ERROR(passing_noescape_to_escaping,none,
-      "passing non-escaping parameter %0 to function expecting an @escaping closure",
-      (Identifier))
+ERROR(passing_noattrfunc_to_attrfunc,none,
+      "passing %select{non-escaping|non-concurrent}0 parameter %1 to function "
+      "expecting %select{an @escaping|a @concurrent}0 closure",
+      (unsigned, Identifier))
 ERROR(converting_noespace_param_to_generic_type,none,
       "converting non-escaping parameter %0 to generic parameter %1 may allow it to escape",
       (Identifier, Type))
-ERROR(assigning_noescape_to_escaping,none,
-      "assigning non-escaping parameter %0 to an @escaping closure",
-      (Identifier))
-ERROR(general_noescape_to_escaping,none,
-      "using non-escaping parameter %0 in a context expecting an @escaping closure",
-      (Identifier))
-ERROR(converting_noescape_to_type,none,
-      "converting non-escaping value to %0 may allow it to escape",
-      (Type))
+ERROR(assigning_noattrfunc_to_attrfunc,none,
+      "assigning %select{non-escaping|non-concurrent}0 parameter %1 to "
+      "%select{an @escaping|a @concurrent}0 closure",
+      (unsigned, Identifier))
+ERROR(general_noattrfunc_to_attr,none,
+      "using %select{non-escaping|non-concurrent}0 parameter %1 in a context "
+      "expecting %select{an @escaping|a @concurrent}0 closure",
+      (unsigned, Identifier))
+ERROR(converting_noattrfunc_to_type,none,
+      "converting %select{non-escaping|non-concurrent function}0 value to %1 "
+      "may %select{allow it to escape|introduce data races}0",
+      (unsigned, Type))
 
 ERROR(capture_across_type_decl,none,
       "%0 declaration cannot close over value %1 defined in outer scope",
@@ -4252,14 +4256,29 @@ ERROR(global_actor_from_nonactor_context,none,
 ERROR(actor_isolated_partial_apply,none,
         "actor-isolated %0 %1 can not be partially applied",
         (DescriptiveDeclKind, DeclName))
-WARNING(concurrent_access_local,none,
-        "local %0 %1 is unsafe to reference in code that may execute "
-        "concurrently",
+ERROR(concurrent_access_local,none,
+        "use of local %0 %1 in concurrently-executing code",
         (DescriptiveDeclKind, DeclName))
-ERROR(actor_isolated_concurrent_access,none,
-        "actor-isolated %0 %1 is unsafe to reference in code "
-        "that may execute concurrently",
+ERROR(actor_isolated_from_concurrent_closure,none,
+        "actor-isolated %0 %1 cannot be referenced from a concurrent closure",
         (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_from_concurrent_function,none,
+        "actor-isolated %0 %1 cannot be referenced from a concurrent function",
+        (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_from_async_let,none,
+        "actor-isolated %0 %1 cannot be referenced from 'async let' initializer",
+        (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_from_escaping_closure,none,
+        "actor-isolated %0 %1 cannot be referenced from an '@escaping' closure",
+        (DescriptiveDeclKind, DeclName))
+ERROR(local_function_executed_concurrently,none,
+      "concurrently-executed %0 %1 must be marked as '@concurrent'",
+      (DescriptiveDeclKind, DeclName))
+ERROR(concurrent_mutation_of_local_capture,none,
+      "mutation of captured %0 %1 in concurrently-executing code",
+      (DescriptiveDeclKind, DeclName))
+NOTE(concurrent_access_here,none,
+     "access in concurrently-executed code here", ())
 NOTE(actor_isolated_sync_func,none,
      "calls to %0 %1 from outside of its actor context are "
      "implicitly asynchronous",