Merge remote-tracking branch 'origin/main' into bump-swift-version-to-6

Author: shahmishal

include/swift/ABI/MetadataValues.h

@@ -14,14 +14,22 @@
 // includes target-independent information which can be usefully shared
 // between them.
 //
+// This header ought not to include any compiler-specific headers (such as
+// those from `swift/AST`, `swift/SIL`, etc.) since doing so may introduce
+// accidental ABI dependencies on compiler internals.
+//
 //===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_ABI_METADATAVALUES_H
 #define SWIFT_ABI_METADATAVALUES_H
 
 #include "swift/ABI/KeyPath.h"
 #include "swift/ABI/ProtocolDispatchStrategy.h"
+
+// FIXME: this include shouldn't be here, but removing it causes symbol
+// mangling mismatches on Windows for some reason?
 #include "swift/AST/Ownership.h"
+
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/FlagSet.h"
@@ -1187,6 +1195,9 @@ class TargetExtendedFunctionTypeFlags {
 
     // Values for the enumerated isolation kinds
     IsolatedAny            = 0x00000002U,
+
+    // Values if we have a transferring result.
+    HasTransferringResult  = 0x00000010U,
   };
   int_type Data;
 
@@ -1211,12 +1222,23 @@ class TargetExtendedFunctionTypeFlags {
               (Data & ~IsolationMask) | IsolatedAny);
   }
 
+  const TargetExtendedFunctionTypeFlags<int_type>
+  withTransferringResult(bool newValue = true) const {
+    return TargetExtendedFunctionTypeFlags<int_type>(
+        (Data & ~HasTransferringResult) |
+        (newValue ? HasTransferringResult : 0));
+  }
+
   bool isTypedThrows() const { return bool(Data & TypedThrowsMask); }
 
   bool isIsolatedAny() const {
     return (Data & IsolationMask) == IsolatedAny;
   }
 
+  bool hasTransferringResult() const {
+    return bool(Data & HasTransferringResult);
+  }
+
   int_type getIntValue() const {
     return Data;
   }
@@ -1234,14 +1256,30 @@ class TargetExtendedFunctionTypeFlags {
 };
 using ExtendedFunctionTypeFlags = TargetExtendedFunctionTypeFlags<uint32_t>;
 
