Don't link-check the Optional/AnyHashable workaround

This restores the earlier behavior of Optionals cast to
AnyHashable, so that [String?:Any] dictionaries cast
to [AnyHashable:Any] can be indexed by plain String
keys.

This is a little problematic because it's not consistent with the
compiler-optimized casts.

But the ability to index such dictionaries by plain String
keys seems important to preserve.  SR-9047 will expand
Optional/AnyHashable interoperability so that such
indexing works without this special case.

An earlier proposal would link-check this, changing the behavior
depending on the caller.  But it's not really workable to
change the behavior seen by intermediate frameworks depending
on the app they're being called by.

Author: tbkka

stdlib/public/runtime/DynamicCast.cpp

@@ -712,14 +712,6 @@ struct ObjCBridgeMemo {
 };
 #endif
 
-static bool avoidOptionalsInAnyHashable() {
-  // Unexpected nulls are fatal in Swift 5.4 and not before
-  // AnyHashable avoids optionals before Swift 5.4
-  // TODO: This is admittedly awkward, but I need to get this changed quickly
-  // I'll come back and clean this up later.
-  return !unexpectedNullIsFatal();
-}
-
 static DynamicCastResult
 tryCastToAnyHashable(
   OpaqueValue *destLocation, const Metadata *destType,
@@ -747,22 +739,24 @@ tryCastToAnyHashable(
 #endif
   }
   case MetadataKind::Optional: {
-    if (avoidOptionalsInAnyHashable()) {
-      // Mimic the Swift 5.3 behavior when running in older contexts
-      // This behavior is consistent with Swift 5.3 runtime, but inconsistent
-      // with how other casting paths handle this case (which is why it's being
-      // changed in Swift 5.4).
-      // Old behavior:  "Foo" as! String? as! AnyHashable => AnyHashable("Foo")
-      // New behavior:  "Foo" as! String? as! AnyHashable => AnyHashable(Optional("Foo"))
-      auto srcInnerType = cast<EnumMetadata>(srcType)->getGenericArgs()[0];
-      unsigned sourceEnumCase = srcInnerType->vw_getEnumTagSinglePayload(
-        srcValue, /*emptyCases=*/1);
-      auto nonNil = (sourceEnumCase == 0);
-      if (nonNil) {
-        return DynamicCastResult::Failure;  // Our caller will unwrap the optional and try again
-      }
-      // If it is nil, fall through to the general case to just wrap the nil
+    // Until SR-9047 fixes the interactions between AnyHashable and Optional, we
+    // avoid directly injecting Optionals.  In particular, this allows
+    // casts from [String?:String] to [AnyHashable:Any] to work the way people
+    // expect. Otherwise, without SR-9047, the resulting dictionary can only be
+    // indexed with an explicit Optional<String>, not a plain String.
+    // After SR-9047, we can consider dropping this special case entirely.
+
+    // !!!!  This breaks compatibility with compiler-optimized casts
+    // (which just inject) and violates the Casting Spec.  It just preserves
+    // the behavior of the older casting code until we can clean things up.
+    auto srcInnerType = cast<EnumMetadata>(srcType)->getGenericArgs()[0];
+    unsigned sourceEnumCase = srcInnerType->vw_getEnumTagSinglePayload(
+      srcValue, /*emptyCases=*/1);
+    auto nonNil = (sourceEnumCase == 0);
+    if (nonNil) {
+      return DynamicCastResult::Failure;  // Our caller will unwrap the optional and try again
     }
+    // Else Optional is nil -- the general case below will inject it
     break;
   }
   default:

test/Casting/Casts.swift

@@ -887,39 +887,40 @@ CastsTests.test("NSDictionary -> Dictionary casting [SR-12025]") {
 CastsTests.test("Optional cast to AnyHashable") {
   let d: [String?: String] = ["FooKey": "FooValue", nil: "NilValue"]
   // In Swift 5.3, this cast DOES unwrap the non-nil key
-  // In Swift 5.4, the cast does NOT unwrap the non-nil key
+  // We've deliberately tried to preserve that behavior in Swift 5.4
   let d2 = d as [AnyHashable: String]
+
+  // After SR-9047, all four of the following should work:
   let d3 = d2["FooKey" as String? as AnyHashable]
-  expectNotNil(d3)
+  expectNil(d3)
   let d4 = d2["FooKey" as String?]
-  expectNotNil(d4)
-  // In Swift 5.4, AnyHashable(String?) is never equal to AnyHashable(String)
-  // This is expected to change...
+  expectNil(d4)
   let d5 = d2["FooKey"]
-  expectNil(d5)
+  expectNotNil(d5)
   let d6 = d2["FooKey" as AnyHashable]
-  expectNil(d6)
+  expectNotNil(d6)
 
-  // In both Swift 5.3 and 5.4, the nil key should be preserved and still function
+  // The nil key should be preserved and still function
   let d7 = d2[String?.none as AnyHashable]
   expectNotNil(d7)
 
-  // Direct casts via the runtime unwrap the optional in 5.3 but not 5.4.
+  // Direct casts via the runtime unwrap the optional
   let a: String = "Foo"
   let ah: AnyHashable = a
   let b: String? = a
   let bh = runtimeCast(b, to: AnyHashable.self)
-  // bh is an AnyHashable(Optional("Foo")) in Swift 5.4 but not earlier
-  // ah is an AnyHashable("Foo")
-  expectNotEqual(bh, ah)
+  expectEqual(bh, ah)
 
-  // In both Swift 5.3 and 5.4, direct casts that don't go through the runtime don't unwrap the optional
+  // Direct casts that don't go through the runtime don't unwrap the optional
+  // This is inconsistent with the runtime cast behavior above.  We should
+  // probably change the runtime behavior above to work the same as this,
+  // but that should wait until SR-9047 lands.
   let x: String = "Baz"
   let xh = x as AnyHashable
   let y: String? = x
   let yh = y as AnyHashable // Doesn't unwrap the optional
   // xh is AnyHashable("Baz")
-  // yh is AnyHashable(Optional("Baz")) in Swift 5.4 and earlier
+  // yh is AnyHashable(Optional("Baz"))
   expectNotEqual(xh, yh)
 }