Merge pull request #4474 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

CHANGELOG.md

@@ -5,6 +5,88 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* References to `optional` methods on a protocol metatype, as well as references to dynamically looked up methods on the `AnyObject` metatype are now supported. These references always have the type of a function that accepts a single argument and returns an optional value of function type:
+
+  ```swift
+  class Object {
+    @objc func getTag() -> Int
+  }
+
+  @objc protocol P {
+    @objc optional func didUpdateObject(withTag tag: Int)
+  }
+
+  let getTag: (AnyObject) -> (() -> Int)? = AnyObject.getTag
+
+  let didUpdateObject: (any P) -> ((Int) -> Void)? = P.didUpdateObject
+  ```
+
+* [SE-0349][]:
+
+  Loading data from raw memory represented by `UnsafeRawPointer`,
+  `UnsafeRawBufferPointer` and their mutable counterparts now supports unaligned
+  accesses. This previously required a workaround involving an intermediate
+  copy:
+
+  ```swift
+  let result = unalignedData.withUnsafeBytes { buffer -> UInt32 in
+    var storage = UInt32.zero
+    withUnsafeMutableBytes(of: &storage) {
+      $0.copyBytes(from: buffer.prefix(MemoryLayout<UInt32>.size))
+    }
+    return storage
+  }
+  ```
+  Now:
+  ```swift
+  let result = unalignedData.withUnsafeBytes { $0.loadUnaligned(as: UInt32.self) }
+  ```
+  Additionally, the counterpart `storeBytes(of:toByteOffset:as:)` had its
+  alignment restriction lifted, so that storing to arbitrary offsets of raw
+  memory can now succeed.
+
+* [SE-0334][]:
+
+  - `UnsafeRawPointer` and `UnsafeMutableRawPointer` have new functionality for
+  pointer arithmetic, adding functions to obtain a pointer advanced to the next
+  or previous alignment boundary:
+
+    ```swift
+    extension UnsafeRawPointer {
+      public func alignedUp<T>(for: T.type) -> UnsafeRawPointer
+      public func alignedDown<T>(for: T.type) -> UnsafeRawPointer
+      public func alignedUp(toMultipleOf alignment: Int) -> UnsafeRawPointer
+      public func alignedDown(toMultipleOf alignment: Int) -> UnsafeRawPointer
+    }
+    ```
+  - It is now possible to use a pointer to `struct` to obtain a pointer to one
+  of its stored properties:
+
+    ```swift
+    withUnsafeMutablePointer(to: &myStruct) {
+      let interiorPointer = $0.pointer(to: \.myProperty)!
+      return myCFunction(interiorPointer)
+    }
+    ```
+  - Comparisons between pointers have been simplified by being more permissive.
+  Since pointers are representations of memory locations within a single pool of
+  underlying memory, Swift now allows comparing pointers without requiring type
+  conversions with the `==`, `!=`, `<`,`<=`,`>`, and `>=` operators. 
+
+* [SE-0333][]:
+
+  It is now possible to use the `withMemoryRebound<T>()` method on raw memory,
+  that is `UnsafeRawPointer` , `UnsafeRawBufferPointer` and their mutable
+  counterparts. Additionally, we clarified the semantics of
+  `withMemoryRebound<T>()` when used on typed memory (`UnsafePointer<Pointee>`,
+  `UnsafeBufferPointer<Pointee>` and their mutable counterparts). Whereas
+  `Pointee` and `T` were previously required to have the same stride, you can
+  now rebind in cases where `Pointee` is an aggregate of `T` or vice-versa. For
+  example, given an `UnsafeMutableBufferPointer<CGPoint>`, you can now use
+  `withMemoryRebound` to operate temporarily on a
+  `UnsafeMutableBufferPointer<CGFloat>`, because `CGPoint` is an aggregate of
+  `CGFloat`.
+
 * [SE-0352][]:
 
   It's now possible to call a generic function with a value of protocol type
