Merge pull request #4255 from swiftwasm/main

Author: MaxDesiatov

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -825,3 +825,8 @@ also locks.
 Marks a synchronous API as being unavailable from asynchronous contexts. Direct
 usage of annotated API from asynchronous contexts will result in a warning from
 the compiler.
+
+## `@_unsafeInheritExecutor`
+
+This `async` function uses the pre-SE-0338 semantics of unsafely inheriting the caller's executor.  This is an underscored feature because the right way of inheriting an executor is to pass in the required executor and switch to it.  Unfortunately, there are functions in the standard library which need to inherit their caller's executor but cannot change their ABI because they were not defined as `@_alwaysEmitIntoClient` in the initial release.
+

docs/SIL.rst

@@ -3178,7 +3178,7 @@ alloc_stack
 ```````````
 ::
 
-  sil-instruction ::= 'alloc_stack' '[dynamic_lifetime]'? '[lexical]'? sil-type (',' debug-var-attr)*
+  sil-instruction ::= 'alloc_stack' '[dynamic_lifetime]'? '[lexical]'? '[moved]'? sil-type (',' debug-var-attr)*
 
   %1 = alloc_stack $T
   // %1 has type $*T
@@ -3204,6 +3204,12 @@ This is the case, e.g. for conditionally initialized objects.
 The optional ``lexical`` attribute specifies that the storage corresponds to a
 local variable in the Swift source.
 
+The optional ``moved`` attribute specifies that at the source level, the
+variable associated with this alloc_stack was moved and furthermore that at the
+SIL level it passed move operator checking. This means that one can not assume
+that the value in the alloc_stack can be semantically valid over the entire
+function frame when emitting debug info.
+
 The memory is not retainable. To allocate a retainable box for a value
 type, use ``alloc_box``.
 
@@ -3548,7 +3554,7 @@ debug_value
 
 ::
 
-  sil-instruction ::= debug_value '[poison]'? sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
+  sil-instruction ::= debug_value '[poison]'? '[moved]'? sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
 
   debug_value %1 : $Int
 
@@ -3557,6 +3563,11 @@ specified operand.  The declaration in question is identified by either the
 SILLocation attached to the debug_value instruction or the SILLocation specified
 in the advanced debug variable attributes.
 
+If the '[moved]' flag is set, then one knows that the debug_value's operand is
+moved at some point of the program, so one can not model the debug_value using
+constructs that assume that the value is live for the entire function (e.x.:
+llvm.dbg.declare).
+
 ::
 
    debug-var-attr ::= 'var'

include/swift/APIDigester/ModuleAnalyzerNodes.h

@@ -63,8 +63,9 @@ namespace api {
 ///
 /// When the json format changes in a way that requires version-specific handling, this number should be incremented.
 /// This ensures we could have backward compatibility so that version changes in the format won't stop the checker from working.
-const uint8_t DIGESTER_JSON_VERSION = 6; // Add initkind for constructors
+const uint8_t DIGESTER_JSON_VERSION = 7; // push SDKNodeRoot to lower-level
 const uint8_t DIGESTER_JSON_DEFAULT_VERSION = 0; // Use this version number for files before we have a version number in json.
+const StringRef ABIRootKey = "ABIRoot";
 
 class SDKNode;
 typedef SDKNode* NodePtr;
@@ -827,4 +828,13 @@ void nodeSetDifference(ArrayRef<SDKNode*> Left, ArrayRef<SDKNode*> Right,
 } // end of ide namespace
 } // end of Swift namespace
 
+namespace swift {
+namespace json {
+template <> struct ObjectTraits<ide::api::SDKNodeRoot> {
+  static void mapping(Output &out, ide::api::SDKNodeRoot &contents) {
+    contents.jsonize(out);
+  }
+};
+}}
+
 #endif

include/swift/AST/Attr.def

@@ -636,7 +636,11 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
   112)
 
 // 113 was experimental _unsafeSendable and is now unused
-// 114 was experimental _unsafeMainActor and is now unused
+
+SIMPLE_DECL_ATTR(_unsafeInheritExecutor, UnsafeInheritExecutor,
+  OnFunc | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove,
+  114) // previously experimental _unsafeMainActor
 
 SIMPLE_DECL_ATTR(_implicitSelfCapture, ImplicitSelfCapture,
   OnParam | UserInaccessible |

include/swift/AST/Decl.h

@@ -29,6 +29,7 @@
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/LayoutConstraint.h"
 #include "swift/AST/ReferenceCounting.h"
+#include "swift/AST/RequirementSignature.h"
 #include "swift/AST/StorageImpl.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/TypeWalker.h"
@@ -525,7 +526,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     IsComputingSemanticMembers : 1
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(ProtocolDecl, NominalTypeDecl, 1+1+1+1+1+1+1+1+1+1+1+8+16,
+  SWIFT_INLINE_BITFIELD_FULL(ProtocolDecl, NominalTypeDecl, 1+1+1+1+1+1+1+1+1+1+1+8,
     /// Whether the \c RequiresClass bit is valid.
     RequiresClassValid : 1,
 
@@ -564,10 +565,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 
     /// If this is a compiler-known protocol, this will be a KnownProtocolKind
     /// value, plus one. Otherwise, it will be 0.
-    KnownProtocol : 8, // '8' for speed. This only needs 6.
-
-    /// The number of requirements in the requirement signature.
-    NumRequirementsInSignature : 16
+    KnownProtocol : 8 // '8' for speed. This only needs 6.
   );
 
   SWIFT_INLINE_BITFIELD(ClassDecl, NominalTypeDecl, 1+1+2+1+1+1+1+1+1,
@@ -4313,7 +4311,7 @@ class ProtocolDecl final : public NominalTypeDecl {
 
   /// The generic signature representing exactly the new requirements introduced
   /// by this protocol.
-  const Requirement *RequirementSignature = nullptr;
+  Optional<RequirementSignature> RequirementSig;
 
   /// Returns the cached result of \c requiresClass or \c None if it hasn't yet
   /// been computed.
@@ -4574,34 +4572,26 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// requirements. Computed from the structural requirements, above.
   ArrayRef<ProtocolDecl *> getProtocolDependencies() const;
 
-  /// Retrieve the requirements that describe this protocol.
-  ///
-  /// These are the requirements including any inherited protocols
-  /// and conformances for associated types that are introduced in this
-  /// protocol. Requirements implied via any other protocol (e.g., inherited
-  /// protocols of the inherited protocols) are not mentioned. The conformance
-  /// requirements listed here become entries in the witness table.
-  ArrayRef<Requirement> getRequirementSignature() const;
+  /// Retrieve the requirements that describe this protocol from the point of
+  /// view of the generic system; see RequirementSignature.h for details.
+  RequirementSignature getRequirementSignature() const;
 
   /// Is the requirement signature currently being computed?
   bool isComputingRequirementSignature() const;
 
   /// Has the requirement signature been computed yet?
   bool isRequirementSignatureComputed() const {
-    return RequirementSignature != nullptr;
+    return RequirementSig.hasValue();
   }
 
-  void setRequirementSignature(ArrayRef<Requirement> requirements);
+  void setRequirementSignature(RequirementSignature requirementSig);
 
   void setLazyRequirementSignature(LazyMemberLoader *lazyLoader,
                                    uint64_t requirementSignatureData);
 
   void setLazyAssociatedTypeMembers(LazyMemberLoader *lazyLoader,
                                     uint64_t associatedTypesData);
 
-private:
-  ArrayRef<Requirement> getCachedRequirementSignature() const;
-
 public:
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {

include/swift/AST/DeclContext.h

@@ -201,6 +201,7 @@ struct FragileFunctionKind {
     AlwaysEmitIntoClient,
     DefaultArgument,
     PropertyInitializer,
+    BackDeploy,
     None
   };
 

include/swift/AST/DiagnosticsSema.def

@@ -3164,6 +3164,9 @@ ERROR(override_reasync_with_non_reasync,none,
 ERROR(reasync_without_async_parameter,none,
       "'reasync' function must take an 'async' function argument", ())
 
+ERROR(inherits_executor_without_async,none,
+      "non-async functions cannot inherit an executor", ())
+
 ERROR(autoclosure_function_type,none,
       "@autoclosure attribute only applies to function types",
       ())

include/swift/AST/LazyResolver.h

@@ -17,7 +17,6 @@
 #ifndef SWIFT_AST_LAZYRESOLVER_H
 #define SWIFT_AST_LAZYRESOLVER_H
 
-#include "swift/AST/ProtocolConformanceRef.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 
 namespace swift {
@@ -32,6 +31,7 @@ class NominalTypeDecl;
 class NormalProtocolConformance;
 class ProtocolConformance;
 class ProtocolDecl;
+class ProtocolTypeAlias;
 class TypeDecl;
 class ValueDecl;
 class VarDecl;
@@ -99,7 +99,8 @@ class alignas(void*) LazyMemberLoader {
   /// Loads the requirement signature for a protocol.
   virtual void
   loadRequirementSignature(const ProtocolDecl *proto, uint64_t contextData,
-                           SmallVectorImpl<Requirement> &requirements) = 0;
+                           SmallVectorImpl<Requirement> &requirements,
+                           SmallVectorImpl<ProtocolTypeAlias> &typeAliases) = 0;
 
   /// Loads the associated types of a protocol.
   virtual void

include/swift/AST/RequirementSignature.h

@@ -0,0 +1,72 @@
+//===--- RequirementSignature.h - Requirement Signature AST -----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the RequirementSignature class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_REQUIREMENT_SIGNATURE_H
+#define SWIFT_AST_REQUIREMENT_SIGNATURE_H
+
+#include "swift/AST/Type.h"
+
+namespace swift {
+
+/// A description of a typealias defined in a protocol.
+class ProtocolTypeAlias final {
+  Identifier Name;
+  Type UnderlyingType;
+
+public:
+  ProtocolTypeAlias(Identifier name, Type underlyingType)
+    : Name(name), UnderlyingType(underlyingType) {}
+
+  /// Returns the name of the typealias.
+  Identifier getName() const { return Name; }
+
+  /// Returns the underlying type of the typealias.
+  Type getUnderlyingType() const { return UnderlyingType; }
+};
+
+/// The requirements that describe a protocol from the viewpoint of the
+/// generics system.
+class RequirementSignature final {
+  ArrayRef<Requirement> Requirements;
+  ArrayRef<ProtocolTypeAlias> TypeAliases;
+
+public:
+  RequirementSignature() = default;
+
+  RequirementSignature(ArrayRef<Requirement> requirements,
+                       ArrayRef<ProtocolTypeAlias> typeAliases)
+    : Requirements(requirements), TypeAliases(typeAliases) {}
+
+  /// The requirements including any inherited protocols and conformances for
+  /// associated types that are introduced in this protocol.
+  ///
+  /// Requirements implied via any other protocol (e.g., inherited protocols
+  /// of the inherited protocols) are not mentioned.
+  ///
+  /// The conformance requirements listed here become entries in witness tables
+  /// for conformances to this protocol.
+  ArrayRef<Requirement> getRequirements() const {
+    return Requirements;
+  }
+
+  ArrayRef<ProtocolTypeAlias> getTypeAliases() const {
+    return TypeAliases;
+  }
+};
+
+} // end namespace swift
+
+#endif // SWIFT_AST_REQUIREMENT_SIGNATURE_H

include/swift/AST/TypeCheckRequests.h

@@ -476,7 +476,7 @@ class ProtocolDependenciesRequest :
 /// be folded into RequirementSignatureRequest.
 class RequirementSignatureRequestRQM :
     public SimpleRequest<RequirementSignatureRequestRQM,
-                         ArrayRef<Requirement>(ProtocolDecl *),
+                         RequirementSignature(ProtocolDecl *),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -485,7 +485,7 @@ class RequirementSignatureRequestRQM :
   friend SimpleRequest;
 
   // Evaluation.
-  ArrayRef<Requirement>
+  RequirementSignature
   evaluate(Evaluator &evaluator, ProtocolDecl *proto) const;
 
 public:
@@ -495,7 +495,7 @@ class RequirementSignatureRequestRQM :
 /// Compute the requirements that describe a protocol.
 class RequirementSignatureRequest :
     public SimpleRequest<RequirementSignatureRequest,
-                         ArrayRef<Requirement>(ProtocolDecl *),
+                         RequirementSignature(ProtocolDecl *),
                          RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -504,14 +504,14 @@ class RequirementSignatureRequest :
   friend SimpleRequest;
 
   // Evaluation.
-  ArrayRef<Requirement>
+  RequirementSignature
   evaluate(Evaluator &evaluator, ProtocolDecl *proto) const;
 
 public:
   // Separate caching.
   bool isCached() const { return true; }
-  Optional<ArrayRef<Requirement>> getCachedResult() const;
-  void cacheResult(ArrayRef<Requirement> value) const;
+  Optional<RequirementSignature> getCachedResult() const;
+  void cacheResult(RequirementSignature value) const;
 };
 
 /// Compute the default definition type of an associated type.