Fixing invalid swiftinterface in presence of an internal protocol

Private member witnessing a public constraint should be deprecated. If StrictTextualInterfaceChecking is set, compiler emits an error when access check is not passed.

rdar://74904373

Author: sepy97

include/swift/AST/DiagnosticsSema.def

@@ -3268,6 +3268,14 @@ WARNING(warn_protocol_witness_optionality,none,
       " different optionality than expected by protocol %2",
       (unsigned, const ValueDecl *, const ProtocolDecl *))
 
+ERROR(err_private_member_witness_public_protocol,none,
+      "%0 is private and should not witness public protocol %1",
+      (const ValueDecl *,const ProtocolDecl *))
+WARNING(warn_private_member_witness_public_protocol,none,
+        "%0 is private and should not witness public protocol %1; "
+        "this is deprecated and will become an error in future versions",
+        (const ValueDecl *,const ProtocolDecl *))
+
 NOTE(protocol_witness_static_conflict,none,
      "candidate operates on %select{a type|an instance}0, not "
      "%select{an instance|a type}0 as required", (bool))

include/swift/Basic/Features.def

@@ -302,6 +302,7 @@ MIGRATABLE_UPCOMING_FEATURE(MemberImportVisibility, 444, 7)
 MIGRATABLE_UPCOMING_FEATURE(InferIsolatedConformances, 470, 7)
 MIGRATABLE_UPCOMING_FEATURE(NonisolatedNonsendingByDefault, 461, 7)
 UPCOMING_FEATURE(ImmutableWeakCaptures, 481, 7)
+UPCOMING_FEATURE(StrictTextualInterfaceChecking, 0, 7)
 
 // Optional language features / modes
 

lib/AST/FeatureSet.cpp

@@ -72,6 +72,7 @@ UNINTERESTING_FEATURE(ExistentialAny)
 UNINTERESTING_FEATURE(InferSendableFromCaptures)
 UNINTERESTING_FEATURE(ImplicitOpenExistentials)
 UNINTERESTING_FEATURE(MemberImportVisibility)
+UNINTERESTING_FEATURE(StrictTextualInterfaceChecking)
 
 // ----------------------------------------------------------------------------
 // MARK: - Experimental Features

lib/Sema/TypeCheckProtocol.cpp

@@ -1762,11 +1762,14 @@ static bool checkWitnessAccess(DeclContext *dc,
 
   auto actualScopeToCheck = requiredAccessScope.first;
 
+  // without StrictTextualInterfaceChecking feature forConformance is set true
+  bool forConformance = not dc->getASTContext().LangOpts.hasFeature
+                            (Feature::StrictTextualInterfaceChecking);
   // Setting the 'forConformance' flag means that we admit witnesses in
   // protocol extensions that we can see, but are not necessarily as
   // visible as the conforming type and protocol.
   if (!witness->isAccessibleFrom(actualScopeToCheck.getDeclContext(),
-                                 /*forConformance=*/true)) {
+                                 forConformance)) {
     // Special case: if we have `@testable import` of the witness's module,
     // allow the witness to match if it would have matched for just this file.
     // That is, if '@testable' allows us to see the witness here, it should

test/Sema/diag_internal_protocol_access_check.swift

@@ -0,0 +1,31 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-typecheck-verify-swift -enable-library-evolution -enable-upcoming-feature StrictTextualInterfaceChecking
+
+public protocol P {
+  func foo() -> Int
+}
+internal protocol Q: P {
+  func fooImpl() -> Int32
+}
+extension Q {
+  public func foo() -> Int { // expected-note {{mark the instance method as 'public' to satisfy the requirement}}
+    return Int(self.fooImpl())
+  }
+}
+public struct S: Q { // expected-error {{method 'foo()' must be declared public because it matches a requirement in public protocol 'P'}}
+  internal func fooImpl() -> Int32 {
+    return 42
+  }
+}
+
+public struct Foo {
+  public init(value: Int) {}
+}
+public protocol PublicProtocol {
+  init?(integer: Int)
+}
+protocol InternalProtocol: PublicProtocol {}
+extension InternalProtocol {
+  public init(integer: Int) {} // expected-note {{mark the initializer as 'public' to satisfy the requirement}}
+}
+extension Foo: PublicProtocol, InternalProtocol {} // expected-error {{initializer 'init(integer:)' must be declared public because it matches a requirement in public protocol 'PublicProtocol'}}