Merge pull request #4309 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

CHANGELOG.md

@@ -5,6 +5,48 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* The compiler now emits a warning when a non-final class conforms to a protocol that imposes a same-type requirement between `Self` and an associated type. This is because such a requirement makes the conformance unsound for subclasses.
+
+For example, Swift 5.6 would allow the following code, which at runtime would construct an instanec of `C` and not `SubC` as expected:
+
+  ```swift
+  protocol P {
+    associatedtype A : Q where Self == Self.A.B
+  }
+  
+  protocol Q {
+    associatedtype B
+  
+    static func getB() -> B
+  }
+  
+  class C : P {
+    typealias A = D
+  }
+  
+  class D : Q {
+    typealias B = C
+  
+    static func getB() -> C { return C() }
+  }
+  
+  extension P {
+    static func getAB() -> Self {
+      // This is well-typed, because `Self.A.getB()` returns
+      // `Self.A.B`, which is equivalent to `Self`.
+      return Self.A.getB()
+    }
+  }
+  
+  class SubC : C {}
+  
+  // P.getAB() declares a return type of `Self`, so it should
+  // return `SubC`, but it actually returns a `C`.
+  print(SubC.getAB())
+  ```
+
+  To make the above example correct, either the class `C` needs to become `final` (in which case `SubC` cannot be declared) or protocol `P` needs to be re-designed to not include the same-type requirement `Self == Self.A.B`.
+
 * [SE-0341][]:
 
   Opaque types can now be used in the parameters of functions and subscripts, wher they provide a shorthand syntax for the introduction of a generic parameter. For example, the following:

SwiftCompilerSources/Sources/AST/CMakeLists.txt

@@ -0,0 +1,14 @@
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2022 Apple Inc. and the Swift project authors
+# Licensed under Apache License v2.0 with Runtime Library Exception
+#
+# See http://swift.org/LICENSE.txt for license information
+# See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+
+add_swift_compiler_module(AST
+  DEPENDS
+    Basic
+  SOURCES
+    DiagnosticEngine.swift)
+

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -0,0 +1,123 @@
+//===--- DiagnosticEngine.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+import ASTBridging
+
+import Basic
+
+public typealias DiagID = BridgedDiagID
+
+extension BridgedDiagnosticArgument {
+  init(stringRef val: BridgedStringRef) {
+    self.init(kind: .stringRef, value: .init(stringRefValue: val))
+  }
+  init(int val: Int) {
+    self.init(kind: .int, value: .init(intValue: val))
+  }
+}
+
+public protocol DiagnosticArgument {
+  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void)
+}
+extension String: DiagnosticArgument {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+    withBridgedStringRef { fn(BridgedDiagnosticArgument(stringRef: $0)) }
+  }
+}
+extension Int: DiagnosticArgument {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+    fn(BridgedDiagnosticArgument(int: self))
+  }
+}
+
+public struct DiagnosticFixIt {
+  public let start: SourceLoc
+  public let byteLength: Int
+  public let text: String
+
+  public init(start: SourceLoc, byteLength: Int, replacement text: String) {
+    self.start = start
+    self.byteLength = byteLength
+    self.text = text
+  }
+
+  func withBridgedDiagnosticFixIt(_ fn: (BridgedDiagnosticFixIt) -> Void) {
+    text.withBridgedStringRef { bridgedTextRef in
+      let bridgedDiagnosticFixIt = BridgedDiagnosticFixIt(
+        start: start.bridged,
+        byteLength: byteLength,
+        text: bridgedTextRef)
+      fn(bridgedDiagnosticFixIt)
+    }
+  }
+}
+
+public struct DiagnosticEngine {
+  private let bridged: BridgedDiagnosticEngine
+
+  public init(bridged: BridgedDiagnosticEngine) {
+    self.bridged = bridged
+  }
+
+  public func diagnose(_ position: SourceLoc?,
+                       _ id: DiagID,
+                       _ args: [DiagnosticArgument],
+                       highlight: CharSourceRange? = nil,
+                       fixIts: [DiagnosticFixIt] = []) {
+
+    let bridgedSourceLoc: BridgedSourceLoc = position.bridged
+    let bridgedHighlightRange: BridgedCharSourceRange = highlight.bridged
+    var bridgedArgs: [BridgedDiagnosticArgument] = []
+    var bridgedFixIts: [BridgedDiagnosticFixIt] = []
+
+    // 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.
+ 
+    var closure: () -> Void = {
+      bridgedArgs.withBridgedArrayRef { bridgedArgsRef in
+        bridgedFixIts.withBridgedArrayRef { bridgedFixItsRef in
+          DiagnosticEngine_diagnose(bridged, bridgedSourceLoc,
+                                    id, bridgedArgsRef,
+                                    bridgedHighlightRange, bridgedFixItsRef)
+        }
+      }
+    }
+    for arg in args {
+      closure = { [closure, arg] in
+        arg._withBridgedDiagnosticArgument { bridgedArg in
+          bridgedArgs.append(bridgedArg)
+          closure()
+        }
+      }
+    }
+    for fixIt in fixIts {
+      closure = { [closure, fixIt] in
+        fixIt.withBridgedDiagnosticFixIt { bridgedFixIt in
+          bridgedFixIts.append(bridgedFixIt)
+          closure()
+        }
+      }
+    }
+
+    closure()
+  }
+
+  public func diagnose(_ position: SourceLoc?,
+                       _ id: DiagID,
+                       _ args: DiagnosticArgument...,
+                       highlight: CharSourceRange? = nil,
+                       fixIts: DiagnosticFixIt...) {
+    diagnose(position, id, args, highlight: highlight, fixIts: fixIts)
+  }
+}

