Merge pull request #2716 from swiftwasm/katei/merge-main-2021-02-12

Merge main 2021-02-12

Author: MaxDesiatov

CHANGELOG.md

@@ -25,9 +25,142 @@ CHANGELOG
 
 </details>
 
+Swift Next
+----------
+
+* [SE-0296][]:
+
+  Asynchronous programming is now natively supported using async/await. Asynchronous functions can be defined using `async`:
+
+  ```swift
+  func loadWebResource(_ path: String) async throws -> Resource { ... }
+  func decodeImage(_ r1: Resource, _ r2: Resource) async throws -> Image
+  func dewarpAndCleanupImage(_ i : Image) async -> Image
+  ```
+
+  Calls to `async` functions may suspend, meaning that they give up the thread on which they are executing and will be scheduled to run again later. The potential for suspension on asynchronous calls requires the `await` keyword, similarly to the way in which `try` acknowledges a call to a `throws` function:
+
+  ```swift
+  func processImageData() async throws -> Image {
+    let dataResource  = try await loadWebResource("dataprofile.txt")
+    let imageResource = try await loadWebResource("imagedata.dat")
+    let imageTmp      = try await decodeImage(dataResource, imageResource)
+    let imageResult   = await dewarpAndCleanupImage(imageTmp)
+    return imageResult
+  }
+  ```
+
+* The 'lazy' keyword now works in local contexts, making the following valid:
+
+  ```swift
+  func test(useIt: Bool) {
+    lazy var result = getPotentiallyExpensiveResult()
+    if useIt {
+      doIt(result)
+    }
+  }
+  ```
+
+**Add new entries to the top of this section, not here!**
+
 Swift 5.4
 ---------
 
+* Protocol conformance checking now considers `where` clauses when evaluating if a `typealias` is a suitable witness for an associated type requirement. The following code is now rejected:
+
+  ```swift
+  protocol Holder {
+    associatedtype Contents
+  }
+
+  struct Box<T> : Holder {}
+  // error: type 'Box<T>' does not conform to protocol 'Holder'
+
+  extension Box where T : Hashable {
+    typealias Contents = T
+  }
+  ```
+
+  In most cases, the compiler would either crash or produce surprising results when making use of a `typealias` with an unsatisfied `where` clause, but it is possible that some previously-working code is now rejected. In the above example, the conformance can be fixed in one of various ways:
+
+  1) making it conditional (moving the `: Holder` from the definition of `Box` to the extension)
+  2) moving the `typealias` from the extension to the type itself
+  3) relaxing the `where` clause on the extension
+
+* Availability checking now rejects protocols that refine less available protocols. Previously, this was accepted by the compiler but could result in linker errors or runtime crashes:
+
+  ```swift
+  @available(macOS 11, *)
+  protocol Base {}
+
+  protocol Bad : Base {}
+  // error: 'Base' is only available in macOS 11 or newer
+
+  @available(macOS 11, *)
+  protocol Good : Base {} // OK
+  ```
+
+* The `@available` attribute is no longer permitted on generic parameters, where it had no effect:
+
+  ```swift
+  struct Bad<@available(macOS 11, *) T> {}
+  // error: '@available' attribute cannot be applied to this declaration
+
+  struct Good<T> {} // equivalent
+  ```
+
+* If a type is made to conform to a protocol via an extension, the availability of the extension is now taken into account when forming generic types that use this protocol conformance. For example, consider a `Box` type whose conformance to `Hashable` uses features only available on macOS 11:
+
+  ```swift
+  public struct Box {}
+
+  @available(macOS 11, *)
+  extension Box : Hashable {
+    func hash(into: inout Hasher) {
+      // call some new API to hash the value...
+    }
+  }
+
+  public func findBad(_: Set<Box>) -> Box {}
+  // warning: conformance of 'Box' to 'Hashable' is only available in macOS 11 or newer
+
+  @available(macOS 11, *)
+  public func findGood(_: Set<Box>) -> Box {} // OK
+  ```
+
+  In the above code, it is not valid for `findBad()` to take a `Set<Box>`, since `Set` requires that its element type conform to `Hashable`; however the conformance of `Box` to `Hashable` is not available prior to macOS 11.
+
+  Note that using an unavailable protocol conformance is a warning, not an error, to avoid potential source compatibility issues. This is because it was technically possible to write code in the past that made use of unavailable protocol conformances but worked anyway, if the optimizer had serendipitously eliminated all runtime dispatch through this conformance, or the code in question was entirely unreachable at runtime.
+
+  Protocol conformances can also be marked as completely unavailable or deprecated, by placing an appropriate `@available` attribute on the extension:
+
+  ```swift
+  @available(*, unavailable, message: "Not supported anymore")
+  extension Box : Hashable {}
+
+  @available(*, deprecated, message: "Suggest using something else")
+  extension Box : Hashable {}
+  ```
+
+  If a protocol conformance is defined on the type itself, it inherits availability from the type. You can move the protocol conformance to an extension if you need it to have narrower availability than the type.
+
+* When `swift` is run with no arguments, it starts a REPL (read eval print loop) that uses LLDB. The compiler also had a second REPL implementation, known as the "integrated REPL", formerly accessible by running `swift -frontend -repl`. The "integrated REPL" was only intended for use by compiler developers, and has now been removed.
+
+  Note that this does not take away the ability to put Swift code in a script and run it with `swift myScript.swift`. This so-called "script mode" is distinct from the integrated REPL, and continues to be supported.
+
+* Property wrappers now work in local contexts, making the following valid:
+
+  ```swift
+  @propertyWrapper
+  struct Wrapper<T> {
+    var wrappedValue: T
+  }
+
+  func test() {
+    @Wrapper var value = 10
+  }
+  ```
+
 * [SR-10069][]:
 
   Function overloading now works in local contexts, making the following valid:
