swiftwasm · kateinoigakukun · Mar 22, 2022 · Mar 10, 2022 · Mar 10, 2022 · Mar 10, 2022
diff --git a/.gitignore b/.gitignore
@@ -47,6 +47,9 @@ docs/_build
 .cache
 .clangd
 
+# SwiftPM
+.build
+
 #==============================================================================#
 # Ignore CMake temporary files
 #==============================================================================#
@@ -59,6 +62,7 @@ CMakeFiles
 #==============================================================================#
 compile_commands.json
 
+#==============================================================================#
 # Ignore generated GYB files until we fix the workaround on Windows
 #==============================================================================#
 8

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,23 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [SE-0343][]:
+
+Top-level scripts support asynchronous calls.
+
+Using an `await` by calling an asynchronous function or accessing an isolated
+variable transitions the top-level to an asynchronous context. As an
+asynchronous context, top-level variables are `@MainActor`-isolated and the
+top-level is run on the `@MainActor`.
+
+Note that the transition affects function overload resolution and starts an
+implicit run loop to drive the concurrency machinery.
+
+Unmodified scripts are not affected by this change unless `-warn-concurrency` is
+passed to the compiler invocation. With `-warn-concurrency`, variables in the
+top-level are isolated to the main actor and the top-level context is isolated
+to the main actor, but is not an asynchronous context.
+
 * [SE-0336][]:
 
 It is now possible to declare `distributed actor` and `distributed func`s inside of them.
