Merge pull request #3689 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

include/swift/AST/KnownIdentifiers.def

@@ -264,6 +264,7 @@ IDENTIFIER(identifier)
 IDENTIFIER(_distributedActorRemoteInitialize)
 IDENTIFIER(_distributedActorDestroy)
 IDENTIFIER(__isRemoteActor)
+IDENTIFIER(whenLocal)
 
 #undef IDENTIFIER
 #undef IDENTIFIER_

include/swift/Sema/ConstraintSystem.h

@@ -2181,6 +2181,10 @@ class SolutionApplicationTarget {
 using RewriteTargetFn = std::function<
     Optional<SolutionApplicationTarget> (SolutionApplicationTarget)>;
 
+/// Represents a conversion restriction between two types.
+using ConversionRestriction =
+    std::tuple<TypeBase *, TypeBase *, ConversionRestrictionKind>;
+
 enum class ConstraintSystemPhase {
   ConstraintGeneration,
   Solving,
@@ -2367,8 +2371,7 @@ class ConstraintSystem {
   /// there are multiple ways in which one type could convert to another, e.g.,
   /// given class types A and B, the solver might choose either a superclass
   /// conversion or a user-defined conversion.
-  std::vector<std::tuple<Type, Type, ConversionRestrictionKind>>
-      ConstraintRestrictions;
+  std::vector<ConversionRestriction> ConstraintRestrictions;
 
   /// The set of fixes applied to make the solution work.
   llvm::SmallVector<ConstraintFix *, 4> Fixes;

lib/Sema/CSDiagnostics.cpp

@@ -2957,6 +2957,20 @@ bool ContextualFailure::tryTypeCoercionFixIt(
   if (!toType->hasTypeRepr())
     return false;
 
+  // If object of the optional type is a subtype of the specified contextual
+  // type, let's suggest a force unwrap "!". Otherwise fallback to potential
+  // coercion or force cast.
+  if (!bothOptional && fromType->getOptionalObjectType()) {
+    if (TypeChecker::isSubtypeOf(fromType->lookThroughAllOptionalTypes(),
+                                 toType, getDC())) {
+      diagnostic.fixItInsert(
+          Lexer::getLocForEndOfToken(getASTContext().SourceMgr,
+                                     getSourceRange().End),
+          "!");
+      return true;
+    }
+  }
+
   CheckedCastKind Kind =
       TypeChecker::typeCheckCheckedCast(fromType, toType,
                                         CheckedCastContextKind::None, getDC(),

lib/Sema/CSSimplify.cpp

@@ -3908,9 +3908,8 @@ bool ConstraintSystem::repairFailures(
       // If the result type of the coercion has an value to optional conversion
       // we can instead suggest the conditional downcast as it is safer in
       // situations like conditional binding.
-      auto useConditionalCast = llvm::any_of(
-          ConstraintRestrictions,
-          [&](std::tuple<Type, Type, ConversionRestrictionKind> restriction) {
+      auto useConditionalCast =
+          llvm::any_of(ConstraintRestrictions, [&](auto &restriction) {
             ConversionRestrictionKind restrictionKind;
             Type type1, type2;
             std::tie(type1, type2, restrictionKind) = restriction;
@@ -6717,7 +6716,9 @@ static bool isCastToExpressibleByNilLiteral(ConstraintSystem &cs, Type fromType,
 static ConstraintFix *maybeWarnAboutExtraneousCast(
     ConstraintSystem &cs, Type origFromType, Type origToType, Type fromType,
     Type toType, SmallVector<Type, 4> fromOptionals,
-    SmallVector<Type, 4> toOptionals, ConstraintSystem::TypeMatchOptions flags,
+    SmallVector<Type, 4> toOptionals,
+    const std::vector<ConversionRestriction> &constraintRestrictions,
+    ConstraintSystem::TypeMatchOptions flags,
     ConstraintLocatorBuilder locator) {
 
   auto last = locator.last();
@@ -6739,6 +6740,18 @@ static ConstraintFix *maybeWarnAboutExtraneousCast(
   // "from" could be less optional than "to" e.g. `0 as Any?`, so
   // we need to store the difference as a signed integer.
   int extraOptionals = fromOptionals.size() - toOptionals.size();
+
+  // "from" expression could be a type variable with value-to-optional
+  // restrictions that we have to account for optionality mismatch.
+  const auto subExprType = cs.getType(castExpr->getSubExpr());
+  if (llvm::is_contained(
+          constraintRestrictions,
+          std::make_tuple(fromType.getPointer(), subExprType.getPointer(),
+                          ConversionRestrictionKind::ValueToOptional))) {
+    extraOptionals++;
+    origFromType = OptionalType::get(origFromType);
+  }
+
   // Removing the optionality from to type when the force cast expr is an IUO.
   const auto *const TR = castExpr->getCastTypeRepr();
   if (isExpr<ForcedCheckedCastExpr>(anchor) && TR &&
@@ -6894,7 +6907,7 @@ ConstraintSystem::simplifyCheckedCastConstraint(
 
     if (auto *fix = maybeWarnAboutExtraneousCast(
             *this, origFromType, origToType, fromType, toType, fromOptionals,
-            toOptionals, flags, locator)) {
+            toOptionals, ConstraintRestrictions, flags, locator)) {
       (void)recordFix(fix);
     }
   };
@@ -6962,7 +6975,7 @@ ConstraintSystem::simplifyCheckedCastConstraint(
     // succeed or fail.
     if (auto *fix = maybeWarnAboutExtraneousCast(
             *this, origFromType, origToType, fromType, toType, fromOptionals,
-            toOptionals, flags, locator)) {
+            toOptionals, ConstraintRestrictions, flags, locator)) {
       (void)recordFix(fix);
     }
 
@@ -11372,7 +11385,8 @@ ConstraintSystem::simplifyRestrictedConstraint(
       addFixConstraint(fix, matchKind, type1, type2, locator);
     }
 
-    ConstraintRestrictions.push_back(std::make_tuple(type1, type2, restriction));
+    ConstraintRestrictions.push_back(
+        std::make_tuple(type1.getPointer(), type2.getPointer(), restriction));
     return SolutionKind::Solved;
   }
   case SolutionKind::Unsolved:

lib/Sema/CSSolver.cpp

@@ -231,9 +231,10 @@ void ConstraintSystem::applySolution(const Solution &solution) {
   // Register constraint restrictions.
   // FIXME: Copy these directly into some kind of partial solution?
   for (auto restriction : solution.ConstraintRestrictions) {
-    ConstraintRestrictions.push_back(
-        std::make_tuple(restriction.first.first, restriction.first.second,
-                        restriction.second));
+    auto &types = restriction.first;
+    ConstraintRestrictions.push_back(std::make_tuple(types.first.getPointer(),
+                                                     types.second.getPointer(),
+                                                     restriction.second));
   }
 
   // Register the solution's disjunction choices.

lib/Sema/TypeCheckConcurrency.cpp

@@ -1432,6 +1432,11 @@ namespace {
       bool isPotentiallyIsolated = false;
       if (!var) {
         isPotentiallyIsolated = false;
+      } else if (var->getName().str().equals("__secretlyKnownToBeLocal")) {
+        // FIXME(distributed): we did a dynamic check and know that this actor is local,
+        //  but we can't express that to the type system; the real implementation
+        //  will have to mark 'self' as "known to be local" after an is-local check.
+        isPotentiallyIsolated = true;
       } else if (auto param = dyn_cast<ParamDecl>(var)) {
         isPotentiallyIsolated = param->isIsolated();
       } else if (var->isSelfParamCapture()) {

stdlib/public/Distributed/DistributedActor.swift

@@ -116,6 +116,28 @@ extension DistributedActor {
   }
 }
 
+// ==== Local actor special handling -------------------------------------------
+
+@available(SwiftStdlib 5.5, *)
+extension DistributedActor {
+
+  /// Executes the passed 'body' only when the distributed actor is local instance.
+  ///
+  /// The `Self` passed to the the body closure is isolated, meaning that the
+  /// closure can be used to call non-distributed functions, or even access actor
+  /// state.
+  ///
+  /// When the actor is remote, the closure won't be executed and this function will return nil.
+  public nonisolated func whenLocal<T>(_ body: @Sendable (isolated Self) async throws -> T)
+    async rethrows -> T? where T: Sendable {
+    if __isLocalActor(self) {
+       return try await body(self)
+    } else {
+      return nil
+    }
+  }
+}
+
 /******************************************************************************/
 /***************************** Actor Identity *********************************/
 /******************************************************************************/

test/Constraints/casts.swift

@@ -613,3 +613,41 @@ func decodeStringOrIntDictionary<T: FixedWidthInteger>() -> [Int: T] {
     fatalError()
   }
 }
+
+
+// SR-15281
+struct SR15281_A { }
+struct SR15281_B {
+  init(a: SR15281_A) { }
+}
+
+struct SR15281_S {
+  var a: SR15281_A? = SR15281_A()
+
+  var b: SR15281_B {
+    a.flatMap(SR15281_B.init(a:)) // expected-error{{cannot convert return expression of type 'SR15281_B?' to return type 'SR15281_B'}} {{34-34=!}}
+  }
+
+  var b1: SR15281_B {
+    a.flatMap(SR15281_B.init(a:)) as! SR15281_B 
+    // expected-warning@-1 {{forced cast from 'SR15281_B?' to 'SR15281_B' only unwraps optionals; did you mean to use '!'?}} {{34-34=!}} {{34-48=}}
+  }
+}
+
+class SR15281_AC {}
+class SR15281_BC {
+  init(a: SR15281_AC) { }
+}
+class SR15281_CC: SR15281_BC {}
+
+struct SR15281_SC {
+  var a: SR15281_AC? = SR15281_AC()
+
+  var b: SR15281_BC {
+    a.flatMap(SR15281_BC.init(a:)) // expected-error{{cannot convert return expression of type 'SR15281_BC?' to return type 'SR15281_BC'}} {{35-35=!}}
+  }
+
+  var c: SR15281_BC {
+    a.flatMap(SR15281_CC.init(a:)) // expected-error{{cannot convert return expression of type 'SR15281_CC?' to return type 'SR15281_BC'}} {{35-35=!}}
+  }
+}

test/Distributed/Runtime/distributed_actor_deinit.swift

@@ -7,7 +7,7 @@
 // UNSUPPORTED: use_os_stdlib
 // UNSUPPORTED: back_deployment_runtime
 
-// temporary non-support. tracked in rdar://82593574
+// FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
 // UNSUPPORTED: windows
 
 import _Distributed

test/Distributed/Runtime/distributed_actor_whenLocal.swift

@@ -0,0 +1,83 @@
+// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -Xfrontend -enable-experimental-distributed -parse-as-library) | %FileCheck %s --dump-input=always
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+// rdar://76038845
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+// FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
+// UNSUPPORTED: windows
+
+import _Distributed
+
+distributed actor Capybara {
+  // only the local capybara can do this!
+  func eat() -> String {
+    "watermelon"
+  }
+}
+
+
+// ==== Fake Transport ---------------------------------------------------------
+@available(SwiftStdlib 5.5, *)
+struct ActorAddress: ActorIdentity {
+  let address: String
+  init(parse address: String) {
+    self.address = address
+  }
+}
+
+@available(SwiftStdlib 5.5, *)
+struct FakeTransport: ActorTransport {
+  func decodeIdentity(from decoder: Decoder) throws -> AnyActorIdentity {
+    fatalError("not implemented:\(#function)")
+  }
+
+  func resolve<Act>(_ identity: AnyActorIdentity, as actorType: Act.Type)
+  throws -> Act? where Act: DistributedActor {
+    return nil
+  }
+
+  func assignIdentity<Act>(_ actorType: Act.Type) -> AnyActorIdentity
+          where Act: DistributedActor {
+    let id = ActorAddress(parse: "xxx")
+    return .init(id)
+  }
+
+  func actorReady<Act>(_ actor: Act) where Act: DistributedActor {
+  }
+
+  func resignIdentity(_ id: AnyActorIdentity) {
+  }
+}
+
+func test() async throws {
+  let transport = FakeTransport()
+
+  let local = Capybara(transport: transport)
+  // await local.eat() // SHOULD ERROR
+  let valueWhenLocal: String? = await local.whenLocal { __secretlyKnownToBeLocal in
+    __secretlyKnownToBeLocal.eat()
+  }
+
+  // CHECK: valueWhenLocal: watermelon
+  print("valueWhenLocal: \(valueWhenLocal ?? "nil")")
+
+  let remote = try Capybara.resolve(local.id, using: transport)
+  let valueWhenRemote: String? = await remote.whenLocal { __secretlyKnownToBeLocal in
+    __secretlyKnownToBeLocal.eat()
+  }
+  
+  // CHECK: valueWhenRemote: nil
+  print("valueWhenRemote: \(valueWhenRemote ?? "nil")")
+}
+
+@available(SwiftStdlib 5.5, *)
+@main struct Main {
+  static func main() async {
+    try! await test()
+  }
+}