@@ -317,8 +450,6 @@ Swift 5.3
   closure's capture list in addition to the existing 'use `self.` explicitly'
   fix-it.
 
-**Add new entries to the top of this section, not here!**
-
 Swift 5.2
 ---------
 
@@ -1337,10 +1468,10 @@ Swift 4.1
   types, such as `index(of:)`.
 
 * [SE-0157][] is implemented. Associated types can now declare "recursive"
-	constraints, which require that the associated type conform to the enclosing
-	protocol. The standard library protocols have been updated to make use of
-	recursive constraints. For example, the `SubSequence` associated type of
-	`Sequence` follows the enclosing protocol:
+  constraints, which require that the associated type conform to the enclosing
+  protocol. The standard library protocols have been updated to make use of
+  recursive constraints. For example, the `SubSequence` associated type of
+  `Sequence` follows the enclosing protocol:
 
   ```swift
   protocol Sequence {
@@ -1357,16 +1488,15 @@ Swift 4.1
   ```
 
   As a result, a number of new constraints have been introduced into the
-	standard library protocols:
-
-	* Make the `Indices` associated type have the same traversal requirements as
-	its enclosing protocol, e.g., `Collection.Indices` conforms to
-	`Collection`, `BidirectionalCollection.Indices` conforms to
-	`BidirectionalCollection`, and so on
-	* Make `Numeric.Magnitude` conform to `Numeric`
-	* Use more efficient `SubSequence` types for lazy filter and map
-	* Eliminate the `*Indexable` protocols
+  standard library protocols:
 
+  * Make the `Indices` associated type have the same traversal requirements as
+    its enclosing protocol, e.g., `Collection.Indices` conforms to
+    `Collection`, `BidirectionalCollection.Indices` conforms to
+    `BidirectionalCollection`, and so on
+  * Make `Numeric.Magnitude` conform to `Numeric`
+  * Use more efficient `SubSequence` types for lazy filter and map
+  * Eliminate the `*Indexable` protocols
 
 * [SE-0161][] is fully implemented. KeyPaths now support subscript, optional
   chaining, and optional force-unwrapping components.
@@ -8178,6 +8308,7 @@ Swift 1.0
 [SE-0284]: <https://github.com/apple/swift-evolution/blob/main/proposals/0284-multiple-variadic-parameters.md>
 [SE-0286]: <https://github.com/apple/swift-evolution/blob/main/proposals/0286-forward-scan-trailing-closures.md>
 [SE-0287]: <https://github.com/apple/swift-evolution/blob/main/proposals/0287-implicit-member-chains.md>
+[SE-0296]: <https://github.com/apple/swift-evolution/blob/main/proposals/0296-async-await.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

CMakeLists.txt

@@ -996,133 +996,7 @@ if (LLVM_ENABLE_DOXYGEN)
   message(STATUS "Doxygen: enabled")
 endif()
 
