Compatibility for Optional -> AnyHashable casts

As part of making casting more consistent, the behavior of Optional -> AnyHashable casts
was changed in some cases.  This PR provides a hook for re-enabling the old behavior
in certain contexts.

Background: Most of the time, casts from String? to AnyHashable get optimized
to just injects the String? into the AnyHashable, so the following
has long been true and remains true in Swift 5.4:
```
let s = "abc"
let o: String? = s

// Next test is true because s is promoted to Optional<String>
print(s == o)

// Next test is false: Optional<String> and String are different types
print(s as AnyHashable == o as AnyHashable)
```

But when casts ended up going through the runtime, Swift 5.3 behaved
differently, as you could see by casting a dictionary with `String?` keys (in
the generic array code, key and value casts always use the runtime logic).  In
the following code, both print statements behave differently in Swift 5.4 than
before:
```
let a: [String?:String] = ["Foo":"Bar"]
let b = a as [AnyHashable:Any]
print(b["Foo"] == "Bar")  // Works before Swift 5.4
print(b["Foo" as String?] == "Bar") // Works in Swift 5.4 and later
```

Old behavior: The `String?` keys would get unwrapped to `String` before being injected into AnyHashable.  This allows the first to work but strangely breaks the second.

New behavior: The `String?` keys do not get unwrapped.  This breaks the first but makes the second work.

TODO: The long-term goal, of course, is for `AnyHashable("Foo" as String?)` to
test equal to `AnyHashable("Foo")` (and hash the same, of course).  In that
case, all of the tests above will succeed.

Resolves rdar://73301155

Author: tbkka

stdlib/public/runtime/DynamicCast.cpp

@@ -712,6 +712,14 @@ 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,
@@ -731,26 +739,47 @@ tryCastToAnyHashable(
     // TODO: Implement a fast path for NSString->AnyHashable casts.
     // These are incredibly common because an NSDictionary with
     // NSString keys is bridged by default to [AnyHashable:Any].
-    // Until this is implemented, fall through to the default case
-    SWIFT_FALLTHROUGH;
+    // Until this is implemented, fall through to the general case
+    break;
 #else
-    // If no Obj-C interop, just fall through to the default case.
-    SWIFT_FALLTHROUGH;
+    // If no Obj-C interop, just fall through to the general case.
+    break;
 #endif
   }
-  default: {
-    auto hashableConformance = reinterpret_cast<const HashableWitnessTable *>(
-      swift_conformsToProtocol(srcType, &HashableProtocolDescriptor));
-    if (hashableConformance) {
-      _swift_convertToAnyHashableIndirect(srcValue, destLocation,
-                                          srcType, hashableConformance);
-      return DynamicCastResult::SuccessViaCopy;
-    } else {
-      return DynamicCastResult::Failure;
+  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 DynamicCast::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
     }
+    break;
   }
+  default:
+    break;
+  }
+
+
+  // General case: If it conforms to Hashable, we cast it
+  auto hashableConformance = reinterpret_cast<const HashableWitnessTable *>(
+    swift_conformsToProtocol(srcType, &HashableProtocolDescriptor));
+  if (hashableConformance) {
+    _swift_convertToAnyHashableIndirect(srcValue, destLocation,
+                                        srcType, hashableConformance);
+    return DynamicCastResult::SuccessViaCopy;
+  } else {
+    return DynamicCastResult::Failure;
   }
-  return DynamicCastResult::Failure;
 }
 
 static DynamicCastResult

test/Casting/Casts.swift

@@ -881,4 +881,46 @@ CastsTests.test("NSDictionary -> Dictionary casting [SR-12025]") {
 }
 #endif
 
+// Casting optionals to AnyHashable is a little peculiar
+// TODO: It would be nice if AnyHashable(Optional("Foo")) == AnyHashable("Foo")
+// (including as dictionary keys).  That would make this a lot less confusing.
+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
+  let d2 = d as [AnyHashable: String]
+  let d3 = d2["FooKey" as String? as AnyHashable]
+  expectNotNil(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...
+  let d5 = d2["FooKey"]
+  expectNil(d5)
+  let d6 = d2["FooKey" as AnyHashable]
+  expectNil(d6)
+
+  // In both Swift 5.3 and 5.4, the nil key should be preserved and still function
+  let d7 = d2[nil]
+  expectNotNil(d7)
+
+  // Direct casts via the runtime unwrap the optional in 5.3 but not 5.4.
+  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)
+
+  // In both Swift 5.3 and 5.4, direct casts that don't go through the runtime don't unwrap the optional
+  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
+  expectNotEqual(xh, yh)
+}
+
 runAllTests()