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

Author: ktoso

CMakeLists.txt

@@ -201,7 +201,7 @@ option(USE_SWIFT_ASYNC_LOWERING
         functions if it is supported for the target. The runtime also checks
         this setting before using async-specific attributes. This only applies
         to the async calling convention and not to the async context attribute."
-	FALSE)
+	TRUE)
 
 #
 # User-configurable Swift Standard Library specific options.

benchmark/single-source/Substring.swift

@@ -29,6 +29,7 @@ public let SubstringTest = [
   BenchmarkInfo(name: "SubstringEquatable", runFunction: run_SubstringEquatable, tags: [.validation, .api, .String]),
   BenchmarkInfo(name: "SubstringFromLongString", runFunction: run_SubstringFromLongString, tags: [.validation, .api, .String]),
   BenchmarkInfo(name: "SubstringFromLongStringGeneric", runFunction: run_SubstringFromLongStringGeneric, tags: [.validation, .api, .String]),
+  BenchmarkInfo(name: "SubstringTrimmingASCIIWhitespace", runFunction: run_SubstringTrimmingASCIIWhitespace, tags: [.validation, .api, .String]),
 ]
 
 // A string that doesn't fit in small string storage and doesn't fit in Latin-1
@@ -267,6 +268,38 @@ public func run_SubstringComparable(_ N: Int) {
   CheckResults(count == N*500)
 }
 
