Merge pull request #3940 from swiftwasm/main

Author: MaxDesiatov

docs/DifferentiableProgramming.md

@@ -1743,7 +1743,7 @@ func foo<T, U, V>(_ x: T, _ y: U, _ z: V) -> W { ... }
 
 // Transpose with respect to `x` and `z`, requiring that `T` and `V` to conform
 // to `Differentiable & AdditiveArithmetic` and equal their corresponding
-`TangentVector` types.
+// `TangentVector` types.
 @transpose(of: foo, wrt: (x, z))
 func _<
     T: Differentiable & AdditiveArithmetic,
@@ -1911,7 +1911,7 @@ result (labeled `value`) and a differential (labeled `differential`). The
 differential is a linear map (`@differentiable(linear)`) function that takes the
 `TangentVector` nested types of all of the types of the original function's
 parameters to differentiate with respect to, and returns the `TangentVector`
-nested type of the orgiinal function's result type.
+nested type of the original function's result type.
 
 ###### Differentiability parameters
 

lib/ClangImporter/ImportDecl.cpp

@@ -9751,39 +9751,33 @@ static void loadAllMembersOfSuperclassIfNeeded(ClassDecl *CD) {
     E->loadAllMembers();
 }
 
-static void loadAllMembersOfRecordDecl(StructDecl *recordDecl) {
-  auto &ctx = recordDecl->getASTContext();
+void ClangImporter::Implementation::loadAllMembersOfRecordDecl(
+    StructDecl *recordDecl) {
   auto clangRecord = cast<clang::RecordDecl>(recordDecl->getClangDecl());
 
-  // This is only to keep track of the members we've already seen.
-  llvm::SmallPtrSet<Decl *, 16> addedMembers;
-  for (auto member : recordDecl->getCurrentMembersWithoutLoading())
-    addedMembers.insert(member);
-
-  for (auto member : clangRecord->decls()) {
-    auto namedDecl = dyn_cast<clang::NamedDecl>(member);
-    if (!namedDecl)
-      continue;
-
-    // Don't try to load ourselves (this will create an infinite loop).
-    if (auto possibleSelf = dyn_cast<clang::RecordDecl>(member))
-      if (possibleSelf->getDefinition() == clangRecord)
-        continue;
-
+  // Import all of the members.
+  llvm::SmallVector<Decl *, 16> members;
+  for (const clang::Decl *m : clangRecord->decls()) {
+    auto nd = dyn_cast<clang::NamedDecl>(m);
     // Currently, we don't import unnamed bitfields.
-    if (isa<clang::FieldDecl>(member) &&
-        cast<clang::FieldDecl>(member)->isUnnamedBitfield())
+    if (isa<clang::FieldDecl>(m) &&
+        cast<clang::FieldDecl>(m)->isUnnamedBitfield())
       continue;
 
-    auto name = ctx.getClangModuleLoader()->importName(namedDecl);
-    if (!name)
-      continue;
+    if (nd && nd == nd->getCanonicalDecl() &&
+        nd->getDeclContext() == clangRecord &&
+        isVisibleClangEntry(nd))
+      insertMembersAndAlternates(nd, members);
+  }
 
-    for (auto found : recordDecl->lookupDirect(name)) {
-      if (addedMembers.insert(found).second &&
-          found->getDeclContext() == recordDecl)
-        recordDecl->addMember(found);
-    }
+  // Add the members here.
+  for (auto member: members) {
+    // FIXME: constructors are added eagerly, but shouldn't be
+    // FIXME: subscripts are added eagerly, but shouldn't be
+    if (!isa<AccessorDecl>(member) &&
+        !isa<SubscriptDecl>(member) &&
+        !isa<ConstructorDecl>(member))
+      recordDecl->addMember(member);
   }
 }
 
@@ -9819,13 +9813,7 @@ ClangImporter::Implementation::loadAllMembers(Decl *D, uint64_t extra) {
   }
 
   if (isa_and_nonnull<clang::RecordDecl>(D->getClangDecl())) {
-    // We haven't loaded any members yet, so tell our context that it still has
-    // lazy members. Otherwise, we won't be able to look up any individual
-    // members (lazily) in "loadAllMembersOfRecordDecl".
-    cast<StructDecl>(D)->setHasLazyMembers(true);
     loadAllMembersOfRecordDecl(cast<StructDecl>(D));
-    // Now that all members are loaded, mark the context as lazily complete.
-    cast<StructDecl>(D)->setHasLazyMembers(false);
     return;
   }
 

lib/ClangImporter/ImporterImpl.h

@@ -1390,6 +1390,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void
   loadAllMembersOfObjcContainer(Decl *D,
                                 const clang::ObjCContainerDecl *objcContainer);
+  void loadAllMembersOfRecordDecl(StructDecl *recordDecl);
+
   void collectMembersToAdd(const clang::ObjCContainerDecl *objcContainer,
                            Decl *D, DeclContext *DC,
                            SmallVectorImpl<Decl *> &members);

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1893,6 +1893,7 @@ static bool isScratchBuffer(SILValue value) {
 
 bool swift::memInstMustInitialize(Operand *memOper) {
   SILValue address = memOper->get();
+
   SILInstruction *memInst = memOper->getUser();
 
   switch (memInst->getKind()) {
@@ -1908,6 +1909,12 @@ bool swift::memInstMustInitialize(Operand *memOper) {
   case SILInstructionKind::InjectEnumAddrInst:
     return true;
 
+  case SILInstructionKind::BeginApplyInst:
+  case SILInstructionKind::TryApplyInst:
+  case SILInstructionKind::ApplyInst: {
+    FullApplySite applySite(memInst);
+    return applySite.isIndirectResultOperand(*memOper);
+  }
   case SILInstructionKind::StoreInst:
     return cast<StoreInst>(memInst)->getOwnershipQualifier()
            == StoreOwnershipQualifier::Init;

lib/Sema/TypeCheckConcurrency.cpp

@@ -428,9 +428,19 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
       // nonisolated, they need cross-actor restrictions (e.g., for Sendable).
       if (auto *ctor = dyn_cast<ConstructorDecl>(decl))
         if (!ctor->isConvenienceInit())
-          if (auto *parent = dyn_cast<ClassDecl>(ctor->getParent()))
-              if (parent->isAnyActor())
-                return forActorSelf(parent, /*isCrossActor=*/true);
+          if (auto *parent = ctor->getParent()->getSelfClassDecl())
+            if (parent->isAnyActor())
+              return forActorSelf(parent, /*isCrossActor=*/true);
+
+      // `nonisolated let` members are cross-actor as well.
+      if (auto var = dyn_cast<VarDecl>(decl)) {
+        if (var->isInstanceMember() && var->isLet()) {
+          if (auto parent = var->getDeclContext()->getSelfClassDecl()) {
+            if (parent->isActor() && !parent->isDistributedActor())
+              return forActorSelf(parent, /*isCrossActor=*/true);
+          }
+        }
+      }
 
       return forUnrestricted();
 
@@ -3214,18 +3224,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // If this declaration has one of the actor isolation attributes, report
   // that.
   if (isolationFromAttr) {
-    // Nonisolated declarations must involve Sendable types.
-    if (*isolationFromAttr == ActorIsolation::Independent) {
-      SubstitutionMap subs;
-      if (auto genericEnv = value->getInnermostDeclContext()
-              ->getGenericEnvironmentOfContext()) {
-        subs = genericEnv->getForwardingSubstitutionMap();
-      }
-      diagnoseNonSendableTypesInReference(
-          ConcreteDeclRef(value, subs), value->getDeclContext(),
-          value->getLoc(), ConcurrentReferenceKind::Nonisolated);
-    }
-
     // Classes with global actors have additional rules regarding inheritance.
     if (isolationFromAttr->isGlobalActor()) {
       if (auto classDecl = dyn_cast<ClassDecl>(value))

lib/Sema/TypeCheckProtocol.cpp

@@ -2864,6 +2864,17 @@ static void emitDeclaredHereIfNeeded(DiagnosticEngine &diags,
 
 bool ConformanceChecker::checkActorIsolation(
     ValueDecl *requirement, ValueDecl *witness) {
+  /// Retrieve a concrete witness for Sendable checking.
+  auto getConcreteWitness = [&] {
+    if (auto genericEnv = witness->getInnermostDeclContext()
+            ->getGenericEnvironmentOfContext()) {
+      return ConcreteDeclRef(
+          witness, genericEnv->getForwardingSubstitutionMap());
+    }
+
+    return ConcreteDeclRef(witness);
+  };
+
   // Ensure that the witness is not actor-isolated in a manner that makes it
   // unsuitable as a witness.
   bool isCrossActor = false;
@@ -3014,8 +3025,8 @@ bool ConformanceChecker::checkActorIsolation(
 
   case ActorIsolationRestriction::CrossActorSelf: {
     if (diagnoseNonSendableTypesInReference(
-        witness, DC, witness->getLoc(),
-        ConcurrentReferenceKind::CrossActor)) {
+            getConcreteWitness(), DC, witness->getLoc(),
+            ConcurrentReferenceKind::CrossActor)) {
       return true;
     }
 
@@ -3145,8 +3156,8 @@ bool ConformanceChecker::checkActorIsolation(
       return false;
 
     return diagnoseNonSendableTypesInReference(
-      witness, DC, witness->getLoc(),
-      ConcurrentReferenceKind::CrossActor);
+        getConcreteWitness(), DC, witness->getLoc(),
+        ConcurrentReferenceKind::CrossActor);
   }
 
   // If the witness has a global actor but the requirement does not, we have

test/Concurrency/concurrent_value_checking.swift

@@ -157,7 +157,7 @@ func testUnsafeSendableInAsync() async {
 // ----------------------------------------------------------------------
 // Sendable restriction on key paths.
 // ----------------------------------------------------------------------
-class NC: Hashable { // expected-note 3{{class 'NC' does not conform to the 'Sendable' protocol}}
+class NC: Hashable { // expected-note 2{{class 'NC' does not conform to the 'Sendable' protocol}}
   func hash(into: inout Hasher) { }
   static func==(_: NC, _: NC) -> Bool { true }
 }
@@ -174,9 +174,12 @@ func testKeyPaths(dict: [NC: Int], nc: NC) {
 // Sendable restriction on nonisolated declarations.
 // ----------------------------------------------------------------------
 actor ANI {
-  // FIXME: improve diagnostics to talk about nonisolated
-  nonisolated let nc = NC() // expected-warning{{cannot use property 'nc' with a non-sendable type 'NC' across actors}}
-  nonisolated func f() -> NC? { nil } // expected-warning{{cannot call function returning non-sendable type 'NC?' across actors}}
+  nonisolated let nc = NC()
+  nonisolated func f() -> NC? { nil }
+}
+
+func testANI(ani: ANI) async {
+  _ = ani.nc // expected-warning{{cannot use property 'nc' with a non-sendable type 'NC' across actors}}
 }
 
 // ----------------------------------------------------------------------

test/Concurrency/sendable_checking.swift

@@ -53,3 +53,15 @@ func testCV(
   // expected-note@-1{{a function type must be marked '@Sendable' to conform to 'Sendable'}}
   acceptSendableFn(fn) // expected-error{{passing non-sendable parameter 'fn' to function expecting a @Sendable closure}}
 }
+
+// rdar://83942484 - spurious Sendable diagnostics
+@available(SwiftStdlib 5.1, *)
+public protocol MyProto {
+    func foo<F>(aFoo: F) async where F: Sendable
+}
+
+@available(SwiftStdlib 5.1, *)
+public actor MyActor: MyProto {
+  public func foo<F>(aFoo: F) async where F: Sendable { }
+  public func bar<B>(aBar: B) async where B: Sendable { }
+}

test/Interop/Cxx/operators/member-inline-module-interface.swift

@@ -60,16 +60,17 @@
 // CHECK:   func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>
 
 // CHECK:   @available(*, unavailable, message: "use subscript")
-// CHECK:   func __operatorSubscriptConst(_ x: Bool) -> UnsafePointer<Bool>
+// CHECK:   mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<Int32>
 
 // CHECK:   @available(*, unavailable, message: "use subscript")
-// CHECK:   func __operatorSubscriptConst(_ x: Double) -> UnsafePointer<Double>
+// CHECK:   mutating func __operatorSubscript(_ x: Bool) -> UnsafeMutablePointer<Bool>
 
 // CHECK:   @available(*, unavailable, message: "use subscript")
-// CHECK:   mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<Int32>
+// CHECK:   func __operatorSubscriptConst(_ x: Bool) -> UnsafePointer<Bool>
 
 // CHECK:   @available(*, unavailable, message: "use subscript")
-// CHECK:   mutating func __operatorSubscript(_ x: Bool) -> UnsafeMutablePointer<Bool>
+// CHECK:   func __operatorSubscriptConst(_ x: Double) -> UnsafePointer<Double>
+
 // CHECK: }