Merge branch 'main' into wip-no-escape-group

Author: ktoso

docs/ABI/Mangling.rst

@@ -222,8 +222,8 @@ types where the metadata itself has unknown layout.)
   global ::= global 'Tm'                 // merged function
   global ::= entity                      // some identifiable thing
   global ::= from-type to-type generic-signature? 'TR'  // reabstraction thunk
-  global ::= impl-function-type type 'Tz'     // objc-to-swift-async completion handler block implementation
-  global ::= impl-function-type type 'TZ'     // objc-to-swift-async completion handler block implementation (predefined by runtime)
+  global ::= impl-function-type type 'Tz' index? // objc-to-swift-async completion handler block implementation
+  global ::= impl-function-type type 'TZ' index? // objc-to-swift-async completion handler block implementation (predefined by runtime)
   global ::= from-type to-type generic-signature? 'TR'  // reabstraction thunk
   global ::= impl-function-type type generic-signature? 'Tz'     // objc-to-swift-async completion handler block implementation
   global ::= impl-function-type type generic-signature? 'TZ'     // objc-to-swift-async completion handler block implementation (predefined by runtime)

docs/SIL.rst

@@ -2320,6 +2320,54 @@ The current list of interior pointer SIL instructions are:
 (*) We still need to finish adding support for project_box, but all other
 interior pointers are guarded already.
 