+extension Character {
+  fileprivate var isASCIIWhitespace: Bool {
+    return self == " " || self == "\t" || self == "\r" || self == "\n" || self == "\r\n"
+  }
+}
+
+extension Substring {
+  fileprivate func trimWhitespace() -> Substring {
+    var me = self
+    while me.first?.isASCIIWhitespace == .some(true) {
+      me = me.dropFirst()
+    }
+    while me.last?.isASCIIWhitespace == .some(true) {
+      me = me.dropLast()
+    }
+    return me
+  }
+}
+
+let _trimmableSubstrings = "pineapple,🍍,  pineapple\t,\r\n\r\n\r\n, 🍍 ,".split(separator: ",")
+
+@inline(never)
+public func run_SubstringTrimmingASCIIWhitespace(_ N: Int) {
+  let substrings = _trimmableSubstrings // bringing this alias from above
+  var count = 0
+  for _ in 1...N*100 {
+    for substring in substrings {
+      blackHole(substring.trimWhitespace())
+    }
+  }
+}
+
 /*
 func checkLess<T, U>(_ x: T, _ y: U)
 where T : StringProtocol, U : StringProtocol {

docs/SIL.rst

@@ -3540,43 +3540,57 @@ load_borrow
    %1 = load_borrow %0 : $*T
    // $T must be a loadable type
 
-Loads the value ``%1`` from the memory location ``%0``. The ``load_borrow``
+Loads the value ``%1`` from the memory location ``%0``. The `load_borrow`_
 instruction creates a borrowed scope in which a read-only borrow value ``%1``
 can be used to read the value stored in ``%0``. The end of scope is delimited
-by an ``end_borrow`` instruction. All ``load_borrow`` instructions must be
-paired with exactly one ``end_borrow`` instruction along any path through the
-program. Until ``end_borrow``, it is illegal to invalidate or store to ``%0``.
+by an `end_borrow`_ instruction. All `load_borrow`_ instructions must be
+paired with exactly one `end_borrow`_ instruction along any path through the
+program. Until `end_borrow`_, it is illegal to invalidate or store to ``%0``.
 
 begin_borrow
 ````````````
 
-TODO
+::
+
+   sil-instruction ::= 'begin_borrow' sil-operand
+
+   %1 = begin_borrow %0 : $T
+
+Given a value ``%0`` with `Owned`_ or `Guaranteed`_ ownership, produces a new
+same typed value with `Guaranteed`_ ownership: ``%1``. ``%1`` is guaranteed to
+have a lifetime ending use (e.x.: `end_borrow`_) along all paths that do not end
+in `Dead End Blocks`_. This `begin_borrow`_ and the lifetime ending uses of
+``%1`` are considered to be liveness requiring uses of ``%0`` and as such in the
+region in between this borrow and its lifetime ending use, ``%0`` must be
+live. This makes sense semantically since ``%1`` is modeling a new value with a
+dependent lifetime on ``%0``.
+
+This instruction is only valid in functions in Ownership SSA form.
 
 end_borrow
 ``````````
 
 ::
 
-   sil-instruction ::= 'end_borrow' sil-value 'from' sil-value : sil-type, sil-type
+   sil-instruction ::= 'end_borrow' sil-operand
 
-   end_borrow %1 from %0 : $T, $T
-   end_borrow %1 from %0 : $T, $*T
-   end_borrow %1 from %0 : $*T, $T
-   end_borrow %1 from %0 : $*T, $*T
-   // We allow for end_borrow to be specified in between values and addresses
-   // all of the same type T.
+   // somewhere earlier
+   // %1 = begin_borrow %0
+   end_borrow %1 : $T
 
-Ends the scope for which the SILValue ``%1`` is borrowed from the SILValue
-``%0``. Must be paired with at most 1 borrowing instruction (like
-``load_borrow``) along any path through the program. In the region in between
-the borrow instruction and the ``end_borrow``, the original SILValue can not be
-modified. This means that:
+Ends the scope for which the `Guaranteed`_ ownership possessing SILValue ``%1``
+is borrowed from the SILValue ``%0``. Must be paired with at most 1 borrowing
+instruction (like `load_borrow`_, `begin_borrow`_) along any path through the
+program. In the region in between the borrow instruction and the `end_borrow`_,
+the original SILValue can not be modified. This means that:
 
 1. If ``%0`` is an address, ``%0`` can not be written to.
 2. If ``%0`` is a non-trivial value, ``%0`` can not be destroyed.
 
 We require that ``%1`` and ``%0`` have the same type ignoring SILValueCategory.
 
+This instruction is only valid in functions in Ownership SSA form.
+
 assign
 ``````
 ::
@@ -3592,12 +3606,12 @@ The type of %1 is ``*T`` and the type of ``%0`` is ``T``, which must be a
 loadable type. This will overwrite the memory at ``%1`` and destroy the value
 currently held there.
 
-The purpose of the ``assign`` instruction is to simplify the
+The purpose of the `assign`_ instruction is to simplify the
 definitive initialization analysis on loadable variables by removing
 what would otherwise appear to be a load and use of the current value.
 It is produced by SILGen, which cannot know which assignments are
 meant to be initializations.  If it is deemed to be an initialization,
-it can be replaced with a ``store``; otherwise, it must be replaced
+it can be replaced with a `store`_; otherwise, it must be replaced
 with a sequence that also correctly destroys the current value.
 
 This instruction is only valid in Raw SIL and is rewritten as appropriate
@@ -3615,7 +3629,7 @@ assign_by_wrapper
   // $F must be a function type, taking $S as a single argument (or multiple arguments in case of a tuple) and returning $T
   // $G must be a function type, taking $S as a single argument (or multiple arguments in case of a tuple) and without a return value
 
-Similar to the ``assign`` instruction, but the assignment is done via a
+Similar to the `assign`_ instruction, but the assignment is done via a
 delegate.
 
 In case of an initialization, the function ``%2`` is called with ``%0`` as
@@ -4245,7 +4259,9 @@ object. Returns 1 if the strong reference count is 1, and 0 if the
 strong reference count is greater than 1.
 
 A discussion of the semantics can be found here:
-:ref:`arcopts.is_unique`.
+`is_unique instruction <arcopts_is_unique_>`_
+
+.. _arcopts_is_unique: https://github.com/apple/swift/blob/main/docs/ARCOptimization.md#is_unique-instruction
 
 begin_cow_mutation
 ``````````````````

include/swift/AST/DiagnosticsParse.def

@@ -248,6 +248,8 @@ ERROR(computed_property_no_accessors, none,
       "%select{computed property|subscript}0 must have accessors specified", (bool))
 ERROR(expected_getset_in_protocol,none,
       "expected get or set in a protocol property", ())
+ERROR(unexpected_getset_implementation_in_protocol,none,
+      "protocol property %0 cannot have a default implementation specified here; use extension instead", (StringRef))
 ERROR(computed_property_missing_type,none,
       "computed property must have an explicit type", ())
 ERROR(getset_nontrivial_pattern,none,

include/swift/AST/DiagnosticsSema.def

@@ -1902,6 +1902,12 @@ ERROR(type_does_not_conform_owner,none,
 ERROR(type_does_not_conform_in_decl_ref,none,
       "referencing %0 %1 on %2 requires that %3 conform to %4",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))
+ERROR(contextual_member_ref_on_protocol_requires_self_requirement,none,
+      "contextual member reference to %0 %1 requires "
+      "'Self' constraint in the protocol extension",
+      (DescriptiveDeclKind, DeclName))
+NOTE(missing_sametype_requirement_on_self,none,
+      "missing same-type requirement on 'Self'", ())
 ERROR(type_does_not_conform_anyobject_in_decl_ref,none,
       "referencing %0 %1 on %2 requires that %3 be a class type",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))

include/swift/AST/GenericSignature.h

@@ -234,13 +234,6 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   mutable llvm::PointerUnion<const GenericSignatureImpl *, ASTContext *>
     CanonicalSignatureOrASTContext;
 
-  void buildConformanceAccessPath(
-      SmallVectorImpl<ConformanceAccessPath::Entry> &path,
-      ArrayRef<Requirement> reqs,
-      const void /*GenericSignatureBuilder::RequirementSource*/ *source,
-      ProtocolDecl *conformingProto, Type rootType,
-      ProtocolDecl *requirementSignatureProto) const;
-
   friend class ArchetypeType;
 
 public:

