Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/AST/DiagnosticsSIL.def

@@ -857,7 +857,8 @@ ERROR(sil_movechecking_borrowed_parameter_captured_by_closure, none,
       "parameter",
       (StringRef))
 ERROR(sil_movechecking_capture_consumed, none,
-      "noncopyable '%0' cannot be consumed when captured by an escaping closure", (StringRef))
+      "noncopyable '%0' cannot be consumed when captured by an escaping closure or borrowed by a non-Escapable type",
+      (StringRef))
 ERROR(sil_movechecking_not_reinitialized_before_end_of_function, none,
       "missing reinitialization of %select{inout parameter|closure capture}1 '%0' "
       "after consume", (StringRef, bool))

lib/SILGen/SILGenConcurrency.cpp

@@ -136,7 +136,8 @@ void SILGenFunction::emitExpectedExecutorProlog() {
   // Defer bodies are always called synchronously within their enclosing
   // function, so the check is unnecessary; in addition, we cannot
   // necessarily perform the check because the defer may not have
-  // captured the isolated parameter of the enclosing function.
+  // captured the isolated parameter of the enclosing function, and
+  // forcing a capture would cause DI problems in actor initializers.
   bool wantDataRaceChecks = [&] {
     if (F.isAsync() || F.isDefer())
       return false;

lib/Sema/TypeCheckCaptures.cpp

@@ -744,6 +744,31 @@ class FindCapturedVars : public ASTWalker {
 
 } // end anonymous namespace
 
+/// Given that a local function is isolated to the given var, should we
+/// force a capture of the var?
+static bool shouldCaptureIsolationInLocalFunc(AbstractFunctionDecl *AFD,
+                                              VarDecl *var) {
+  assert(isa<ParamDecl>(var));
+
+  // Don't try to capture an isolated parameter of the function itself.
+  if (var->getDeclContext() == AFD)
+    return false;
+
+  // We only *need* to force a capture of the isolation in an async function
+  // (in which case it's needed for executor switching) or if we're in the
+  // mode that forces an executor check in all synchronous functions. But
+  // it's a simpler rule if we just do it unconditionally.
+
+  // However, don't do it for the implicit functions that represent defer
+  // bodies, where it is both unnecessary and likely to lead to bad diagnostics.
+  // We already suppress the executor check in defer bodies.
+  if (auto FD = dyn_cast<FuncDecl>(AFD))
+    if (FD->isDeferBody())
+      return false;
+
+  return true;
+}
+
 CaptureInfo CaptureInfoRequest::evaluate(Evaluator &evaluator,
                                          AbstractFunctionDecl *AFD) const {
   auto type = AFD->getInterfaceType();
@@ -767,10 +792,7 @@ CaptureInfo CaptureInfoRequest::evaluate(Evaluator &evaluator,
     auto actorIsolation = getActorIsolation(AFD);
     if (actorIsolation.getKind() == ActorIsolation::ActorInstance) {
       if (auto *var = actorIsolation.getActorInstance()) {
-        assert(isa<ParamDecl>(var));
-        // Don't capture anything if the isolation parameter is a parameter
-        // of the local function.
-        if (var->getDeclContext() != AFD)
+        if (shouldCaptureIsolationInLocalFunc(AFD, var))
           finder.addCapture(CapturedValue(var, 0, AFD->getLoc()));
       }
     }

test/SILGen/local_function_isolation.swift

@@ -71,7 +71,7 @@ actor GenericActor<K> {
 // Make sure defer doesn't capture anything.
 actor DeferInsideInitActor {
   init(foo: ()) async throws {
-    // CHECK-LABEL: sil private [ossa] @$s24local_function_isolation20DeferInsideInitActorC3fooACyt_tYaKcfc6$deferL_yyF : $@convention(thin) (@sil_isolated @guaranteed DeferInsideInitActor) -> () {
+    // CHECK-LABEL: sil private [ossa] @$s24local_function_isolation20DeferInsideInitActorC3fooACyt_tYaKcfc6$deferL_yyF : $@convention(thin) () -> () {
     defer {}
     self.init()
   }

test/SILOptimizer/definite_init_actor.swift

@@ -10,6 +10,7 @@
 
 func neverReturn() -> Never { fatalError("quit!") }
 func arbitraryAsync() async {}
+func makeIntOrThrow() throws -> Int { return 0 }
 
 actor BoringActor {
 
@@ -402,3 +403,40 @@ actor Ahmad {
   // CHECK: } // end sil function '$s4test5AhmadCACyYacfc'
   nonisolated init() async {}
 }
+
+// This should not complain about needing self in the defer prior to it being
+// fully initialized.
+actor Customer {
+  var x: Int
+  var y: Int
+
+  // CHECK-LABEL: sil hidden @$s4test8CustomerCACyYaKcfc :
+  init() async throws {
+    // CHECK:      [[GENERIC:%[0-9]+]] = enum $Optional<Builtin.Executor>, #Optional.none!enumelt
+    // CHECK-NEXT: hop_to_executor [[GENERIC]]
+    // CHECK:      [[SELF:%.*]] = end_init_let_ref %0 : $Customer
+
+    defer { print("I have a complaint") }
+
+    // CHECK:       try_apply {{.*}}, error [[FAIL1:bb[0-9]+]]
+    self.x = try makeIntOrThrow()
+
+    // CHECK:       try_apply {{.*}}, error [[FAIL2:bb[0-9]+]]
+    // CHECK:       hop_to_executor [[SELF]] : $Customer
+    self.y = try makeIntOrThrow()
+
+    // CHECK:      [[DEFER:%.*]] = function_ref @$s4test8CustomerCACyYaKcfc6$deferL_yyF :
+    // CHECK-NEXT: apply [[DEFER]]()
+    // CHECK-NEXT: return [[SELF]] : $Customer
+
+    // CHECK:    [[FAIL1]]({{%.*}} : $any Error):
+    // CHECK-NEXT: // function_ref
+    // CHECK-NEXT: [[DEFER:%.*]] = function_ref @$s4test8CustomerCACyYaKcfc6$deferL_yyF :
+    // CHECK-NEXT: apply [[DEFER]]()
+
+    // CHECK:    [[FAIL2]]({{%.*}} : $any Error):
+    // CHECK-NEXT: // function_ref
+    // CHECK-NEXT: [[DEFER:%.*]] = function_ref @$s4test8CustomerCACyYaKcfc6$deferL_yyF :
+    // CHECK-NEXT: apply [[DEFER]]()
+  }
+}

test/SILOptimizer/lifetime_dependence/verify_diagnostics.swift

@@ -121,6 +121,23 @@ struct TestDeinitCallsAddressor: ~Copyable, ~Escapable {
   }
 }
 
+struct NCBuffer: ~Copyable {
+  fileprivate let buffer: UnsafeMutableRawBufferPointer
+
+  public init() {
+    let ptr = UnsafeMutableRawPointer.init(bitPattern: 0)
+    self.buffer = UnsafeMutableRawBufferPointer(start: ptr, count: 0)
+  }
+
+  public var bytes: Span<UInt8> {
+    @_lifetime(borrow self)
+    borrowing get {
+      let span: Span<UInt8> = Span(_bytes: self.buffer.bytes)
+      return span
+    }
+  }
+}
+
 // Test a borrowed dependency on an address
 @_lifetime(immortal)
 public func testGenericDep<T: ~Escapable>(type: T.Type) -> T {
@@ -287,3 +304,15 @@ func testSpanMayThrow(buffer: inout [Int]) {
   let bufferSpan = buffer.mutableSpan
   try! mutableSpanMayThrow(bufferSpan)
 }
+
+// =============================================================================
+// Dependence on non-Copyable values
+// =============================================================================
+
+@_lifetime(immortal)
+func dependOnNonCopyable() -> NCBuffer {
+  let buffer = NCBuffer()
+  let count = buffer.bytes.count
+  _ = count
+  return buffer // expected-error {{noncopyable 'buffer' cannot be consumed when captured by an escaping closure or borrowed by a non-Escapable type}}
+}

utils/swift_build_support/swift_build_support/products/wasmswiftsdk.py

@@ -130,7 +130,8 @@ def _build_libxml2(self, swift_host_triple, has_pthread, wasi_sysroot):
         libxml2.cmake_options.define('HAVE_PTHREAD_H', cmake_thread_enabled)
 
         libxml2.build_with_cmake([], self.args.build_variant, [],
-                                 prefer_native_toolchain=True)
+                                 prefer_native_toolchain=True,
+                                 ignore_extra_cmake_options=True)
         with shell.pushd(libxml2.build_dir):
             shell.call([self.toolchain.cmake, '--install', '.', '--prefix', '/', '--component', 'development'],
                        env={'DESTDIR': wasi_sysroot})
@@ -158,7 +159,8 @@ def _build_foundation(self, swift_host_triple, has_pthread, wasi_sysroot):
         foundation.cmake_options.define('LIBXML2_LIBRARY', os.path.join(wasi_sysroot, 'lib'))
 
         foundation.build_with_cmake([], self.args.build_variant, [],
-                                     prefer_native_toolchain=True)
+                                    prefer_native_toolchain=True,
+                                    ignore_extra_cmake_options=True)
 
         dest_dir = self._target_package_path(swift_host_triple)
         with shell.pushd(foundation.build_dir):
@@ -184,7 +186,8 @@ def _build_swift_testing(self, swift_host_triple, has_pthread, wasi_sysroot):
         swift_testing.cmake_options.define('SwiftTesting_MACRO', 'NO')
 
         swift_testing.build_with_cmake([], self.args.build_variant, [],
-                                       prefer_native_toolchain=True)
+                                       prefer_native_toolchain=True,
+                                       ignore_extra_cmake_options=True)
         dest_dir = self._target_package_path(swift_host_triple)
         with shell.pushd(swift_testing.build_dir):
             shell.call([self.toolchain.cmake, '--install', '.', '--prefix', '/usr'],