+/// Different kinds of value ownership supported by function types.
+enum class ParameterOwnership : uint8_t {
+  /// the context-dependent default ownership (sometimes shared,
+  /// sometimes owned)
+  Default,
+  /// an 'inout' exclusive, mutating borrow
+  InOut,
+  /// a 'borrowing' nonexclusive, usually nonmutating borrow
+  Shared,
+  /// a 'consuming' ownership transfer
+  Owned,
+
+  Last_Kind = Owned
+};
+
 template <typename int_type>
 class TargetParameterTypeFlags {
   enum : int_type {
-    ValueOwnershipMask    = 0x7F,
+    OwnershipMask         = 0x7F,
     VariadicMask          = 0x80,
     AutoClosureMask       = 0x100,
     NoDerivativeMask      = 0x200,
     IsolatedMask          = 0x400,
+    TransferringMask      = 0x800,
   };
   int_type Data;
 
@@ -1251,8 +1289,8 @@ class TargetParameterTypeFlags {
   constexpr TargetParameterTypeFlags() : Data(0) {}
 
   constexpr TargetParameterTypeFlags<int_type>
-  withValueOwnership(ValueOwnership ownership) const {
-    return TargetParameterTypeFlags<int_type>((Data & ~ValueOwnershipMask) |
+  withOwnership(ParameterOwnership ownership) const {
+    return TargetParameterTypeFlags<int_type>((Data & ~OwnershipMask) |
                                               (int_type)ownership);
   }
 
@@ -1280,14 +1318,21 @@ class TargetParameterTypeFlags {
         (Data & ~IsolatedMask) | (isIsolated ? IsolatedMask : 0));
   }
 
+  constexpr TargetParameterTypeFlags<int_type>
+  withTransferring(bool isTransferring) const {
+    return TargetParameterTypeFlags<int_type>(
+        (Data & ~TransferringMask) | (isTransferring ? TransferringMask : 0));
+  }
+
   bool isNone() const { return Data == 0; }
   bool isVariadic() const { return Data & VariadicMask; }
   bool isAutoClosure() const { return Data & AutoClosureMask; }
   bool isNoDerivative() const { return Data & NoDerivativeMask; }
   bool isIsolated() const { return Data & IsolatedMask; }
+  bool isTransferring() const { return Data & TransferringMask; }
 
-  ValueOwnership getValueOwnership() const {
-    return (ValueOwnership)(Data & ValueOwnershipMask);
+  ParameterOwnership getOwnership() const {
+    return (ParameterOwnership)(Data & OwnershipMask);
   }
 
   int_type getIntValue() const { return Data; }

include/swift/AST/Decl.h

@@ -32,6 +32,7 @@
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/Import.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/InverseMarking.h"
 #include "swift/AST/LayoutConstraint.h"
 #include "swift/AST/LifetimeAnnotation.h"
 #include "swift/AST/ReferenceCounting.h"
@@ -3219,30 +3220,6 @@ class TypeDecl : public ValueDecl {
     };
   };
 
-  /// "Does a conformance for Copyable exist for this type declaration?"
-  ///
-  /// This doesn't mean that all instance of this type are Copyable, because
-  /// if a conditional conformance to Copyable exists, this method will return
-  /// true.
-  ///
-  /// If you need a more precise answer, ask this Decl's corresponding
-  /// Type if it `isCopyable` instead of using this.
-  CanBeInvertible::Result canBeCopyable() const;
-
-  /// "Does a conformance for Escapable exist for this type declaration?"
-  ///
-  /// This doesn't mean that all instance of this type are Escapable, because
-  /// if a conditional conformance to Escapable exists, this method will return
-  /// true.
-  ///
-  /// If you need a more precise answer, ask this Decl's corresponding
-  /// Type if it `isEscapable` instead of using this.
-  CanBeInvertible::Result canBeEscapable() const;
-
-  /// Determine how the given invertible protocol was written on this TypeDecl,
-  /// if at all.
-  InverseMarking getMarking(InvertibleProtocolKind ip) const;
-
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&
            D->getKind() <= DeclKind::Last_TypeDecl;
@@ -3260,7 +3237,7 @@ class TypeDecl : public ValueDecl {
   }
 };
 
-/// A type declaration that can have generic parameters attached to it. Because
+/// A type declaration that  have generic parameters attached to it. Because
 /// it has these generic parameters, it is always a DeclContext.
 class GenericTypeDecl : public GenericContext, public TypeDecl {
 public:
@@ -3935,6 +3912,10 @@ class AssociatedTypeDecl : public TypeDecl {
         TypeDecl::getOverriddenDecl());
   }
 
+  /// Determine whether this type has ~<target>` stated as
+  /// one of its inherited types.
+  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
+
   /// Retrieve the set of associated types overridden by this associated
   /// type.
   llvm::TinyPtrVector<AssociatedTypeDecl *> getOverriddenDecls() const;
@@ -4372,6 +4353,34 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Returns null if the type is a class, or does not have a declared `deinit`.
   DestructorDecl *getValueTypeDestructor();
 
+  /// "Does a conformance for Copyable exist for this type declaration?"
+  ///
+  /// This doesn't mean that all instance of this type are Copyable, because
+  /// if a conditional conformance to Copyable exists, this method will return
+  /// true.
+  ///
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isCopyable` instead of using this.
+  CanBeInvertible::Result canBeCopyable() const;
+
+  /// "Does a conformance for Escapable exist for this type declaration?"
+  ///
+  /// This doesn't mean that all instance of this type are Escapable, because
+  /// if a conditional conformance to Escapable exists, this method will return
+  /// true.
+  ///
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isEscapable` instead of using this.
+  CanBeInvertible::Result canBeEscapable() const;
+
+  /// Determine whether this type has `: <target>` stated explicitly in
+  /// its inheritance clause.
+  bool hasMarking(InvertibleProtocolKind target) const;
+
+  /// Determine whether this type has ~<target>` stated on
+  /// itself, one of its inherited types or `Self` requirements.
+  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_NominalTypeDecl &&
@@ -5227,6 +5236,10 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// protocol.
   bool inheritsFrom(const ProtocolDecl *Super) const;
 
+  /// Determine whether this protocol has ~<target>` stated on
+  /// itself, one of its inherited types or `Self` requirements.
+  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
+
   /// Determine whether this protocol requires conformance to `IP`, without
   /// querying a generic signature.
   bool requiresInvertible(InvertibleProtocolKind ip) const;

include/swift/AST/DiagnosticsSema.def

@@ -808,6 +808,19 @@ WARNING(sema_import_current_module_with_file,none,
 ERROR(sema_opening_import,Fatal,
       "opening import file for module %0: %1", (Identifier, StringRef))
 
+REMARK(serialization_skipped_invalid_decl,none,
+       "serialization skipped invalid %kind0",
+       (const Decl *))
+REMARK(serialization_skipped_invalid_type,none,
+       "serialization skipped for invalid type %0",
+       (TypeRepr *))
+REMARK(serialization_skipped_invalid_type_unknown_name,none,
+       "serialization skipped for invalid type",
+       ())
+ERROR(serialization_failed,none,
+      "serialization of module %0 failed due to the errors above",
+      (const ModuleDecl *))
+
 ERROR(serialization_load_failed,Fatal,
       "failed to load module '%0'", (StringRef))
 ERROR(module_interface_build_failed,Fatal,

include/swift/AST/InverseMarking.h

@@ -19,8 +19,6 @@
 
 namespace swift {
 
-class InvertibleAnnotationRequest;
-
 /// Describes the way an inverse and its corresponding positive contraint
 /// appears on a TypeDecl, i.e., the way it was marked.
 struct InverseMarking {
@@ -91,8 +89,6 @@ struct InverseMarking {
   Mark inverse;
   Mark positive;
 
-  // This friend initializes the marks.
-  friend InvertibleAnnotationRequest;
 public:
 
   // Creates an empty marking.

include/swift/AST/Ownership.h

@@ -142,6 +142,14 @@ enum class ValueOwnership : uint8_t {
 enum : unsigned { NumValueOwnershipBits =
   countBitsUsed(static_cast<unsigned>(ValueOwnership::Last_Kind)) };
 
+enum class ParameterOwnership : uint8_t;
+
+/// Map a `ValueOwnership` to the corresponding ABI-stable constant used by
+/// runtime metadata.
+ParameterOwnership asParameterOwnership(ValueOwnership o);
+/// Map an ABI-stable ownership identifier to a `ValueOwnership`.
+ValueOwnership asValueOwnership(ParameterOwnership o);
+
 static inline llvm::StringRef getOwnershipSpelling(ValueOwnership ownership) {
   switch (ownership) {
   case ValueOwnership::Default:

include/swift/AST/TypeCheckRequests.h

@@ -429,28 +429,6 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
-/// Determine the kind of invertible protocol markings for this declaration,
-/// for example, if a conformance to IP or ~IP was written on it in the
-/// inheritance clause and/or where clause.
-class InvertibleAnnotationRequest
-    : public SimpleRequest<InvertibleAnnotationRequest,
-                           InverseMarking(TypeDecl *, InvertibleProtocolKind),
-                           RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  InverseMarking evaluate(Evaluator &evaluator,
-                          TypeDecl *decl, InvertibleProtocolKind ip) const;
-
-public:
-  // Caching.
-  bool isCached() const { return true; }
-};
-
 /// Determine whether the given declaration is 'dynamic''.
 class IsDynamicRequest :
     public SimpleRequest<IsDynamicRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -217,9 +217,6 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, InvertibleAnnotationRequest,
-              InverseMarking(TypeDecl *, InvertibleProtocolKind),
-              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsGetterMutatingRequest, bool(AbstractStorageDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsImplicitlyUnwrappedOptionalRequest,

include/swift/AST/TypeRepr.h

@@ -137,6 +137,10 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   /// Is this type representation a protocol?
   bool isProtocolOrProtocolComposition(DeclContext *dc);
 
+  /// Is this `~<target>` representation.
+  bool isInverseOf(InvertibleProtocolKind target,
+                   DeclContext *dc);
+
   /// Is this type representation known to be invalid?
   bool isInvalid() const { return Bits.TypeRepr.Invalid; }
 

include/swift/AST/Types.h

@@ -1146,25 +1146,16 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// function with each archetype-to-substituted-type binding. The callback
   /// may return a new type to substitute into the result type, or return
   /// CanType() to error out of the operation. Each invocation of the callback
-  /// receives three arguments:
+  /// receives two arguments:
   /// - The `orig` archetype from a position in `this` type.
-  /// - The `subst` type in the same structural position of `ty` that is trying to be bound
-  ///  to `orig`.
-  /// - The `upperBound` archetype, which if set, indicates the minimum set of constraints
-  ///  that any type substituted in this structural position must conform to. May be null,
-  ///  indicating an unconstrained context.
-  /// - If `upperBound` is set, then the `substConformances` array will contain the
-  ///  protocol conformances for `subst` to each of the protocol requirements
-  ///  on `upperBound` in `getConformsTo` order.
+  /// - The `subst` type in the same structural position of `ty` that is trying
+  /// to be bound to `orig`.
   ///
   /// Returns the substituted type, or a null CanType() if this type
   /// is not bindable to the substituted type, or the callback returns
   /// CanType().
   CanType substituteBindingsTo(Type ty,
-         llvm::function_ref<CanType(ArchetypeType *orig,
-                CanType subst,
-                ArchetypeType *upperBound,
-                ArrayRef<ProtocolConformanceRef> substConformances)> substFn);
+         llvm::function_ref<CanType(ArchetypeType *orig, CanType subst)> substFn);
 
   /// Determines whether this type is similar to \p other as defined by
   /// \p matchOptions.

include/swift/Basic/Features.def

@@ -125,6 +125,7 @@ LANGUAGE_FEATURE(TypedThrows, 413, "Typed throws")
 LANGUAGE_FEATURE(OptionalIsolatedParameters, 420, "Optional isolated parameters")
 SUPPRESSIBLE_LANGUAGE_FEATURE(Extern, 0, "@_extern")
 LANGUAGE_FEATURE(ExpressionMacroDefaultArguments, 422, "Expression macro as caller-side default argument")
+LANGUAGE_FEATURE(BuiltinStoreRaw, 0, "Builtin.storeRaw")
 
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
 UPCOMING_FEATURE(ForwardTrailingClosures, 286, 6)

include/swift/Basic/LangOptions.h

@@ -243,6 +243,9 @@ namespace swift {
     /// Emit remarks about contextual inconsistencies in loaded modules.
     bool EnableModuleRecoveryRemarks = false;
 
+    /// Emit remarks for unexpected conditions when serializing a module.
+    bool EnableModuleSerializationRemarks = false;
+
     /// Emit remarks about the source of each element exposed by the module API.
     bool EnableModuleApiImportRemarks = false;
 

include/swift/Demangling/Demangle.h

@@ -278,7 +278,7 @@ class Node {
   /// Prints the whole node tree in readable form to stderr.
   ///
   /// Useful to be called from the debugger.
-  void dump();
+  void dump() LLVM_ATTRIBUTE_USED;
 };
 
 /// Returns the length of the swift mangling prefix of the \p SymbolName.
@@ -555,6 +555,7 @@ struct [[nodiscard]] ManglingError {
     InvalidImplDifferentiability,
     InvalidImplFunctionAttribute,
     InvalidImplParameterConvention,
+    InvalidImplParameterTransferring,
     InvalidMetatypeRepresentation,
     MultiByteRelatedEntity,
     BadValueWitnessKind,