Merge pull request #2743 from swiftwasm/release/5.4

[pull] swiftwasm-release/5.4 from release/5.4

Author: pull[bot]

lib/AST/GenericSignatureBuilder.cpp

@@ -1833,6 +1833,13 @@ static void lookupConcreteNestedType(NominalTypeDecl *decl,
     concreteDecls.push_back(cast<TypeDecl>(member));
 }
 
+static auto findBestConcreteNestedType(SmallVectorImpl<TypeDecl *> &concreteDecls) {
+  return std::min_element(concreteDecls.begin(), concreteDecls.end(),
+                          [](TypeDecl *type1, TypeDecl *type2) {
+                            return TypeDecl::compare(type1, type2) < 0;
+                          });
+}
+
 TypeDecl *EquivalenceClass::lookupNestedType(
                              GenericSignatureBuilder &builder,
                              Identifier name,
@@ -1940,11 +1947,7 @@ TypeDecl *EquivalenceClass::lookupNestedType(
            "Lookup should never keep a non-anchor associated type");
   } else if (!concreteDecls.empty()) {
     // Find the best concrete type.
-    auto bestConcreteTypeIter =
-      std::min_element(concreteDecls.begin(), concreteDecls.end(),
-                       [](TypeDecl *type1, TypeDecl *type2) {
-                         return TypeDecl::compare(type1, type2) < 0;
-                       });
+    auto bestConcreteTypeIter = findBestConcreteNestedType(concreteDecls);
 
     // Put the best concrete type first; the rest will follow.
     entry.types.push_back(*bestConcreteTypeIter);
@@ -3559,7 +3562,8 @@ static Type getStructuralType(TypeDecl *typeDecl, bool keepSugar) {
 
 static Type substituteConcreteType(Type parentType,
                                    TypeDecl *concreteDecl) {
-  if (parentType->is<ErrorType>())
+  if (parentType->is<ErrorType>() ||
+      parentType->is<UnresolvedType>())
     return parentType;
 
   auto *dc = concreteDecl->getDeclContext();
@@ -3612,18 +3616,14 @@ ResolvedType GenericSignatureBuilder::maybeResolveEquivalenceClass(
           if (concreteDecls.empty())
             return ResolvedType::forUnresolved(nullptr);
 
-          auto bestConcreteTypeIter =
-            std::min_element(concreteDecls.begin(), concreteDecls.end(),
-                             [](TypeDecl *type1, TypeDecl *type2) {
-                               return TypeDecl::compare(type1, type2) < 0;
-                             });
-
+          auto bestConcreteTypeIter = findBestConcreteNestedType(concreteDecls);
           concreteDecl = *bestConcreteTypeIter;
         }
       }
 
       auto concreteType = substituteConcreteType(parentType, concreteDecl);
-      return ResolvedType::forConcrete(concreteType);
+      return maybeResolveEquivalenceClass(concreteType, resolutionKind,
+                                          wantExactPotentialArchetype);
     }
 
     // Find the nested type declaration for this.

lib/SILOptimizer/Analysis/SimplifyInstruction.cpp

@@ -348,8 +348,13 @@ static SILValue simplifyDeadCast(SingleValueInstruction *Cast) {
   for (Operand *op : Cast->getUses()) {
     switch (op->getUser()->getKind()) {
       case SILInstructionKind::DestroyValueInst:
+        break;
       case SILInstructionKind::StrongReleaseInst:
       case SILInstructionKind::StrongRetainInst:
+        // ref-casts can cast from an Optional<Classtype>. But strong_retain/
+        // strong_release don't accept an optional.
+        if (!Cast->getOperand(0)->getType().isReferenceCounted(Cast->getModule()))
+          return SILValue();
         break;
       default:
         return SILValue();

stdlib/public/core/KeyPath.swift

@@ -1932,6 +1932,11 @@ func _modifyAtWritableKeyPath_impl<Root, Value>(
   root: inout Root,
   keyPath: WritableKeyPath<Root, Value>
 ) -> (UnsafeMutablePointer<Value>, AnyObject?) {
+  if type(of: keyPath).kind == .reference {
+    return _modifyAtReferenceWritableKeyPath_impl(root: root,
+      keyPath: _unsafeUncheckedDowncast(keyPath,
+        to: ReferenceWritableKeyPath<Root, Value>.self))
+  }
   return keyPath._projectMutableAddress(from: &root)
 }
 

test/SILOptimizer/sil_combine.sil

@@ -836,6 +836,20 @@ bb0(%0 : $C1):
   return %0 : $C1
 }
 
+// strong_retain/strong_release don't accept an Optional<reference>.
+//
+// CHECK-LABEL: sil @dontOptimizeRefCastOfOptional
+// CHECK:   %1 = unchecked_ref_cast %0
+// CHECK:   strong_retain %1
+// CHECK: } // end sil function 'dontOptimizeRefCastOfOptional'
+sil @dontOptimizeRefCastOfOptional : $@convention(thin) (@guaranteed Optional<C1>) -> () {
+bb0(%0 : $Optional<C1>):
+  %1 = unchecked_ref_cast %0 : $Optional<C1> to $C1
+  strong_retain %1 : $C1
+  %3 = tuple ()
+  return %3 : $()
+}
+
 // CHECK-LABEL: sil @dead_end_cow_mutation
 // CHECK: bb0
 // CHECK-NEXT: strong_retain %0

test/stdlib/KeyPath.swift

@@ -1043,6 +1043,16 @@ keyPath.test("ReferenceWritableKeyPath statically typed as WritableKeyPath") {
   expectEqual(outer[keyPath: upcastKeyPath], 43)
   outer[keyPath: upcastKeyPath] = 44
   expectEqual(outer[keyPath: upcastKeyPath], 44)
+
+  func setWithInout<T>(_ lhs: inout T, _ rhs: T) { lhs = rhs }
+
+  expectEqual(outer[keyPath: keyPath], 44)
+  setWithInout(&outer[keyPath: keyPath], 45);
+  expectEqual(outer[keyPath: keyPath], 45)
+
+  expectEqual(outer[keyPath: upcastKeyPath], 45)
+  setWithInout(&outer[keyPath: upcastKeyPath], 46)
+  expectEqual(outer[keyPath: upcastKeyPath], 46)
 }
 
 runAllTests()

validation-test/compiler_crashers_2_fixed/sr11639.swift

@@ -0,0 +1,15 @@
+// RUN: %target-swift-frontend -emit-ir -primary-file %s
+
+public protocol FooProtocol {
+  associatedtype Bar
+}
+
+public struct Foo<Bar>: FooProtocol {
+  public var bar: Bar
+}
+
+public protocol BazProtocol: FooProtocol {
+  associatedtype Foo1: FooProtocol where Foo1.Bar == Foo2.Bar
+  associatedtype Foo2Bar
+  typealias Foo2 = Foo<Foo2Bar>
+}