@@ -37,7 +54,7 @@ func talkTo(greeter: Greeter) async throws {
 
 * 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:
+For example, Swift 5.6 would allow the following code, which at runtime would construct an instance of `C` and not `SubC` as expected:
 
   ```swift
   protocol P {
@@ -79,7 +96,7 @@ For example, Swift 5.6 would allow the following code, which at runtime would co
 
 * [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:
+  Opaque types can now be used in the parameters of functions and subscripts, when they provide a shorthand syntax for the introduction of a generic parameter. For example, the following:
 
   ```swift
   func horizontal(_ v1: some View, _ v2: some View) -> some View {
@@ -9065,6 +9082,7 @@ Swift 1.0
 [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>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

diff --git a/benchmark/single-source/SubstringTest.swift b/benchmark/single-source/SubstringTest.swift
@@ -63,21 +63,23 @@ public func run_SubstringFromLongStringGeneric(_ n: Int) {
   }
 }
 
-@inline(never)
-public func run_StringFromLongWholeSubstring(_ n: Int) {
+private func getLongWideRealBuffer() -> String {
   var s0 = longWide
   s0 += "!" // ensure the string has a real buffer
-  let s = Substring(s0)
+  return s0
+}
+
+@inline(never)
+public func run_StringFromLongWholeSubstring(_ n: Int) {
+  let s = Substring(getLongWideRealBuffer())
   for _ in 1...n*500 {
     blackHole(String(s))
   }
 }
 
 @inline(never)
 public func run_StringFromLongWholeSubstringGeneric(_ n: Int) {
-  var s0 = longWide
-  s0 += "!" // ensure the string has a real buffer
-  let s = Substring(s0)
+  let s = Substring(getLongWideRealBuffer())
   for _ in 1...n*500 {
     create(String.self, from: s)
   }

diff --git a/cmake/modules/Libdispatch.cmake b/cmake/modules/Libdispatch.cmake
@@ -89,6 +89,8 @@ foreach(sdk ${DISPATCH_SDKS})
                           ${SWIFT_LIBDISPATCH_COMPILER_TRIPLE_CMAKE_ARGS}
                           -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
                           -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+                          -DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}
+                          -DCMAKE_SHARED_LINKER_FLAGS=${CMAKE_SHARED_LINKER_FLAGS}
                           -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
                           -DCMAKE_INSTALL_LIBDIR=lib
                           -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>

diff --git a/docs/CppInteroperability/CppInteroperabilityStatus.md b/docs/CppInteroperability/CppInteroperabilityStatus.md
@@ -0,0 +1,146 @@
+#  C++ Interoperability Status
+
+Swift has some experimental ability to interoperate with C++.
+This document provides an overview of the status of the Swift and C++ interoperability support.
+
+## C++ to Swift Interoperability Status
+
+Swift has the experimental ability to import a large subset of C++.
+This section of the document describes which C++ language and standard library features can be imported and used from Swift in an experimental manner.
+
+### Example
+The following example demonstrates several interop features. It compiles and runs on main.
+
+```C++
+// cxx-types.h (mapped to CxxTypes module in module.modulemap)
+#include <algorithm>
+#include <vector>
+
+using V = std::vector<long>;
+```
+
+```Swift
+// main.swift
+import CxxTypes
+import std.vector
+import std.algorithm
+
+// We can extend C++ types in Swift.
+extension V : RandomAccessCollection {
+  public var startIndex: Int { 0 }
+  public var endIndex: Int { size() }
+}
+
+// Create a vector with some data.
+var numbers = V(4)
+std.fill(numbers.beginMutating(), numbers.endMutating(), 41)
+
+// Transform it using C++.
+std.transform(numbers.beginMutating(), numbers.endMutating(),
+              numbers.beginMutating()) { (element: Int) in
+  return element + 1
+}
+
+// Loop over it in Swift.
+for (index, element) in numbers.enumerated() {
+  print("v[\(index)] = \(element)")
+}
+
+// We can also use anything in RandomAccessCollection, such as map and zip.
+let strings = numbers.map { "\($0)" }
+for (s, n) in zip(strings, numbers) {
+  print("\(s) = \(n)")
+}
+```
+
+### Importing C++
+
+There are currently two experimental ways to import C++ into Swift:
+- **Clang modules**: can be imported into Swift. This requires a module map.
+- **Bridging header**: can be imported into Swift. Headers included in the bridging header will be imported.
+Please note that support for importing C++ 20 modules isn’t implemented.
+
+Both CMake and the Swift package manager can be configured to invoke Swift with the correct arguments to import C++ headers.
+
+**Note**: C++ code is imported using the Objective-C++ language mode on Apple platforms.
+
+### Experimental C++ Language Support
+
+This status table describes which of the following C++ language features can be used in Swift: 
+
+| **C++ Language Feature**                    | **Implemented Experimental Support For Using It In Swift**    |
+|---------------------------------------------|---------------------------------------------------------------|
+| Top-level functions                         | Yes    |
+| Enumerations                                | Yes. That includes `enum class`  |
+| Struct / Class types                        | Yes - as value types, except for types without a copy constructor. Partial experimental support for importing a C++ struct/class as a reference type |
+| Typedefs / Type aliases                     | Yes    |
+| Global Variables                            | Yes    |
+| Namespaces                                  | Yes    |
+| Inline Namespaces                           | Yes, with some known issues (https://bugs.swift.org/browse/SR-15956) |
+| Exceptions                                  | No  |
+| Fields                                      | Yes |
+| Member functions                            | Yes. Some value category overloads aren't imported |
+| Virtual Member Functions                    | No |
+| Operators                                   | Yes, with some known issues    |
+| Subscript Operators                         | Yes |
+| Constructors                                | Yes. That includes implicit constructors    |
+| Destructor                                  | Yes. C++ destructors are invoked automatically when the value is no longer used in Swift |
+| Copy constructor / copy assignment operator | Yes. Swift invokes the underlying copy constructor when copying a C++ value |
+| Move constructor / move assignment operator | No    |
+| Base class member functions / operators     | Yes, with some known issues |
+| Function templates                          | Yes    |
+| Class templates                             | Yes    |
+| Dependent types                             | Partially: imported as Any |
+| Availability Attributes                     | Yes    |
+
+
+The following C++ code patterns or language features have specific mappings to Swift language features when imported in Swift:
+
+
+| **C++ Language Feature**                             | **Imported Into Swift**                                                                  |
+|------------------------------------------------------|------------------------------------------------------------------------------------------|
+| `get`/`set` member functions                         | Imported as computed property (starting from Swift-5.7)                                          |
+| `const`/non-`const` member function overload set     | Both overloads are imported as a method, with non-`const` method being renamed to `mutating…` (starting from Swift-5.7). The renaming logic will change in a future version of Swift, and non-`const` methods won't be renamed |
+
+
+Unless stated otherwise (i.e., imported reference types) all Swift features work with imported types. For example: use in generic contexts, protocol conformance, extensions, etc.
+
+
+### C++ Standard Library Support
+
+Parts of libc++ can be imported and used from Swift.
+
+This status table describes which of the following C++ standard library features have some experimental support for using them in Swift. Please note that this is not a comprehensive list and other libc++ APIs that use the above supported C++ language features could be imported into Swift.
+
+| **C++ Standard Library Feature**   | **Can Be Used From Swift**                   |
+|------------------------------------|----------------------------------------------|
+| `std::string`                      | Yes                                          |
+| `std::vector`                      | Yes                                          |
+
+## Known Issues
+
+### Inline Namespaces
+- https://bugs.swift.org/browse/SR-15956: Swift's typechecker currently doesn't allow calling a function from an inline namespace when it's referenced through the parent namespace. Example of a test that fails: https://github.com/apple/swift/blob/main/test/Interop/Cxx/namespace/inline-namespace-function-call-broken.swift 
+
+
+## Swift to C++ Interoperability Status
+
+This section of the document describes which Swift language and standard library features can be imported and used from C++. 
+
+### Importing Swift
+
+Swift has some experimental support for generating a header that can be imported by C++.
+
+### Swift Language Support
+
+This status table describes which of the following Swift language features have some experimental support for using them in C++.
+
+**Functions**
+
+| **Swift Language Feature**     | **Implemented Experimental Support For Using It In C++** |
+|--------------------------------|----------------------------------------------------------|
+| Top-level `@_cdecl` functions  | Yes                                                      |
+| Top-level Swift functions      | Partially, only with C compatible types                  |
+| `inout` parameters             | No                                                       |
+| Variadic parameters            | No                                                       |
+| Multiple return values         | No                                                       |
diff --git a/docs/README.md b/docs/README.md
@@ -249,7 +249,7 @@ documentation, please create a thread on the Swift forums under the
     Describes the goals and design for Library Evolution.
 - [BuildManifesto.md](/docs/BuildManifesto.md):
   Provides an outline for modularizing the build system for the Swift toolchain.
-- [CppInteroperabilityManifesto.md](/docs/CppInteroperabilityManifesto.md):
+- [CppInteroperabilityManifesto.md](/docs/CppInteroperability/CppInteroperabilityManifesto.md):
   Describes the motivation and design for first-class Swift-C++ interoperability.
 - [DifferentiableProgramming.md](/docs/DifferentiableProgramming.md):
   Outlines a vision and design for first-class differentiable programming in Swift.

diff --git a/docs/ReferenceGuides/UnderscoredAttributes.md b/docs/ReferenceGuides/UnderscoredAttributes.md
@@ -39,14 +39,19 @@ Most notably, default argument expressions are implicitly
 `@_alwaysEmitIntoClient`, which means that adding a default argument to a
 function which did not have one previously does not break ABI.
 
-## `@_backDeploy(availabilitySpec ...)`
+## `@_backDeploy(before: ...)`
 
 Causes the body of a function to be emitted into the module interface to be
-available for inlining in clients with deployment targets lower than the formal
-availability of the function. When inlined, the body of the function is
-transformed such that it calls the library's copy of the function if it is
-available at runtime. Otherwise, the copy of the original function body is
-executed.
+available for emission into clients with deployment targets lower than the
+ABI availability of the function. When the client's deployment target is
+before the function's ABI availability, the compiler replaces calls to that
+function with a call to a thunk that checks at runtime whether the original
+library function is available. If the the original is available then it is
+called. Otherwise, the fallback copy of the function that was emitted into the
+client is called instead.
+
+For more details, see the [pitch thread](https://forums.swift.org/t/pitch-function-back-deployment/55769/)
+in the forums.
 
 ## `@_assemblyVision`
 

diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -988,11 +988,11 @@ class ASTContext final {
   /// one.
   void loadExtensions(NominalTypeDecl *nominal, unsigned previousGeneration);
 
-  /// Load the methods within the given class that produce
+  /// Load the methods within the given type that produce
   /// Objective-C class or instance methods with the given selector.
   ///
-  /// \param classDecl The class in which we are searching for @objc methods.
-  /// The search only considers this class and its extensions; not any
+  /// \param tyDecl The type in which we are searching for @objc methods.
+  /// The search only considers this type and its extensions; not any
   /// superclasses.
   ///
   /// \param selector The selector to search for.
@@ -1010,7 +1010,11 @@ class ASTContext final {
   ///
   /// \param swiftOnly If true, only loads methods from imported Swift modules,
   /// skipping the Clang importer.
-  void loadObjCMethods(ClassDecl *classDecl, ObjCSelector selector,
+  ///
+  /// \note Passing a protocol is supported, but currently a no-op, because
+  /// Objective-C protocols cannot be extended in ways that make the ObjC method
+  /// lookup table relevant.
+  void loadObjCMethods(NominalTypeDecl *tyDecl, ObjCSelector selector,
                        bool isInstanceMethod, unsigned previousGeneration,
                        llvm::TinyPtrVector<AbstractFunctionDecl *> &methods,
                        bool swiftOnly = false);

diff --git a/include/swift/AST/ASTMangler.h b/include/swift/AST/ASTMangler.h
@@ -186,6 +186,8 @@ class ASTMangler : public Mangler {
                                              Type GlobalActorBound,
                                              ModuleDecl *Module);
 
+  std::string mangleDistributedThunk(const FuncDecl *thunk);
+
   /// Mangle a completion handler block implementation function, used for importing ObjC
   /// APIs as async.
   ///