[Sema] Minimum access for override method is fileprivate

lib/Sema/TypeCheckDecl.cpp

@@ -5548,11 +5548,12 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         std::min(classDecl->getFormalAccess(), overriddenAccess);
       if (requiredAccess == Accessibility::Open && decl->isFinal())
         requiredAccess = Accessibility::Public;
+      else if (requiredAccess == Accessibility::Private)
+        requiredAccess = Accessibility::FilePrivate;
 
       bool shouldDiagnose = false;
       bool shouldDiagnoseSetter = false;
-      if (requiredAccess > Accessibility::Private &&
-          !isa<ConstructorDecl>(decl)) {
+      if (!isa<ConstructorDecl>(decl)) {
         shouldDiagnose = (decl->getFormalAccess() < requiredAccess);
 
         if (!shouldDiagnose && matchDecl->isSettable(classDecl)) {
@@ -5562,6 +5563,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
             const DeclContext *accessDC = nullptr;
             if (requiredAccess == Accessibility::Internal)
               accessDC = classDecl->getParentModule();
+            else if (requiredAccess == Accessibility::FilePrivate)
+              accessDC = classDecl->getDeclContext();
             shouldDiagnoseSetter = ASD->isSettable(accessDC) &&
                                    !ASD->isSetterAccessibleFrom(accessDC);
           }
@@ -6494,11 +6497,14 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     if (CD->isRequired() && ContextTy) {
       if (auto nominal = ContextTy->getAnyNominal()) {
-        if (CD->getFormalAccess() <
-            std::min(nominal->getFormalAccess(), Accessibility::Public)) {
+        auto requiredAccess = std::min(nominal->getFormalAccess(),
+                                       Accessibility::Public);
+        if (requiredAccess == Accessibility::Private)
+          requiredAccess = Accessibility::FilePrivate;
+        if (CD->getFormalAccess() < requiredAccess) {
           auto diag = TC.diagnose(CD,
                                   diag::required_initializer_not_accessible);
-          fixItAccessibility(diag, CD, nominal->getFormalAccess());
+          fixItAccessibility(diag, CD, requiredAccess);
         }
       }
     }

test/SILGen/Inputs/mangling_private_helper.swift

@@ -5,5 +5,5 @@ open class Base {
 // Demonstrate the need for a vtable entry for privateMethod().
 // This isn't strictly necessary.
 private class Subclass : Base {
-  override private func privateMethod() {}
+  override fileprivate func privateMethod() {}
 }

test/SILOptimizer/Inputs/devirt_access_other_module.swift

@@ -14,5 +14,5 @@ public func getExternalClass() -> ExternalClass {
 }
 
 private class PrivateSubclass : ExternalClass {
-  override private func foo() {}
+  override fileprivate func foo() {}
 }

test/Sema/accessibility.swift

@@ -198,6 +198,38 @@ internal class InternalSubPrivateSet: Base {
   }
 }
 
+private class PrivateSub: Base {
+  required private init() {} // expected-error {{'required' initializer must be as accessible as its enclosing type}} {{12-19=fileprivate}}
+  private override func foo() {} // expected-error {{overriding instance method must be as accessible as its enclosing type}} {{3-10=fileprivate}}
+  private override var bar: Int { // expected-error {{overriding var must be as accessible as its enclosing type}} {{3-10=fileprivate}}
+    get { return 0 }
+    set {}
+  }
+  private override subscript () -> () { return () } // expected-error {{overriding subscript must be as accessible as its enclosing type}} {{3-10=fileprivate}}
+}
+
+private class PrivateSubGood: Base {
+  required fileprivate init() {}
+  fileprivate override func foo() {}
+  fileprivate override var bar: Int {
+    get { return 0 }
+    set {}
+  }
+  fileprivate override subscript () -> () { return () }
+}
+
+private class PrivateSubPrivateSet: Base {
+  required fileprivate init() {}
+  fileprivate override func foo() {}
+  private(set) override var bar: Int { // expected-error {{setter of overriding var must be as accessible as its enclosing type}}
+    get { return 0 }
+    set {}
+  }
+  private(set) override subscript () -> () { // okay; read-only in base class
+    get { return () }
+    set {}
+  }
+}
 
 public typealias PublicTA1 = PublicStruct
 public typealias PublicTA2 = InternalStruct // expected-error {{type alias cannot be declared public because its underlying type uses an internal type}}