SwiftCompilerSources/Sources/Basic/CMakeLists.txt

@@ -7,4 +7,5 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 add_swift_compiler_module(Basic
+  SourceLoc.swift
   Utils.swift)

SwiftCompilerSources/Sources/Basic/SourceLoc.swift

@@ -0,0 +1,67 @@
+//===--- SourceLoc.swift - SourceLoc bridiging utilities ------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+public struct SourceLoc {
+  /// Points into a source file.
+  let locationInFile: UnsafePointer<UInt8>
+
+  public init?(locationInFile: UnsafePointer<UInt8>?) {
+    guard let locationInFile = locationInFile else {
+      return nil
+    }
+    self.locationInFile = locationInFile
+  }
+
+  public init?(bridged: BridgedSourceLoc) {
+    guard let locationInFile = bridged.pointer else {
+      return nil
+    }
+    self.init(locationInFile: locationInFile)
+  }
+
+  public var bridged: BridgedSourceLoc {
+    .init(pointer: locationInFile)
+  }
+}
+
+extension Optional where Wrapped == SourceLoc {
+  public var bridged: BridgedSourceLoc {
+    self?.bridged ?? .init(pointer: nil)
+  }
+}
+
+public struct CharSourceRange {
+  private let start: SourceLoc
+  private let byteLength: Int
+
+  public init(start: SourceLoc, byteLength: Int) {
+    self.start = start
+    self.byteLength = byteLength
+  }
+
+  public init?(bridged: BridgedCharSourceRange) {
+    guard let start = SourceLoc(bridged: bridged.start) else {
+      return nil
+    }
+    self.init(start: start, byteLength: bridged.byteLength)
+  }
+
+  public var bridged: BridgedCharSourceRange {
+    .init(start: start.bridged, byteLength: byteLength)
+  }
+}
+
+extension Optional where Wrapped == CharSourceRange {
+  public var bridged: BridgedCharSourceRange {
+    self?.bridged ?? .init(start: .init(pointer: nil), byteLength: 0)
+  }
+}

SwiftCompilerSources/Sources/CMakeLists.txt

@@ -9,6 +9,7 @@
 # NOTE: Subdirectories must be added in dependency order.
 
 add_subdirectory(Basic)
+add_subdirectory(AST)
 if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
   add_subdirectory(ExperimentalRegex)
 endif()

docs/ABI/Mangling.rst

@@ -223,6 +223,8 @@ types where the metadata itself has unknown layout.)
   global ::= global 'TI'                 // implementation of a dynamic_replaceable function
   global ::= global 'Tu'                 // async function pointer of a function
   global ::= global 'TX'                 // function pointer of a dynamic_replaceable function
+  global ::= global 'Twb'                // back deployment thunk
+  global ::= global 'TwB'                // back deployment fallback function
   global ::= entity entity 'TV'          // vtable override thunk, derived followed by base
   global ::= type label-list? 'D'        // type mangling for the debugger with label list for function types.
   global ::= type 'TC'                   // continuation prototype (not actually used for real symbols)

include/swift/ABI/MetadataValues.h

@@ -2201,57 +2201,6 @@ class TaskOptionRecordFlags : public FlagSet<size_t> {
                                  getKind, setKind)
 };
 
-/// Kinds of async context.
-enum class AsyncContextKind {
-  /// An ordinary asynchronous function.
-  Ordinary         = 0,
-
-  /// A context which can yield to its caller.
-  Yielding         = 1,
-
-  /// A continuation context.
-  Continuation     = 2,
-
-  // Other kinds are reserved for interesting special
-  // intermediate contexts.
-
-  // Kinds >= 192 are private to the implementation.
-  First_Reserved = 192
-};
-
-/// Flags for async contexts.
-class AsyncContextFlags : public FlagSet<uint32_t> {
-public:
-  enum {
-    Kind                = 0,
-    Kind_width          = 8,
-
-    CanThrow            = 8,
-
-    // Kind-specific flags should grow down from 31.
-
-    Continuation_IsExecutorSwitchForced = 31,
-  };
-
-  explicit AsyncContextFlags(uint32_t bits) : FlagSet(bits) {}
-  constexpr AsyncContextFlags() {}
-  AsyncContextFlags(AsyncContextKind kind) {
-    setKind(kind);
-  }
-
-  /// The kind of context this represents.
-  FLAGSET_DEFINE_FIELD_ACCESSORS(Kind, Kind_width, AsyncContextKind,
-                                 getKind, setKind)
-
-  /// Whether this context is permitted to throw.
-  FLAGSET_DEFINE_FLAG_ACCESSORS(CanThrow, canThrow, setCanThrow)
-
-  /// See AsyncContinuationFlags::isExecutorSwitchForced.
-  FLAGSET_DEFINE_FLAG_ACCESSORS(Continuation_IsExecutorSwitchForced,
-                                continuation_isExecutorSwitchForced,
-                                continuation_setIsExecutorSwitchForced)
-};
-
 /// Flags passed to swift_continuation_init.
 class AsyncContinuationFlags : public FlagSet<size_t> {
 public: