Merge pull request #2629 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

.clang-format

@@ -1,2 +1,2 @@
 BasedOnStyle: LLVM
-AlwaysBreakTemplateDeclarations: Yes
+AlwaysBreakTemplateDeclarations: Yes

include/swift/AST/DiagnosticsSema.def

@@ -783,6 +783,10 @@ ERROR(reserved_member_name,none,
       "type member must not be named %0, since it would conflict with the"
       " 'foo.%1' expression", (DeclName, StringRef))
 
+NOTE(invalid_redecl_by_optionality_note,none,
+      "%select{implicitly unwrapped |}0optional parameter is of "
+      "same type as %select{implicitly unwrapped |}1optional parameter",
+      (bool, bool))
 ERROR(invalid_redecl,none,"invalid redeclaration of %0", (DeclName))
 ERROR(invalid_redecl_init,none,
       "invalid redeclaration of synthesized %select{|memberwise }1%0",

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -646,6 +646,66 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
           continue;
       }
 
+      // Signatures are the same, but interface types are not. We must
+      // have a type that we've massaged as part of signature
+      // interface type generation.
+      if (current->getInterfaceType()->isEqual(other->getInterfaceType())) {
+        if (currentDC->isTypeContext() == other->getDeclContext()->isTypeContext()) {
+          auto currFnTy = current->getInterfaceType()->getAs<AnyFunctionType>();
+          auto otherFnTy = other->getInterfaceType()->getAs<AnyFunctionType>();
+          if (currFnTy && otherFnTy && currentDC->isTypeContext()) {
+            currFnTy = currFnTy->getResult()->getAs<AnyFunctionType>();
+            otherFnTy = otherFnTy->getResult()->getAs<AnyFunctionType>();
+          }
+          
+          if (currFnTy && otherFnTy) {
+            ArrayRef<AnyFunctionType::Param> currParams = currFnTy->getParams();
+            ArrayRef<AnyFunctionType::Param> otherParams = otherFnTy->getParams();
+            
+            if (currParams.size() == otherParams.size()) {
+              auto diagnosed = false;
+              for (unsigned i : indices(currParams)) {
+                  
+                bool currIsIUO = false;
+                bool otherIsIUO = false;
+                bool optionalRedecl = false;
+                
+                if (currParams[i].getPlainType()->getOptionalObjectType()) {
+                  optionalRedecl = true;
+                  if (swift::getParameterAt(current, i)->isImplicitlyUnwrappedOptional())
+                    currIsIUO = true;
+                }
+                
+                if (otherParams[i].getPlainType()->getOptionalObjectType()) {
+                  if (swift::getParameterAt(other, i)->isImplicitlyUnwrappedOptional())
+                    otherIsIUO = true;
+                }
+                else {
+                  optionalRedecl = false;
+                }
+                
+                if (optionalRedecl && currIsIUO != otherIsIUO) {
+                  ctx.Diags.diagnoseWithNotes(
+                    current->diagnose(diag::invalid_redecl,
+                                      current->getName()), [&]() {
+                    other->diagnose(diag::invalid_redecl_prev, other->getName());
+                  });
+                  current->diagnose(diag::invalid_redecl_by_optionality_note,
+                                    otherIsIUO, currIsIUO);
+                  
+                  current->setInvalid();
+                  diagnosed = true;
+                  break;
+                }
+              }
+
+              if (diagnosed)
+                break;
+            }
+          }
+        }
+      }
+
       // If the conflicting declarations have non-overlapping availability and,
       // we allow the redeclaration to proceed if...
       //

stdlib/public/runtime/DynamicCast.cpp

@@ -731,26 +731,49 @@ 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: {
+    // 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:
+    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

stdlib/tools/swift-reflection-test/swift-reflection-test.c

@@ -310,7 +310,7 @@ makeLocalSection(const void *Buffer,
   }
 
   swift_reflection_section_t LS = {(void *)Buffer,
-                                   (void *)(Buffer + Section.Size)};
+                                   (void *)((uint8_t *)Buffer + Section.Size)};
   return LS;
 }
 

test/Casting/Casts.swift

@@ -881,4 +881,47 @@ 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
+  // 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]
+  expectNil(d3)
+  let d4 = d2["FooKey" as String?]
+  expectNil(d4)
+  let d5 = d2["FooKey"]
+  expectNotNil(d5)
+  let d6 = d2["FooKey" as AnyHashable]
+  expectNotNil(d6)
+
+  // 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
+  let a: String = "Foo"
+  let ah: AnyHashable = a
+  let b: String? = a
+  let bh = runtimeCast(b, to: AnyHashable.self)
+  expectEqual(bh, ah)
+
+  // 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"))
+  expectNotEqual(xh, yh)
+}
+
 runAllTests()

test/IDE/complete_async_context.swift

@@ -1,5 +1,7 @@
 // RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t -enable-experimental-concurrency
 
+// REQUIRES: concurrency
+
 func funcThrows() throws {
     fatalError()
 }

test/IDE/complete_asyncannotation.swift

@@ -1,5 +1,7 @@
 // RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t -enable-experimental-concurrency
 
+// REQUIRES: concurrency
+
 func globalFuncAsync() async {}
 func globalFuncAsyncThrows() async throws {}
 func globalFuncAsyncRethrows(_ x: () async throws -> ()) async rethrows {}

test/IDE/complete_concurrency_keyword.swift

@@ -1,5 +1,7 @@
 // RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t -enable-experimental-concurrency
 
+// REQUIRES: concurrency
+
 // CHECK_DECL: NOT
 
 #^GLOBAL^#

test/IDE/complete_concurrency_specifier.swift

@@ -1,5 +1,7 @@
 // RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t -enable-experimental-concurrency
 
+// REQUIRES: concurrency
+
 // SPECIFIER: Begin completions
 // SPECIFIER-DAG: Keyword/None:                       async; name=async
 // SPECIFIER-DAG: Keyword[throws]/None:               throws; name=throws