include/swift/AST/GenericSignatureBuilder.h

@@ -626,7 +626,6 @@ class GenericSignatureBuilder {
   /// After this point, one cannot introduce new requirements, and the
   /// generic signature builder no longer has valid state.
   GenericSignature computeGenericSignature(
-                      SourceLoc loc,
                       bool allowConcreteGenericParams = false,
                       bool allowBuilderToMove = true) &&;
 
@@ -639,8 +638,7 @@ class GenericSignatureBuilder {
   ///
   /// \param allowConcreteGenericParams If true, allow generic parameters to
   /// be made concrete.
-  void finalize(SourceLoc loc,
-                TypeArrayView<GenericTypeParamType> genericParams,
+  void finalize(TypeArrayView<GenericTypeParamType> genericParams,
                 bool allowConcreteGenericParams=false);
 
 public:
@@ -923,10 +921,6 @@ class GenericSignatureBuilder::RequirementSource final
   /// Whether there is a trailing written requirement location.
   const bool hasTrailingWrittenRequirementLoc;
 
-public:
-  /// Whether a protocol requirement came from the requirement signature.
-  const bool usesRequirementSignature;
-
 private:
   /// The actual storage, described by \c storageKind.
   union {
@@ -1022,7 +1016,7 @@ class GenericSignatureBuilder::RequirementSource final
                     WrittenRequirementLoc writtenReqLoc)
     : kind(kind), storageKind(StorageKind::StoredType),
       hasTrailingWrittenRequirementLoc(!writtenReqLoc.isNull()),
-      usesRequirementSignature(false), parent(nullptr) {
+      parent(nullptr) {
     assert(isAcceptableStorageKind(kind, storageKind) &&
            "RequirementSource kind/storageKind mismatch");
 
@@ -1038,7 +1032,6 @@ class GenericSignatureBuilder::RequirementSource final
                     WrittenRequirementLoc writtenReqLoc)
     : kind(kind), storageKind(StorageKind::StoredType),
       hasTrailingWrittenRequirementLoc(!writtenReqLoc.isNull()),
-      usesRequirementSignature(!protocol->isComputingRequirementSignature()),
       parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");
@@ -1055,8 +1048,7 @@ class GenericSignatureBuilder::RequirementSource final
   RequirementSource(Kind kind, const RequirementSource *parent,
                     ProtocolConformanceRef conformance)
     : kind(kind), storageKind(StorageKind::ProtocolConformance),
-      hasTrailingWrittenRequirementLoc(false),
-      usesRequirementSignature(false), parent(parent) {
+      hasTrailingWrittenRequirementLoc(false), parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");
     assert(isAcceptableStorageKind(kind, storageKind) &&
@@ -1068,8 +1060,7 @@ class GenericSignatureBuilder::RequirementSource final
   RequirementSource(Kind kind, const RequirementSource *parent,
                     AssociatedTypeDecl *assocType)
     : kind(kind), storageKind(StorageKind::AssociatedTypeDecl),
-      hasTrailingWrittenRequirementLoc(false),
-      usesRequirementSignature(false), parent(parent) {
+      hasTrailingWrittenRequirementLoc(false), parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");
     assert(isAcceptableStorageKind(kind, storageKind) &&
@@ -1080,8 +1071,7 @@ class GenericSignatureBuilder::RequirementSource final
 
   RequirementSource(Kind kind, const RequirementSource *parent)
     : kind(kind), storageKind(StorageKind::None),
-      hasTrailingWrittenRequirementLoc(false),
-      usesRequirementSignature(false), parent(parent) {
+      hasTrailingWrittenRequirementLoc(false), parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");
     assert(isAcceptableStorageKind(kind, storageKind) &&
@@ -1091,8 +1081,7 @@ class GenericSignatureBuilder::RequirementSource final
   RequirementSource(Kind kind, const RequirementSource *parent,
                     Type newType)
     : kind(kind), storageKind(StorageKind::StoredType),
-      hasTrailingWrittenRequirementLoc(false),
-      usesRequirementSignature(false), parent(parent) {
+      hasTrailingWrittenRequirementLoc(false), parent(parent) {
     assert((static_cast<bool>(parent) != isRootKind(kind)) &&
            "Root RequirementSource should not have parent (or vice versa)");
     assert(isAcceptableStorageKind(kind, storageKind) &&

include/swift/AST/RawComment.h

@@ -98,7 +98,9 @@ struct BasicDeclLocs {
 
 struct BasicSourceFileInfo {
   StringRef FilePath;
-  Fingerprint InterfaceHash = Fingerprint::ZERO();
+  /// Used for completion; factors in hashes from type-bodies in order to be sensitive to changes in
+  /// the intefaces of top-level type members.
+  Fingerprint InterfaceHashIncludingTypeMembers = Fingerprint::ZERO();
   llvm::sys::TimePoint<> LastModified = {};
   uint64_t FileSize = 0;
 

include/swift/Runtime/Concurrency.h

@@ -121,6 +121,10 @@ void swift_task_cancel(AsyncTask *task);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_cancel_group_child_tasks(AsyncTask *task, TaskGroup *group);
 
+/// Get 'active' AsyncTask, depending on platform this may use thread local storage.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+AsyncTask* swift_task_get_active();
+
 /// Escalate the priority of a task and all of its child tasks.
 ///
 /// This can be called from any thread.

include/swift/SIL/SILInstruction.h

@@ -1025,6 +1025,16 @@ class OwnershipForwardingMixin {
   }
 
 public:
+  /// Forwarding ownership is determined by the forwarding instruction's
+  /// constant ownership attribute. If forwarding ownership is owned, then the
+  /// instruction moves an owned operand to its result, ending its lifetime. If
+  /// forwarding ownership is guaranteed, then the instruction propagates the
+  /// lifetime of its borrows operand through its result.
+  ///
+  /// The resulting forwarded value's ownership, returned by getOwnershipKind(),
+  /// is not identical to the forwarding ownership. It differs when the result
+  /// is trivial type. e.g. an owned or guaranteed value can be cast to a
+  /// trivial type using owned or guaranteed forwarding.
   ValueOwnershipKind getForwardingOwnershipKind() const {
     return ownershipKind;
   }