@@ -32,7 +114,7 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
   It's now possible to use a default value expression with a generic parameter type
   to default the argument and its type:
 
-  ```
+  ```swift
   func compute<C: Collection>(_ values: C = [0, 1, 2]) {
     ...
   }
@@ -128,7 +210,7 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
   Distributed actors provide stronger isolation guarantees than "local" actors, and enable additional checks to be made on return types and parameters of distributed methods, e.g. checking if they conform to `Codable`. Distributed methods can be called on "remote" references of distributed actors, turning those invocations into remote procedure calls, by means of pluggable and user extensible distributed actor system implementations. 
 
-  Swift does not provide any specific distributed actor system by itself, however, packages in the ecosystem fulfil the role of providing those implementations.
+  Swift does not provide any specific distributed actor system by itself, however, packages in the ecosystem fulfill the role of providing those implementations.
 
   ```swift
   distributed actor Greeter { 
@@ -9170,20 +9252,23 @@ Swift 1.0
 [SE-0316]: <https://github.com/apple/swift-evolution/blob/main/proposals/0316-global-actors.md>
 [SE-0320]: <https://github.com/apple/swift-evolution/blob/main/proposals/0320-codingkeyrepresentable.md>
 [SE-0322]: <https://github.com/apple/swift-evolution/blob/main/proposals/0322-temporary-buffers.md>
-[SE-0324]: <https://github.com/apple/swift-evolution/blob/main/proposals/0324-c-lang-pointer-arg-conversion.md>
 [SE-0323]: <https://github.com/apple/swift-evolution/blob/main/proposals/0323-async-main-semantics.md>
+[SE-0324]: <https://github.com/apple/swift-evolution/blob/main/proposals/0324-c-lang-pointer-arg-conversion.md>
+[SE-0326]: <https://github.com/apple/swift-evolution/blob/main/proposals/0326-extending-multi-statement-closure-inference.md>
 [SE-0327]: <https://github.com/apple/swift-evolution/blob/main/proposals/0327-actor-initializers.md>
 [SE-0328]: <https://github.com/apple/swift-evolution/blob/main/proposals/0328-structural-opaque-result-types.md>
 [SE-0331]: <https://github.com/apple/swift-evolution/blob/main/proposals/0331-remove-sendable-from-unsafepointer.md>
-[SE-0337]: <https://github.com/apple/swift-evolution/blob/main/proposals/0337-support-incremental-migration-to-concurrency-checking.md>
+[SE-0333]: <https://github.com/apple/swift-evolution/blob/main/proposals/0333-with-memory-rebound.md>
+[SE-0334]: <https://github.com/apple/swift-evolution/blob/main/proposals/0334-pointer-usability-improvements.md>
 [SE-0335]: <https://github.com/apple/swift-evolution/blob/main/proposals/0335-existential-any.md>
-[SE-0341]: <https://github.com/apple/swift-evolution/blob/main/proposals/0341-opaque-parameters.md>
 [SE-0336]: <https://github.com/apple/swift-evolution/blob/main/proposals/0336-distributed-actor-isolation.md>
-[SE-0343]: <https://github.com/apple/swift-evolution/blob/main/proposals/0343-top-level-concurrency.md>
+[SE-0337]: <https://github.com/apple/swift-evolution/blob/main/proposals/0337-support-incremental-migration-to-concurrency-checking.md>
 [SE-0340]: <https://github.com/apple/swift-evolution/blob/main/proposals/0340-swift-noasync.md>
+[SE-0341]: <https://github.com/apple/swift-evolution/blob/main/proposals/0341-opaque-parameters.md>
+[SE-0343]: <https://github.com/apple/swift-evolution/blob/main/proposals/0343-top-level-concurrency.md>
 [SE-0345]: <https://github.com/apple/swift-evolution/blob/main/proposals/0345-if-let-shorthand.md>
-[SE-0326]: <https://github.com/apple/swift-evolution/blob/main/proposals/0326-extending-multi-statement-closure-inference.md>
 [SE-0347]: <https://github.com/apple/swift-evolution/blob/main/proposals/0347-type-inference-from-default-exprs.md>
+[SE-0349]: <https://github.com/apple/swift-evolution/blob/main/proposals/0349-unaligned-loads-and-stores.md>
 [SE-0352]: <https://github.com/apple/swift-evolution/blob/main/proposals/0352-implicit-open-existentials.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -82,7 +82,7 @@ public struct DiagnosticEngine {
     // Build a higher-order function to wrap every 'withBridgedXXX { ... }'
     // calls, so we don't escape anything from the closure. 'bridgedArgs' and
     // 'bridgedFixIts' are temporary storage to store bridged values. So they
-    // should not be used after the closue is executed.
+    // should not be used after the closure is executed.
 
     var closure: () -> Void = {
       bridgedArgs.withBridgedArrayRef { bridgedArgsRef in

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeInfo.swift

@@ -953,12 +953,12 @@ struct EscapeInfo {
         case let mvr as MultipleValueInstructionResult:
           let inst = mvr.instruction
           switch inst {
-            case is DestructureStructInst, is DestructureTupleInst:
-              val = inst.operands[0].value
-              // TODO: only push the specific result index.
-              // But currently there is no O(0) method to get the result index
-              // from a result value.
-              p = p.popAllValueFields().push(.anyValueFields)
+            case let dsi as DestructureStructInst:
+              p = p.push(.structField, index: mvr.index)
+              val = dsi.operand
+            case let dti as DestructureTupleInst:
+              p = p.push(.tupleField, index: mvr.index)
+              val = dti.operand
             case let bcm as BeginCOWMutationInst:
               val = bcm.operand
             default:

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -93,15 +93,15 @@ public struct ArgumentEffect : CustomStringConvertible, CustomReflectable {
   public enum Kind {
     /// The selected argument value does not escape.
     ///
-    /// Synatx examples:
+    /// Syntax examples:
     ///    !%0       // argument 0 does not escape
     ///    !%0.**    // argument 0 and all transitively contained values do not escape
     ///
     case notEscaping
 
     /// The selected argument value escapes to the specified selection (= first payload).
     ///
-    /// Synatx examples:
+    /// Syntax examples:
     ///    %0.s1 => %r   // field 2 of argument 0 exclusively escapes via return.
     ///    %0.s1 -> %1   // field 2 of argument 0 - and other values - escape to argument 1.
     ///
@@ -262,7 +262,7 @@ extension StringParser {
       }
       if function.numIndirectResultArguments > 0 {
         if function.numIndirectResultArguments != 1 {
-          try throwError("mutli-value returns not supported yet")
+          try throwError("multi-value returns not supported yet")
         }
         value = .argument(0)
       } else {
@@ -274,7 +274,7 @@ extension StringParser {
       }
       value = .argument(argIdx + function.numIndirectResultArguments)
     } else {
-      try throwError("paramter name or return expected")
+      try throwError("parameter name or return expected")
     }
 
     let valueType: Type

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -144,6 +144,8 @@ public final class MultipleValueInstructionResult : Value {
 
   public var definingInstruction: Instruction? { instruction }
 
+  public var index: Int { MultiValueInstResult_getIndex(bridged) }
+
   var bridged: BridgedMultiValueResult {
     BridgedMultiValueResult(obj: SwiftObject(self))
   }
@@ -568,10 +570,10 @@ final public class BeginCOWMutationInst : MultipleValueInstruction,
   public var bufferResult: Value { return getResult(index: 1) }
 }
 
-final public class DestructureStructInst : MultipleValueInstruction {
+final public class DestructureStructInst : MultipleValueInstruction, UnaryInstruction {
 }
 
-final public class DestructureTupleInst : MultipleValueInstruction {
+final public class DestructureTupleInst : MultipleValueInstruction, UnaryInstruction {
 }
 
 final public class BeginApplyInst : MultipleValueInstruction, FullApplySite {

SwiftCompilerSources/Sources/SIL/SubstitutionMap.swift

@@ -1,4 +1,4 @@
-//===--- PassUtils.swift - Utilities for optimzation passes ---------------===//
+//===--- PassUtils.swift - Utilities for optimization passes ---------------===//
 //
 // This source file is part of the Swift.org open source project
 //

docs/ABI/Mangling.rst

@@ -637,7 +637,7 @@ Types
   type ::= protocol-list 'p'                 // existential type
   type ::= protocol-list superclass 'Xc'     // existential type with superclass
   type ::= protocol-list 'Xl'                // existential type with AnyObject
-  type ::= protocol-list 'y' (type* '_')* type* retroactive-conformance* 'Xp'   // parameterized protocol type
+  type ::= protocol-list 'y' (type* '_')* type* retroactive-conformance* 'XP'   // parameterized protocol type
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0
@@ -918,21 +918,9 @@ root protocol conformance, and the suffix 'g'.
 
 ::
 
-  // No generalization signature, no type expression.
-  extended-existential-shape ::= generic-signature 'Xg' extended-existential-value-storage
-
-  // Generalization signature (the second one), no type expression.
-  extended-existential-shape ::= generic-signature generic-signature 'XG' extended-existential-value-storage
-
-  // No generalization signature, type expression.
-  extended-existential-shape ::= generic-signature type 'Xh' extended-existential-value-storage
-
-  // Generalization signature (the second one), type expression.
-  extended-existential-shape ::= generic-signature generic-signature type 'Xh' extended-existential-value-storage
-
-  extended-existential-value-storage ::= 'o' // opaque
-  extended-existential-value-storage ::= 'c' // class
-  extended-existential-value-storage ::= 'm' // metatype
+  // No generalization signature.
+  extended-existential-shape ::= type 'Xg' // no generalization signature
+  extended-existential-shape ::= generic-signature type 'XG'
 
 Identifiers
 ~~~~~~~~~~~

include/swift/ABI/Metadata.h

@@ -1855,6 +1855,32 @@ struct TargetExtendedExistentialTypeShape
   /// Flags for the existential shape.
   ExtendedExistentialTypeShapeFlags Flags;
 
+  /// The mangling of the generalized existential type, expressed
+  /// (if necessary) in terms of the type parameters of the
+  /// generalization signature.
+  ///
+  /// If this shape is non-unique, this is always a flat string, not a
+  /// "symbolic" mangling which can contain relative references.  This
+  /// allows uniquing to simply compare the string content.
+  ///
+  /// In principle, the content of the requirement signature and type
+  /// expression are derivable from this type.  We store them separately
+  /// so that code which only needs to work with the logical content of
+  /// the type doesn't have to break down the existential type string.
+  /// This both (1) allows those operations to work substantially more
+  /// efficiently (and without needing code to produce a requirement
+  /// signature from an existential type to exist in the runtime) and
+  /// (2) potentially allows old runtimes to support new existential
+  /// types without as much invasive code.
+  ///
+  /// The content of this string is *not* necessarily derivable from
+  /// the requirement signature.  This is because there may be multiple
+  /// existential types that have equivalent logical content but which
+  /// we nonetheless distinguish at compile time.  Storing this also
+  /// allows us to far more easily produce a formal type from this
+  /// shape reflectively.
+  RelativeStringPointer ExistentialType;
+
   /// The header describing the requirement signature of the existential.
   TargetGenericContextDescriptorHeader<Runtime> ReqSigHeader;
 
@@ -2024,6 +2050,9 @@ struct UniqueHash {
 
 /// A descriptor for an extended existential type descriptor which
 /// needs to be uniqued at runtime.
+///
+/// Uniquing is performed by comparing the existential type strings
+/// of the shapes.
 template <typename Runtime>
 struct TargetNonUniqueExtendedExistentialTypeShape {
   /// A reference to memory that can be used to cache a globally-unique
@@ -2032,10 +2061,12 @@ struct TargetNonUniqueExtendedExistentialTypeShape {
     std::atomic<ConstTargetMetadataPointer<Runtime,
                   TargetExtendedExistentialTypeShape>>> UniqueCache;
 
-  /// A hash of the mangling of the existential shape.
-  ///
-  /// TODO: describe that mangling here
-  UniqueHash Hash;
+  llvm::StringRef getExistentialTypeStringForUniquing() const {
+    // When we have a non-unique shape, we're guaranteed that
+    // ExistentialType contains no symbolic references, so we can just
+    // recover it this way rather than having to parse it.
+    return LocalCopy.ExistentialType.get();
+  }
 
   /// The local copy of the existential shape descriptor.
   TargetExtendedExistentialTypeShape<Runtime> LocalCopy;

include/swift/APIDigester/ModuleAnalyzerNodes.h

@@ -1,4 +1,4 @@
-//===--- ModuleAnaluzerNodes.h - Nodes for API differ tool ---------------====//
+//===--- ModuleAnalyzerNodes.h - Nodes for API differ tool ---------------====//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -142,7 +142,7 @@ class UpdatedNodesMap {
 };
 
 // Describing some attributes with ABI/API impact. The addition or removal of these
-// attributes is considerred breakage.
+// attributes is considered breakage.
 struct BreakingAttributeInfo {
   const DeclAttrKind Kind;
   const StringRef Content;
@@ -357,7 +357,7 @@ class SDKNodeDecl: public SDKNode {
   uint8_t ReferenceOwnership;
   StringRef GenericSig;
   // In ABI mode, this field is populated as a user-friendly version of GenericSig.
-  // Dignostic preferes the sugared versions if they differ as well.
+  // Diagnostic preferes the sugared versions if they differ as well.
   StringRef SugaredGenericSig;
   Optional<uint8_t> FixedBinaryOrder;
   PlatformIntroVersion introVersions;
@@ -571,7 +571,7 @@ class SDKNodeDeclType: public SDKNodeDecl {
 
   Optional<SDKNodeDeclType*> getSuperclass() const;
 
-  /// Finding the node through all children, including the inheritted ones,
+  /// Finding the node through all children, including the inherited ones,
   /// whose printed name matches with the given name.
   Optional<SDKNodeDecl*> lookupChildByPrintedName(StringRef Name) const;
   SDKNodeType *getRawValueType() const;
@@ -797,22 +797,22 @@ class SwiftDeclCollector: public VisibleDeclConsumer {
 
 void detectRename(SDKNode *L, SDKNode *R);
 
-int dumpSwiftModules(const CompilerInvocation &InitInvok,
+int dumpSwiftModules(const CompilerInvocation &InitInvoke,
                      const llvm::StringSet<> &ModuleNames,
                      StringRef OutputDir,
                      const std::vector<std::string> PrintApis,
                      CheckerOptions Opts);
 
 SDKNodeRoot *getSDKNodeRoot(SDKContext &SDKCtx,
-                            const CompilerInvocation &InitInvok,
+                            const CompilerInvocation &InitInvoke,
                             const llvm::StringSet<> &ModuleNames);
 
 SDKNodeRoot *getEmptySDKNodeRoot(SDKContext &SDKCtx);
 
 void dumpSDKRoot(SDKNodeRoot *Root, PayLoad load, StringRef OutputFile);
 void dumpSDKRoot(SDKNodeRoot *Root, StringRef OutputFile);
 
-int dumpSDKContent(const CompilerInvocation &InitInvok,
+int dumpSDKContent(const CompilerInvocation &InitInvoke,
                    const llvm::StringSet<> &ModuleNames,
                    StringRef OutputFile, CheckerOptions Opts);