Allow code to shadow definitions in the Foundation module

include/swift/Basic/Features.def

@@ -161,6 +161,9 @@ EXPERIMENTAL_FEATURE(BuiltinMacros, false)
 /// declare an attribute which is discoverable and constructable at runtime.
 EXPERIMENTAL_FEATURE(RuntimeDiscoverableAttrs, false)
 
+/// Whether to allow types from Foundation to be implicitly shadowed
+EXPERIMENTAL_FEATURE(ShadowFoundation, false)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3156,6 +3156,10 @@ static bool usesFeatureBuiltinMacros(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureShadowFoundation(Decl *decl) {
+  return false;
+}
+
 static void
 suppressingFeatureNoAsyncAvailability(PrintOptions &options,
                                       llvm::function_ref<void()> action) {

lib/AST/NameLookup.cpp

@@ -660,37 +660,56 @@ static void recordShadowedDeclsAfterTypeMatch(
         }
       }
 
-      // The Foundation overlay introduced Data.withUnsafeBytes, which is
-      // treated as being ambiguous with SwiftNIO's Data.withUnsafeBytes
-      // extension. Apply a special-case name shadowing rule to use the
-      // latter rather than the former, which be the consequence of a more
-      // significant change to name shadowing in the future.
-      if (auto owningStruct1
-            = firstDecl->getDeclContext()->getSelfStructDecl()) {
-        if (auto owningStruct2
-              = secondDecl->getDeclContext()->getSelfStructDecl()) {
-          if (owningStruct1 == owningStruct2 &&
-              owningStruct1->getName().is("Data") &&
-              isa<FuncDecl>(firstDecl) && isa<FuncDecl>(secondDecl) &&
-              firstDecl->getName() == secondDecl->getName() &&
-              firstDecl->getBaseName().userFacingName() == "withUnsafeBytes") {
-            // If the second module is the Foundation module and the first
-            // is the NIOFoundationCompat module, the second is shadowed by the
-            // first.
-            if (firstDecl->getModuleContext()->getName()
-                  .is("NIOFoundationCompat") &&
-                secondDecl->getModuleContext()->getName().is("Foundation")) {
+      if (ctx.LangOpts.hasFeature(Feature::ShadowFoundation)) {
+        // If `ShadowFoundation` is enabled, allow all types from Foundation
+        // to be implicitly shadowed.
+        if (auto foundationModule = ctx.getLoadedModule(ctx.Id_Foundation)) {
+          if ((firstModule == foundationModule) !=
+              (secondModule == foundationModule)) {
+            // If second module is Foundation, then it is shadowed by first
+            if (secondModule == foundationModule) {
               shadowed.insert(secondDecl);
               continue;
             }
 
-            // If it's the other way around, the first declaration is shadowed
-            // by the second.
-            if (secondDecl->getModuleContext()->getName()
-                  .is("NIOFoundationCompat") &&
-                firstDecl->getModuleContext()->getName().is("Foundation")) {
-              shadowed.insert(firstDecl);
-              break;
+            // Otherwise, the first declaration is shadowed by the second.
+            shadowed.insert(firstDecl);
+            break;
+          }
+        }
+      } else {
+        // The Foundation overlay introduced Data.withUnsafeBytes, which is
+        // treated as being ambiguous with SwiftNIO's Data.withUnsafeBytes
+        // extension. Apply a special-case name shadowing rule to use the
+        // latter rather than the former, which be the consequence of a more
+        // significant change to name shadowing in the future.
+        if (auto owningStruct1
+              = firstDecl->getDeclContext()->getSelfStructDecl()) {
+          if (auto owningStruct2
+                = secondDecl->getDeclContext()->getSelfStructDecl()) {
+            if (owningStruct1 == owningStruct2 &&
+                owningStruct1->getName().is("Data") &&
+                isa<FuncDecl>(firstDecl) && isa<FuncDecl>(secondDecl) &&
+                firstDecl->getName() == secondDecl->getName() &&
+                firstDecl->getBaseName().userFacingName() == "withUnsafeBytes") {
+              // If the second module is the Foundation module and the first
+              // is the NIOFoundationCompat module, the second is shadowed by the
+              // first.
+              if (firstDecl->getModuleContext()->getName()
+                    .is("NIOFoundationCompat") &&
+                  secondDecl->getModuleContext()->getName().is("Foundation")) {
+                shadowed.insert(secondDecl);
+                continue;
+              }
+
+              // If it's the other way around, the first declaration is shadowed
+              // by the second.
+              if (secondDecl->getModuleContext()->getName()
+                    .is("NIOFoundationCompat") &&
+                  firstDecl->getModuleContext()->getName().is("Foundation")) {
+                shadowed.insert(firstDecl);
+                break;
+              }
             }
           }
         }

test/Constraints/Inputs/FakeFoundation.h

@@ -0,0 +1 @@
+#import <Foundation/Foundation.h>

test/Constraints/Inputs/FakeFoundation.swift

@@ -0,0 +1 @@
+// empty

test/Constraints/Inputs/imported_type.h

@@ -1,4 +1,4 @@
-#import <Foundation/Foundation.h>
+#import "FakeFoundation.h"
 
 @interface Data
 @end

test/Constraints/invalid_decl_ref.swift

@@ -1,8 +1,9 @@
-// RUN: %target-swift-frontend -module-name SomeModule -typecheck -verify -dump-ast -import-objc-header %S/Inputs/imported_type.h %s | %FileCheck %s
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -emit-module-path %t/FakeFoundation.swiftmodule -module-name FakeFoundation %S/Inputs/FakeFoundation.swift -import-objc-header %S/Inputs/FakeFoundation.h -disable-availability-checking
 
 // REQUIRES: objc_interop
 
-import Foundation
+import FakeFoundation
 
 // CHECK: declref_expr type='module<SomeModule>'
 // CHECK-NEXT: type_expr type='Data.Type'

test/Frontend/Inputs/ShadowFoundation.swift

@@ -0,0 +1,3 @@
+public struct UUID {
+    public let uuidString = "FakeUUID"
+}

test/Frontend/foundation-module-shadowing.swift

@@ -0,0 +1,13 @@
+// REQUIRES: objc_interop
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -emit-module-path %t/ShadowFoundation.swiftmodule -module-name ShadowFoundation %S/Inputs/ShadowFoundation.swift -disable-availability-checking
+// RUN: %target-typecheck-verify-swift -I %t -disable-availability-checking -enable-experimental-feature ShadowFoundation
+
+import Foundation
+import ShadowFoundation
+
+func f(_ uuid: UUID) -> Bool {
+    return uuid.uuidString == "FakeUUID"
+}
+
+func g(_ uuid: Foundation.UUID) { }