Merge pull request #4867 from swiftwasm/katei/merge-main-2022-09-09

Merge main 2022-09-09

Author: kateinoigakukun

CHANGELOG.md

@@ -16,6 +16,43 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [SE-0327][]:
+
+  There are a few notable changes in Swift 5.7 with respect to SE-0327.
+
+  First, the deinitializer and most kinds of initializers for `actor` types, and types constrained by a global actor like the `@MainActor`, have revised rules about what expressions are permitted in their body. The goal of these revisions has been to improve language expressivity and safety. In particular, many more programming patterns are now permitted in these initializers.
+
+  For example, a non-async initializer of an `actor` prior to Swift 5.7 would raise a diagnostic any time `self` escapes the initializer before returning. That diagnostic's purpose was to protect against a possible data race when accessing isolated stored proeprties. But, that diagnostic was emitted even if there was no dangerous racy access.
+
+  In Swift 5.7, the compiler now checks these initializers for dangerous accesses to isolated stored properties that occur after an escape of `self`:
+
+  ```swift
+  actor Database {
+    // ... other properties ...
+    var rows: Int = 0
+
+    init(_ world: DataUser) {
+      defer {
+        print("last = \(self.rows)") // ❌ this access to 'rows' is illegal.
+      }
+
+      print("before = \(self.rows)") // ✅ this access to 'rows' is OK
+      world.publishDatabase(self)    // ✅ passing 'self' is OK in Swift 5.7+
+      print("after = \(self.rows)")  // ❌ this access to 'rows' is illegal. 
+
+      Task { [weak self] in          // ✅ capturing 'self' is OK in Swift 5.7+
+        while let db = self { await db.prune() }
+      }
+    }
+  }
+  ```
+
+  This is a control-flow sensitive check, meaning an illegal access does not necessarily appear on a source line after an escape of `self` (in the example above, consider _when_ the `defer` is executed). The compiler will always point out one of the escapes of `self` that is causing an access to become illegal.
+
+  Next, delegating initializers of an actor are no longer always non-isolated. This means an `async` delegating initializer can do the same things as a non-delegating one.
+
+  Finally, the diagnostic about non-isolated default-value expressions introduced for Swift 5.6 in the Xcode 13.3 release has been removed. The proposed rule was not precise enough to avoid flagging an innocuous yet common pattern in SwiftUI code involving `@StateObject` properties and `@MainActor`.
+
 * The Swift compiler no longer warns about redundant requirements in generic declarations. For example,
   the following code diagnosed a warning in Swift 5.6 about the `T.Iterator : IteratorProtocol`
   requirement being redundant, because it is implied by `T : Sequence`:

CMakeLists.txt

@@ -628,6 +628,11 @@ if(CMAKE_C_COMPILER_ID MATCHES Clang)
   add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Werror=c++98-compat-extra-semi>)
 endif()
 
+# Make sure we know where swift-syntax is because we need it to build the parser.
+if(NOT EXISTS "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}")
+  message(SEND_ERROR "swift-syntax is required to build the Swift compiler. Please run update-checkout or specify SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE")
+endif()
+
 # Use dispatch as the system scheduler by default.
 # For convenience, we set this to false when concurrency is disabled.
 set(SWIFT_CONCURRENCY_USES_DISPATCH FALSE)
@@ -755,7 +760,7 @@ elseif(BOOTSTRAPPING_MODE MATCHES "BOOTSTRAPPING.*")
   else()
     set(BOOTSTRAPPING_MODE "HOSTTOOLS")
   endif()
-elseif(BOOTSTRAPPING_MODE STREQUAL "HOSTTOOLS")
+elseif(BOOTSTRAPPING_MODE STREQUAL "HOSTTOOLS" OR SWIFT_SWIFT_PARSER)
   # We are building using a pre-installed host toolchain but not bootstrapping
   # the Swift modules. This happens when building using 'build-tooling-libs'
   # where we haven't built a new Swift compiler. Use the Swift compiler from the
@@ -868,6 +873,13 @@ if(XCODE)
   set(SWIFT_SDKS "OSX")
 endif()
 
+# When we have the early SwiftSyntax build, we can include its parser.
+if(SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR)
+  set(SWIFT_SWIFT_PARSER TRUE)
+  include(${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR}/cmake/SwiftSyntaxTargets.cmake)
+endif()
+
+
 # FIXME: the parameters we specify in SWIFT_SDKS are lacking architecture specifics,
 # so we need to hard-code it. For example, the SDK for Android is just 'ANDROID',
 # and we have to specify SWIFT_SDK_ANDROID_ARCHITECTURES separately.
@@ -1074,6 +1086,7 @@ if(SWIFT_INCLUDE_TOOLS)
   message(STATUS "  Assertions:     ${LLVM_ENABLE_ASSERTIONS}")
   message(STATUS "  LTO:            ${SWIFT_TOOLS_ENABLE_LTO}")
   message(STATUS "  Bootstrapping:  ${BOOTSTRAPPING_MODE}")
