Merge pull request #38884 from LucianoPAlmeida/SR-15038-array-element

[SR-15038][Sema] Use locator to propagate information of array, set, dictonary element on check cast constraint

Author: LucianoPAlmeida

lib/Sema/CSSimplify.cpp

@@ -6600,7 +6600,8 @@ static ConstraintFix *maybeWarnAboutExtraneousCast(
     SmallVector<Type, 4> toOptionals, ConstraintSystem::TypeMatchOptions flags,
     ConstraintLocatorBuilder locator) {
 
-  if (flags.contains(ConstraintSystem::TypeMatchFlags::TMF_ApplyingFix))
+  auto last = locator.last();
+  if (last && last->is<LocatorPathElt::GenericArgument>())
     return nullptr;
 
   // Both types have to be fixed.
@@ -6777,9 +6778,11 @@ ConstraintSystem::simplifyCheckedCastConstraint(
   case CheckedCastKind::ArrayDowncast: {
     auto fromBaseType = *isArrayType(fromType);
     auto toBaseType = *isArrayType(toType);
-
-    auto result = simplifyCheckedCastConstraint(
-        fromBaseType, toBaseType, subflags | TMF_ApplyingFix, locator);
+    
+    auto elementLocator =
+        locator.withPathElement(LocatorPathElt::GenericArgument(0));
+    auto result = simplifyCheckedCastConstraint(fromBaseType, toBaseType,
+                                                subflags, elementLocator);
     attemptRecordCastFixIfSolved(result);
     return result;
   }
@@ -6791,22 +6794,28 @@ ConstraintSystem::simplifyCheckedCastConstraint(
     Type toKeyType, toValueType;
     std::tie(toKeyType, toValueType) = *isDictionaryType(toType);
 
-    if (simplifyCheckedCastConstraint(fromKeyType, toKeyType,
-                                      subflags | TMF_ApplyingFix,
-                                      locator) == SolutionKind::Error)
+    auto keyLocator =
+        locator.withPathElement(LocatorPathElt::GenericArgument(0));
+    if (simplifyCheckedCastConstraint(fromKeyType, toKeyType, subflags,
+                                      keyLocator) == SolutionKind::Error)
       return SolutionKind::Error;
 
-    auto result = simplifyCheckedCastConstraint(
-        fromValueType, toValueType, subflags | TMF_ApplyingFix, locator);
+    auto valueLocator =
+        locator.withPathElement(LocatorPathElt::GenericArgument(1));
+    auto result = simplifyCheckedCastConstraint(fromValueType, toValueType,
+                                                subflags, valueLocator);
     attemptRecordCastFixIfSolved(result);
     return result;
   }
 
   case CheckedCastKind::SetDowncast: {
     auto fromBaseType = *isSetType(fromType);
     auto toBaseType = *isSetType(toType);
-    auto result = simplifyCheckedCastConstraint(
-        fromBaseType, toBaseType, subflags | TMF_ApplyingFix, locator);
+    
+    auto elementLocator =
+        locator.withPathElement(LocatorPathElt::GenericArgument(0));
+    auto result = simplifyCheckedCastConstraint(fromBaseType, toBaseType,
+                                                subflags, elementLocator);
     attemptRecordCastFixIfSolved(result);
     return result;
   }

test/Constraints/casts.swift

@@ -549,3 +549,67 @@ extension ChangeType where T == String? {
   var foo: String? { return self.delta?.previous as? String } // OK
   var bar: String? { self.delta?.next }
 }
+
+// SR-15038
+protocol ExperimentDeserializable {
+  static func deserializeExperiment(_ value: Any) -> Self?
+}
+
+extension String: ExperimentDeserializable {
+  static func deserializeExperiment(_ value: Any) -> String? { value as? String }
+}
+
+extension Int: ExperimentDeserializable {
+  static func deserializeExperiment(_ value: Any) -> Int? { value as? Int }
+}
+
+class Constant<T> {
+  private init(getUnderlyingValue: @escaping () -> T) {
+    print(getUnderlyingValue())
+  }
+}
+
+struct Thing {
+  let storage: [String: Any]
+}
+
+extension Constant where T: Sequence, T.Element: ExperimentDeserializable {
+  static func foo<U>(thing: Thing, defaultValue: T) -> T where T == [U] {
+    guard let array = thing.storage["foo"] as? [Any] else {
+      fatalError()
+    }
+
+    let value = array.map(T.Element.deserializeExperiment) as? [T.Element] ?? defaultValue // OK
+    return value
+  }
+}
+
+// Array
+func decodeStringOrInt<T: FixedWidthInteger>() -> [T] {
+  let stringWrapped = [String]()
+  if let values = stringWrapped.map({ $0.isEmpty ? 0 : T($0) }) as? [T] { // OK
+    return values
+  } else {
+    fatalError()
+  }
+}
+
+// Set 
+func decodeStringOrIntSet<T: FixedWidthInteger>() -> Set<T> {
+  let stringWrapped = [String]()
+  if let values = Set(stringWrapped.map({ $0.isEmpty ? 0 : T($0) })) as? Set<T> { // OK
+    return values
+  } else {
+    fatalError()
+  }
+}
+
+// Dictionary
+func decodeStringOrIntDictionary<T: FixedWidthInteger>() -> [Int: T] {
+  let stringWrapped = [String]()
+  if let values = Dictionary(uniqueKeysWithValues: stringWrapped.map({ $0.isEmpty ? (0, 0) : (0, T($0)) })) as? [Int: T] { // OK
+    return values
+  } else {
+    fatalError()
+  }
+}