+Memory Lifetime
+~~~~~~~~~~~~~~~
+
+Similar to Ownership SSA, there are also lifetime rules for values in memory.
+With "memory" we refer to memory which is addressed by SIL instruction with
+address-type operands, like ``load``, ``store``, ``switch_enum_addr``, etc.
+
+Each memory location which holds a non-trivial value is either uninitialized
+or initialized. A memory location gets initialized by storing values into it
+(except assignment, which expects a location to be already initialized).
+A memory location gets de-initialized by "taking" from it or destroying it, e.g.
+with ``destroy_addr``. It is illegal to re-initialize a memory location or to
+use a location after it was de-initialized.
+
+If a memory location holds a trivial value (e.g. an ``Int``), it is not
+required to de-initialize the location.
+
+The SIL verifier checks this rule for memory locations which can be uniquely
+identified, for example and ``alloc_stack`` or an indirect parameter. The
+verifier cannot check memory locations which are potentially aliased, e.g.
+a ``ref_element_addr`` (a stored class property).
+
+Lifetime of Enums in Memory
+```````````````````````````
+
+The situation is a bit more complicated with enums, because an enum can have
+both, cases with non-trivial payloads and cases with no payload or trivial
+payloads.
+
+Even if an enum itself is not trivial (because it has at least on case with a
+non-trivial payload), it is not required to de-initialize such an enum memory
+location on paths where it's statically provable that the enum contains a
+trivial or non-payload case.
+
+That's the case if the destroy point is jointly dominated by:
+
+* a ``store [trivial]`` to the enum memory location.
+
+or
+
+* an ``inject_enum_addr`` to the enum memory location with a non-trivial or
+  non-payload case.
+
+or
+
+* a successor of a ``switch_enum`` or ``switch_enum_addr`` for a non-trivial
+  or non-payload case.
+
 Dead End Blocks
 ~~~~~~~~~~~~~~~
 

include/swift/ABI/Task.h

@@ -82,8 +82,17 @@ class alignas(2 * alignof(void*)) Job {
     return Flags.getPriority();
   }
 
-  /// Run this job.
-  void run(ExecutorRef currentExecutor);
+  /// Given that we've fully established the job context in the current
+  /// thread, actually start running this job.  To establish the context
+  /// correctly, call swift_job_run or runJobInExecutorContext.
+  void runInFullyEstablishedContext(ExecutorRef currentExecutor);
+
+  /// Given that we've fully established the job context in the
+  /// current thread, and that the job is a simple (non-task) job,
+  /// actually start running this job.
+  void runSimpleInFullyEstablishedContext(ExecutorRef currentExecutor) {
+    RunJob(this, currentExecutor);
+  }
 };
 
 // The compiler will eventually assume these.
@@ -176,7 +185,11 @@ class AsyncTask : public HeapObject, public Job {
     assert(flags.isAsyncTask());
   }
 
-  void run(ExecutorRef currentExecutor) {
+  /// Given that we've already fully established the job context
+  /// in the current thread, start running this task.  To establish
+  /// the job context correctly, call swift_job_run or
+  /// runInExecutorContext.
+  void runInFullyEstablishedContext(ExecutorRef currentExecutor) {
     ResumeTask(this, currentExecutor, ResumeContext);
   }
 
@@ -581,6 +594,10 @@ class AsyncTask : public HeapObject, public Job {
     /// Destroy the storage associated with the future.
     void destroy();
 
+    const Metadata *getResultType() const {
+      return resultType;
+    }
+
     /// Retrieve a pointer to the storage of result.
     OpaqueValue *getStoragePtr() {
       return reinterpret_cast<OpaqueValue *>(
@@ -656,11 +673,11 @@ static_assert(sizeof(AsyncTask) == 12 * sizeof(void*),
 static_assert(alignof(AsyncTask) == 2 * alignof(void*),
               "AsyncTask alignment is wrong");
 
-inline void Job::run(ExecutorRef currentExecutor) {
+inline void Job::runInFullyEstablishedContext(ExecutorRef currentExecutor) {
   if (auto task = dyn_cast<AsyncTask>(this))
-    task->run(currentExecutor);
+    task->runInFullyEstablishedContext(currentExecutor);
   else
-    RunJob(this, currentExecutor);
+    runSimpleInFullyEstablishedContext(currentExecutor);
 }
 
 /// An asynchronous context within a task.  Generally contexts are

include/swift/AST/ASTMangler.h

@@ -172,6 +172,7 @@ class ASTMangler : public Mangler {
   std::string mangleObjCAsyncCompletionHandlerImpl(CanSILFunctionType BlockType,
                                                    CanType ResultType,
                                                    CanGenericSignature Sig,
+                                                   Optional<bool> FlagParamIsZeroOnError,
                                                    bool predefined);
 
   /// Mangle the derivative function (JVP/VJP), or optionally its vtable entry

include/swift/AST/Attr.def

@@ -624,6 +624,12 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   110)
 
+DECL_ATTR(hasAsyncAlternative, HasAsyncAlternative,
+  OnAbstractFunction | ConcurrencyOnly |
+  ABIStableToAdd | ABIStableToRemove |
+  APIStableToAdd | APIStableToRemove,
+  111)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Attr.h

@@ -2140,6 +2140,30 @@ class TransposeAttr final
   }
 };
 
+/// The `@hasAsyncAlternative` attribute marks a function as having an async
+/// alternative, optionally providing a name (for cases when the alternative
+/// has a different name).
+class HasAsyncAlternativeAttr final : public DeclAttribute  {
+public:
+  /// An optional name of the async alternative function, where the name of the
+  /// attributed function is used otherwise.
+  const DeclNameRef Name;
+
+  HasAsyncAlternativeAttr(DeclNameRef Name, SourceLoc AtLoc, SourceRange Range)
+    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false),
+      Name(Name) {}
+
+  HasAsyncAlternativeAttr(SourceLoc AtLoc, SourceRange Range)
+    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false) {}
+
+  /// Determine whether this attribute has a name associated with it.
+  bool hasName() const { return !Name.getBaseName().empty(); }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_HasAsyncAlternative;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/DiagnosticsParse.def

@@ -1672,6 +1672,15 @@ ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
       "parameters as original function generic signature '%1'",
       (StringRef, StringRef))
 
+// hasAsyncAlternative
+ERROR(requires_has_async_alternative, none,
+      "'%0' support is required to be explicitly enabled using "
+      "-experimental-has-async-alternative-attribute", (StringRef))
+
+ERROR(has_async_alternative_invalid_name, none,
+      "argument of '%0' attribute must be an identifier or full function name",
+      (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -779,9 +779,6 @@ NOTE(serialization_compatibility_version_mismatch,none,
 ERROR(serialization_allowing_invalid_decl,none,
       "allowing deserialization of invalid declaration %0 from module '%1'",
       (DeclName, StringRef))
-ERROR(serialization_invalid_decl,Fatal,
-      "invalid declaration %0 read from module '%1'; "
-      SWIFT_BUG_REPORT_MESSAGE, ())
 
 ERROR(reserved_member_name,none,
       "type member must not be named %0, since it would conflict with the"
@@ -3546,6 +3543,9 @@ ERROR(generic_type_requires_arguments,none,
 NOTE(descriptive_generic_type_declared_here,none,
      "%0 declared here", (StringRef))
 
+ERROR(placeholder_type_not_allowed,none,
+      "you cannot use a placeholder type here", ())
+
 WARNING(use_of_void_pointer,none,
 "Unsafe%0Pointer<Void> has been replaced by Unsafe%0RawPointer", (StringRef))
 
@@ -4319,24 +4319,45 @@ WARNING(non_concurrent_property_type,none,
         "cannot use %0 %1 with a non-concurrent-value type %2 "
         "%select{across actors|from concurrently-executed code}3",
         (DescriptiveDeclKind, DeclName, Type, bool))
+WARNING(non_concurrent_keypath_capture,none,
+        "cannot form key path that captures non-concurrent-value type %0",
+        (Type))
 ERROR(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
       "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",
       (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
+WARNING(non_concurrent_type_member_warn,none,
+      "%select{stored property %1|associated value %1}0 of "
+      "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",
+      (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
 ERROR(concurrent_value_class_mutable_property,none,
       "stored property %0 of 'ConcurrentValue'-conforming %1 %2 is mutable",
       (DeclName, DescriptiveDeclKind, DeclName))
+WARNING(concurrent_value_class_mutable_property_warn,none,
+      "stored property %0 of 'ConcurrentValue'-conforming %1 %2 is mutable",
+      (DeclName, DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_outside_source_file,none,
-      "conformance 'ConcurrentValue' must occur in the same source file as "
+      "conformance to 'ConcurrentValue' must occur in the same source file as "
+      "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
+      (DescriptiveDeclKind, DeclName))
+WARNING(concurrent_value_outside_source_file_warn,none,
+      "conformance to 'ConcurrentValue' must occur in the same source file as "
       "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
       (DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_open_class,none,
       "open class %0 cannot conform to `ConcurrentValue`; "
       "use `UnsafeConcurrentValue`", (DeclName))
+WARNING(concurrent_value_open_class_warn,none,
+      "open class %0 cannot conform to `ConcurrentValue`; "
+      "use `UnsafeConcurrentValue`", (DeclName))
 ERROR(concurrent_value_inherit,none,
       "`ConcurrentValue` class %1 cannot inherit from another class"
       "%select{| other than 'NSObject'}0",
       (bool, DeclName))
+WARNING(concurrent_value_inherit_warn,none,
+        "`ConcurrentValue` class %1 cannot inherit from another class"
+        "%select{| other than 'NSObject'}0",
+        (bool, DeclName))
 
 ERROR(actorindependent_let,none,
       "'@actorIndependent' is meaningless on 'let' declarations because "
@@ -5625,8 +5646,12 @@ ERROR(marker_protocol_requirement, none,
 ERROR(marker_protocol_inherit_nonmarker, none,
       "marker protocol %0 cannot inherit non-marker protocol %1",
       (DeclName, DeclName))
-ERROR(marker_protocol_value,none,
-      "marker protocol %0 can only be used in generic constraints", (DeclName))
+ERROR(marker_protocol_cast,none,
+      "marker protocol %0 cannot be used in a conditional cast", (DeclName))
+ERROR(marker_protocol_conditional_conformance,none,
+      "conditional conformance to non-marker protocol %0 cannot depend on "
+      "conformance of %1 to non-marker protocol %2",
+      (Identifier, Type, Identifier))
 
 //------------------------------------------------------------------------------
 // MARK: differentiable programming diagnostics

include/swift/AST/FineGrainedDependencies.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_AST_FINE_GRAINED_DEPENDENCIES_H
 #define SWIFT_AST_FINE_GRAINED_DEPENDENCIES_H
 
+#include "swift/AST/EvaluatorDependencies.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/Fingerprint.h"
 #include "swift/Basic/LLVM.h"
@@ -57,11 +58,14 @@
 //==============================================================================
 
 namespace swift {
+class Decl;
 class DependencyTracker;
 class DiagnosticEngine;
 class FrontendOptions;
 class ModuleDecl;
 class SourceFile;
+class NominalTypeDecl;
+class ValueDecl;
 
 /// Use a new namespace to help keep the experimental code from clashing.
 namespace fine_grained_dependencies {
@@ -417,6 +421,57 @@ class DependencyKey {
   // For import/export
   friend ::llvm::yaml::MappingTraits<DependencyKey>;
 
+public:
+  class Builder {
+  private:
+    const NodeKind kind;
+    const DeclAspect aspect;
+    const NominalTypeDecl *context;
+    StringRef name;
+
+  private:
+    // A private copy constructor so our clients are forced to use the
+    // move-only builder interface.
+    explicit Builder(NodeKind kind, DeclAspect aspect,
+                     const NominalTypeDecl *context, StringRef name)
+        : kind(kind), aspect(aspect), context(context), name(name) {}
+
+  public:
+    /// Creates a DependencyKey::Builder from the given \p kind and \p aspect
+    /// with a \c null context and empty name.
+    explicit Builder(NodeKind kind, DeclAspect aspect)
+        : kind(kind), aspect(aspect), context(nullptr), name("") {}
+
+  public:
+    /// Consumes this builder and returns a dependency key created from its
+    /// data.
+    DependencyKey build() &&;
+
+  public:
+    /// Extracts the data from the given \p ref into a this builder.
+    Builder fromReference(const evaluator::DependencyCollector::Reference &ref);
+
+  public:
+    /// Extracts the context data from the given declaration, if any.
+    Builder withContext(const Decl *D) &&;
+    /// Extracts the context data from the given decl-member pair, if any.
+    Builder withContext(std::pair<const NominalTypeDecl *, const ValueDecl *>
+                            holderAndMember) &&;
+
+  public:
+    /// Copies the name data for the given swiftdeps file into this builder.
+    Builder withName(StringRef swiftDeps) &&;
+    /// Copies the name of the given declaration into this builder, if any.
+    Builder withName(const Decl *decl) &&;
+    /// Extracts the name from the given decl-member pair, if any.
+    Builder withName(std::pair<const NominalTypeDecl *, const ValueDecl *>
+                         holderAndMember) &&;
+
+  private:
+    static StringRef getTopLevelName(const Decl *decl);
+  };
+
+private:
   NodeKind kind;
   DeclAspect aspect;
   /// The mangled context type name of the holder for \ref potentialMember, \ref
@@ -485,10 +540,6 @@ class DependencyKey {
   template <NodeKind kind, typename Entity>
   static DependencyKey createForProvidedEntityInterface(Entity);
 
-  /// Given some type of provided entity compute the context field of the key.
-  template <NodeKind kind, typename Entity>
-  static std::string computeContextForProvidedEntity(Entity);
-
   DependencyKey correspondingImplementation() const {
     return withAspect(DeclAspect::implementation);
   }
@@ -497,10 +548,6 @@ class DependencyKey {
     return DependencyKey(kind, aspect, context, name);
   }
 
-  /// Given some type of provided entity compute the name field of the key.
-  template <NodeKind kind, typename Entity>
-  static std::string computeNameForProvidedEntity(Entity);
-
   static DependencyKey createKeyForWholeSourceFile(DeclAspect,
                                                    StringRef swiftDeps);
 

include/swift/AST/SILOptions.h

@@ -89,6 +89,11 @@ class SILOptions {
   /// and go from OSSA to non-ownership SIL.
   bool StopOptimizationBeforeLoweringOwnership = false;
 
+  /// Do we always serialize SIL in OSSA form?
+  ///
+  /// If this is disabled we do not serialize in OSSA form when optimizing.
+  bool EnableOSSAModules = false;
+
   // The kind of function bodies to skip emitting.
   FunctionBodySkipping SkipFunctionBodies = FunctionBodySkipping::None;