+  message(STATUS "  Swift parser:   ${SWIFT_SWIFT_PARSER}")
   message(STATUS "")
 else()
   message(STATUS "Not building host Swift tools")
@@ -1168,6 +1181,7 @@ endif()
 if(SWIFT_BUILD_STDLIB)
   add_subdirectory(stdlib)
 else()
+  set(SWIFT_STDLIB_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/stdlib")
   # Some of the things below depend on the threading library
   add_subdirectory(stdlib/public/Threading)
 

SwiftCompilerSources/CMakeLists.txt

@@ -160,6 +160,21 @@ function(add_swift_compiler_modules_library name)
     if (add_to_syntaxparse)
       set(syntaxparse_obj_files ${syntaxparse_obj_files} ${module_obj_file})
     endif()
+    set(c_include_paths
+      # LLVM modules and headers.
+      "${LLVM_MAIN_INCLUDE_DIR}"
+      # Generated LLVM headers.
+      "${LLVM_INCLUDE_DIR}"
+      # Clang modules and headers.
+      ${CLANG_INCLUDE_DIRS}
+      # Bridging modules and headers.
+      "${SWIFT_MAIN_INCLUDE_DIR}"
+      # Generated C headers.
+      "${CMAKE_CURRENT_BINARY_DIR}/../include")
+    set(c_include_paths_args)
+    foreach(c_include_path ${c_include_paths})
+      list(APPEND c_include_paths_args "-Xcc" "-I" "-Xcc" "${c_include_path}")
+    endforeach()
 
     # Compile the module into an object file
     add_custom_command_target(dep_target OUTPUT ${module_obj_file}
@@ -173,14 +188,7 @@ function(add_swift_compiler_modules_library name)
               "-emit-module-path" "${build_dir}/${module}.swiftmodule"
               "-parse-as-library" ${sources}
               "-wmo" ${swift_compile_options}
-              # LLVM modules and headers.
-              "-Xcc" "-I" "-Xcc" "${LLVM_MAIN_INCLUDE_DIR}"
-              # Generated LLVM headers.
-              "-Xcc" "-I" "-Xcc" "${LLVM_INCLUDE_DIR}"
-              # Bridging modules and headers.
-              "-Xcc" "-I" "-Xcc" "${SWIFT_SOURCE_DIR}/include"
-              # Generated C headers.
-              "-Xcc" "-I" "-Xcc" "${CMAKE_CURRENT_BINARY_DIR}/../include"
+              ${c_include_paths_args}
               # Generated swift modules.
               "-I" "${build_dir}"
       COMMENT "Building swift module ${module}")

SwiftCompilerSources/Package.swift

@@ -22,6 +22,8 @@ private extension Target {
       "-Xcc", "-I", "-Xcc", "../include",
       // LLVM modules and headers
       "-Xcc", "-I", "-Xcc", "../../llvm-project/llvm/include",
+      // Clang modules and headers
+      "-Xcc", "-I", "-Xcc", "../../llvm-project/clang/include",
       "-cross-module-optimization"
     ]),
   ]

SwiftCompilerSources/Sources/Optimizer/CMakeLists.txt

@@ -15,6 +15,7 @@ add_subdirectory(Analysis)
 add_subdirectory(DataStructures)
 add_subdirectory(InstructionPasses)
 add_subdirectory(PassManager)
+add_subdirectory(ModulePasses)
 add_subdirectory(FunctionPasses)
 add_subdirectory(TestPasses)
 add_subdirectory(Utilities)

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -109,13 +109,6 @@ struct FunctionUses {
   // The use-list head for each function.
   private var uses: [Function: FirstUse] = [:]
 
-  init() {
-    // Already start with a reasonable big capacity to reduce the number of
-    // re-allocations when appending to the data structures.
-    useStorage.reserveCapacity(128)
-    uses.reserveCapacity(64)
-  }
-
   /// Returns the use-list of `function`.
   ///
   /// Note that `collect` must be called before `getUses` can be used.
@@ -125,7 +118,12 @@ struct FunctionUses {
 
   /// Collects all uses of all function in the module.
   mutating func collect(context: ModulePassContext) {
-  
+
+    // Already start with a reasonable big capacity to reduce the number of
+    // re-allocations when appending to the data structures.
+    useStorage.reserveCapacity(128)
+    uses.reserveCapacity(64)
+
     // Mark all functions, which are referenced from tables, to have "unknown" uses.
 
     for vTable in context.vTables {

SwiftCompilerSources/Sources/Optimizer/ModulePasses/CMakeLists.txt

@@ -0,0 +1,11 @@
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2014 - 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
+
+swift_compiler_sources(Optimizer
+  StackProtection.swift
+)