-if(SWIFT_BUILD_HOST_DISPATCH)
-  if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
-    if(CMAKE_C_COMPILER_ID STREQUAL Clang AND
-       CMAKE_C_COMPILER_VERSION VERSION_GREATER 3.8
-       OR LLVM_USE_SANITIZER)
-      set(SWIFT_LIBDISPATCH_C_COMPILER ${CMAKE_C_COMPILER})
-      set(SWIFT_LIBDISPATCH_CXX_COMPILER ${CMAKE_CXX_COMPILER})
-    elseif(${CMAKE_SYSTEM_NAME} STREQUAL ${CMAKE_HOST_SYSTEM_NAME})
-      if(CMAKE_SYSTEM_NAME STREQUAL Windows)
-        if(CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR AND
-            TARGET clang)
-          set(SWIFT_LIBDISPATCH_C_COMPILER
-              $<TARGET_FILE_DIR:clang>/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-          set(SWIFT_LIBDISPATCH_CXX_COMPILER
-              $<TARGET_FILE_DIR:clang>/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-        else()
-          set(SWIFT_LIBDISPATCH_C_COMPILER clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-          set(SWIFT_LIBDISPATCH_CXX_COMPILER clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-        endif()
-      else()
-        set(SWIFT_LIBDISPATCH_C_COMPILER $<TARGET_FILE_DIR:clang>/clang)
-        set(SWIFT_LIBDISPATCH_CXX_COMPILER $<TARGET_FILE_DIR:clang>/clang++)
-      endif()
-    else()
-      message(SEND_ERROR "libdispatch requires a newer clang compiler (${CMAKE_C_COMPILER_VERSION} < 3.9)")
-    endif()
-
-    if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
-      set(SOURCEKIT_LIBDISPATCH_RUNTIME_DIR bin)
-    else()
-      set(SOURCEKIT_LIBDISPATCH_RUNTIME_DIR lib)
-    endif()
-
-    include(ExternalProject)
-    ExternalProject_Add(libdispatch
-                        SOURCE_DIR
-                          "${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}"
-                        CMAKE_ARGS
-                          -DCMAKE_AR=${CMAKE_AR}
-                          -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-                          -DCMAKE_C_COMPILER=${SWIFT_LIBDISPATCH_C_COMPILER}
-                          -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
-                          -DCMAKE_CXX_COMPILER=${SWIFT_LIBDISPATCH_CXX_COMPILER}
-                          -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
-                          -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
-                          -DCMAKE_INSTALL_LIBDIR=lib
-                          -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
-                          -DCMAKE_LINKER=${CMAKE_LINKER}
-                          -DCMAKE_RANLIB=${CMAKE_RANLIB}
-                          -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-                          -DBUILD_SHARED_LIBS=YES
-                          -DENABLE_SWIFT=NO
-                          -DENABLE_TESTING=NO
-                        INSTALL_COMMAND
-                          # NOTE(compnerd) provide a custom install command to
-                          # ensure that we strip out the DESTDIR environment
-                          # from the sub-build
-                          ${CMAKE_COMMAND} -E env --unset=DESTDIR ${CMAKE_COMMAND} --build . --target install
-                        STEP_TARGETS
-                          install
-                        BUILD_BYPRODUCTS
-                          <INSTALL_DIR>/${SOURCEKIT_LIBDISPATCH_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}dispatch${CMAKE_SHARED_LIBRARY_SUFFIX}
-                          <INSTALL_DIR>/lib/${CMAKE_IMPORT_LIBRARY_PREFIX}dispatch${CMAKE_IMPORT_LIBRARY_SUFFIX}
-                          <INSTALL_DIR>/${SOURCEKIT_LIBDISPATCH_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}BlocksRuntime${CMAKE_SHARED_LIBRARY_SUFFIX}
-                          <INSTALL_DIR>/lib/${CMAKE_IMPORT_LIBRARY_PREFIX}BlocksRuntime${CMAKE_IMPORT_LIBRARY_SUFFIX}
-                        BUILD_ALWAYS
-                          1)
-
-    ExternalProject_Get_Property(libdispatch install_dir)
-
-    # CMake does not like the addition of INTERFACE_INCLUDE_DIRECTORIES without
-    # the directory existing.  Just create the location which will be populated
-    # during the installation.
-    file(MAKE_DIRECTORY ${install_dir}/include)
-
-    add_library(dispatch SHARED IMPORTED)
-    set_target_properties(dispatch
-                          PROPERTIES
-                            IMPORTED_LOCATION
-                              ${install_dir}/${SOURCEKIT_LIBDISPATCH_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}dispatch${CMAKE_SHARED_LIBRARY_SUFFIX}
-                            IMPORTED_IMPLIB
-                              ${install_dir}/lib/${CMAKE_IMPORT_LIBRARY_PREFIX}dispatch${CMAKE_IMPORT_LIBRARY_SUFFIX}
-                            INTERFACE_INCLUDE_DIRECTORIES
-                              ${install_dir}/include)
-
-    add_library(BlocksRuntime SHARED IMPORTED)
-    set_target_properties(BlocksRuntime
-                          PROPERTIES
-                            IMPORTED_LOCATION
-                              ${install_dir}/${SOURCEKIT_LIBDISPATCH_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}BlocksRuntime${CMAKE_SHARED_LIBRARY_SUFFIX}
-                            IMPORTED_IMPLIB
-                              ${install_dir}/lib/${CMAKE_IMPORT_LIBRARY_PREFIX}BlocksRuntime${CMAKE_IMPORT_LIBRARY_SUFFIX}
-                            INTERFACE_INCLUDE_DIRECTORIES
-                              ${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}/src/BlocksRuntime)
-
-    add_dependencies(dispatch libdispatch-install)
-    add_dependencies(BlocksRuntime libdispatch-install)
-
-    if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
-      set(SOURCEKIT_RUNTIME_DIR bin)
-    else()
-      set(SOURCEKIT_RUNTIME_DIR lib)
-    endif()
-    add_dependencies(sourcekit-inproc BlocksRuntime dispatch)
-    if("${SWIFT_HOST_VARIANT_SDK}" MATCHES "OSX|WINDOWS")
-      swift_install_in_component(FILES
-                                   $<TARGET_FILE:dispatch>
-                                   $<TARGET_FILE:BlocksRuntime>
-                                 DESTINATION ${SOURCEKIT_RUNTIME_DIR}
-                                 COMPONENT sourcekit-inproc)
-    endif()
-    if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
-      swift_install_in_component(FILES
-                                   $<TARGET_LINKER_FILE:dispatch>
-                                   $<TARGET_LINKER_FILE:BlocksRuntime>
-                                 DESTINATION lib
-                                 COMPONENT sourcekit-inproc)
-    endif()
-
-
-    # FIXME(compnerd) this should be taken care of by the
-    # INTERFACE_INCLUDE_DIRECTORIES above
-    include_directories(AFTER
-                          ${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}/src/BlocksRuntime
-                          ${SWIFT_PATH_TO_LIBDISPATCH_SOURCE})
-  endif()
-endif()
+include(Libdispatch)
 
 # Add all of the subdirectories, where we actually do work.
 

cmake/modules/AddSwift.cmake

@@ -82,6 +82,10 @@ function(_add_host_variant_c_compile_link_flags name)
     set(DEPLOYMENT_VERSION "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
   endif()
 
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
+    set(DEPLOYMENT_VERSION ${SWIFT_ANDROID_API_LEVEL})
+  endif()
+
   # MSVC, clang-cl, gcc don't understand -target.
   if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT SWIFT_COMPILER_IS_MSVC_LIKE)
     get_target_triple(target target_variant "${SWIFT_HOST_VARIANT_SDK}" "${SWIFT_HOST_VARIANT_ARCH}"
@@ -271,18 +275,6 @@ function(_add_host_variant_c_compile_flags target)
     target_compile_options(${target} PRIVATE -funwind-tables)
   endif()
 
-  if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
-    target_compile_options(${target} PRIVATE -nostdinc++)
-    swift_android_libcxx_include_paths(CFLAGS_CXX_INCLUDES)
-    swift_android_include_for_arch("${SWIFT_HOST_VARIANT_ARCH}"
-      "${SWIFT_HOST_VARIANT_ARCH}_INCLUDE")
-    target_include_directories(${target} SYSTEM PRIVATE
-      ${CFLAGS_CXX_INCLUDES}
-      ${${SWIFT_HOST_VARIANT_ARCH}_INCLUDE})
-    target_compile_definitions(${target} PRIVATE
-      __ANDROID_API__=${SWIFT_ANDROID_API_LEVEL})
-  endif()
-
   if(SWIFT_HOST_VARIANT_SDK STREQUAL "LINUX")
     if(SWIFT_HOST_VARIANT_ARCH STREQUAL x86_64)
       # this is the minimum architecture that supports 16 byte CAS, which is
@@ -350,7 +342,7 @@ function(_add_host_variant_link_flags target)
     target_link_libraries(${target} PRIVATE
       ${cxx_link_libraries})
 
-    swift_android_lib_for_arch(${SWIFT_HOST_VARIANT_ARCH}
+    swift_android_libgcc_for_arch_cross_compile(${SWIFT_HOST_VARIANT_ARCH}
       ${SWIFT_HOST_VARIANT_ARCH}_LIB)
     target_link_directories(${target} PRIVATE
       ${${SWIFT_HOST_VARIANT_ARCH}_LIB})

cmake/modules/AddSwiftUnittests.cmake

@@ -48,7 +48,7 @@ function(add_swift_unittest test_dirname)
       COMMAND "${SWIFT_SOURCE_DIR}/utils/swift-rpathize.py"
               "$<TARGET_FILE:${test_dirname}>")
   elseif("${SWIFT_HOST_VARIANT}" STREQUAL "android")
-    swift_android_lib_for_arch(${SWIFT_HOST_VARIANT_ARCH} android_system_libs)
+    swift_android_libgcc_for_arch_cross_compile(${SWIFT_HOST_VARIANT_ARCH} android_system_libs)
     set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_DIRECTORIES
       "${android_system_libs}")
     set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_LIBRARIES "log")