Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

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/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/Interop/Cxx/value-witness-table/witness-layout-opts-irgen.swift

@@ -7,6 +7,9 @@
 // to test them in the same file.
 // XFAIL: OS=windows-msvc
 
+// Failing on 32-bit simulator, disable for now. rdar://73829982
+// REQUIRES: rdar73829982
+
 import WitnessLayoutOpts
 
 protocol Dummy { }

test/Sema/diag_erroneous_iuo.swift

@@ -211,6 +211,7 @@ func overloadedByOptionality(_ a: inout Int!) {}
 // expected-note@-1 {{'overloadedByOptionality' previously declared here}}
 func overloadedByOptionality(_ a: inout Int?) {}
 // expected-error@-1 {{invalid redeclaration of 'overloadedByOptionality'}}
+// expected-note@-2 {{optional parameter is of same type as implicitly unwrapped optional parameter}}
 
 struct T {
   let i: Int!

test/decl/overload.swift

@@ -379,17 +379,25 @@ func inout2(x: inout Int) { }
 
 // optionals
 func optional(x: Int?) { } // expected-note{{previously declared}}
-func optional(x: Int!) { } // expected-error{{invalid redeclaration of 'optional(x:)'}}
+func optional(x: Int!) { } 
+// expected-error@-1{{invalid redeclaration of 'optional(x:)'}}
+// expected-note@-2 {{implicitly unwrapped optional parameter is of same type as optional parameter}}
 
 func optionalInOut(x: inout Int?) { } // expected-note{{previously declared}}
-func optionalInOut(x: inout Int!) { } // expected-error{{invalid redeclaration of 'optionalInOut(x:)}}
+func optionalInOut(x: inout Int!) { } 
+// expected-error@-1{{invalid redeclaration of 'optionalInOut(x:)'}}
+// expected-note@-2 {{implicitly unwrapped optional parameter is of same type as optional parameter}}
 
 class optionalOverloads {
   class func optionalInOut(x: inout Int?) { } // expected-note{{previously declared}}
-  class func optionalInOut(x: inout Int!) { } // expected-error{{invalid redeclaration of 'optionalInOut(x:)'}}
+  class func optionalInOut(x: inout Int!) { } 
+  // expected-error@-1{{invalid redeclaration of 'optionalInOut(x:)'}}
+  // expected-note@-2 {{implicitly unwrapped optional parameter is of same type as optional parameter}}
 
   func optionalInOut(x: inout Int?) { } // expected-note{{previously declared}}
-  func optionalInOut(x: inout Int!) { } // expected-error{{invalid redeclaration of 'optionalInOut(x:)}}
+  func optionalInOut(x: inout Int!) { } 
+  // expected-error@-1{{invalid redeclaration of 'optionalInOut(x:)'}}
+  // expected-note@-2 {{implicitly unwrapped optional parameter is of same type as optional parameter}}
 }
 
 func optional_3() -> Int? { } // expected-note{{previously declared}}