Fix the Effective Access Level of package Declarations

lib/AST/Decl.cpp

@@ -4120,6 +4120,15 @@ AccessLevel ValueDecl::getEffectiveAccess() const {
   case AccessLevel::Open:
     break;
   case AccessLevel::Package:
+    if (getModuleContext()->isTestingEnabled() ||
+        getModuleContext()->arePrivateImportsEnabled()) {
+        effectiveAccess = getMaximallyOpenAccessFor(this);
+    } else {
+        // Package declarations are effectively public within their
+        // package unit.
+        effectiveAccess = AccessLevel::Public;
+    }
+    break;
   case AccessLevel::Public:
   case AccessLevel::Internal:
     if (getModuleContext()->isTestingEnabled() ||

lib/Sema/TypeCheckAttr.cpp

@@ -3740,9 +3740,11 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
                        genericParamType, protocol->getName().str());
         break;
       case UnviableReason::Inaccessible:
-        diags.diagnose(init->getLoc(), diag::type_eraser_init_not_accessible,
-                       init->getEffectiveAccess(), protocolType,
-                       protocol->getEffectiveAccess());
+        diags.diagnose(
+            init->getLoc(), diag::type_eraser_init_not_accessible,
+            init->getFormalAccessScope().requiredAccessForDiagnostics(),
+            protocolType,
+            protocol->getFormalAccessScope().requiredAccessForDiagnostics());
         break;
       case UnviableReason::SPI:
         diags.diagnose(init->getLoc(), diag::type_eraser_init_spi,

test/IRGen/Inputs/package_types/resilient_class.swift

@@ -0,0 +1,106 @@
+
+import resilient_struct
+
+
+
+// Resilient base class
+
+package class ResilientOutsideParent {
+  package var property: String = "ResilientOutsideParent.property"
+  package final var finalProperty: String = "ResilientOutsideParent.finalProperty"
+
+  package class var classProperty: String {
+    return "ResilientOutsideParent.classProperty"
+  }
+
+  package init() {
+    print("ResilientOutsideParent.init()")
+  }
+
+  package func method() {
+    print("ResilientOutsideParent.method()")
+  }
+
+  package class func classMethod() {
+    print("ResilientOutsideParent.classMethod()")
+  }
+
+  package func getValue() -> Int {
+    return 0
+  }
+}
+
+
+
+// Resilient subclass
+
+package class ResilientOutsideChild : ResilientOutsideParent {
+  package override func method() {
+    print("ResilientOutsideChild.method()")
+    super.method()
+  }
+
+  package override class func classMethod() {
+    print("ResilientOutsideChild.classMethod()")
+    super.classMethod()
+  }
+}
+
+
+// Resilient generic base class
+
+package class ResilientGenericOutsideParent<A> {
+  package var property: A
+  package init(property: A) {
+    self.property = property
+    print("ResilientGenericOutsideParent.init()")
+  }
+
+  package func method() {
+    print("ResilientGenericOutsideParent.method()")
+  }
+
+  package class func classMethod() {
+    print("ResilientGenericOutsideParent.classMethod()")
+  }
+}
+
+
+// Resilient generic subclass
+
+package class ResilientGenericOutsideChild<A> : ResilientGenericOutsideParent<A> {
+  package override init(property: A) {
+    print("ResilientGenericOutsideGenericChild.init(a: A)")
+    super.init(property: property)
+  }
+
+  package override func method() {
+    print("ResilientGenericOutsideChild.method()")
+    super.method()
+  }
+
+  package override class func classMethod() {
+    print("ResilientGenericOutsideChild.classMethod()")
+    super.classMethod()
+  }
+}
+
+
+// Resilient subclass of generic class
+
+package class ResilientConcreteOutsideChild : ResilientGenericOutsideParent<String> {
+  package override init(property: String) {
+    print("ResilientConcreteOutsideChild.init(property: String)")
+    super.init(property: property)
+  }
+
+  package override func method() {
+    print("ResilientConcreteOutsideChild.method()")
+    super.method()
+  }
+
+  package override class func classMethod() {
+    print("ResilientConcreteOutsideChild.classMethod()")
+    super.classMethod()
+  }
+}

test/IRGen/Inputs/package_types/resilient_enum.swift

@@ -0,0 +1,217 @@
+import resilient_struct
+
+// Fixed-layout enum with resilient members
+package enum SimpleShape {
+  case KleinBottle
+  case Triangle(Size)
+}
+
+// Fixed-layout enum with resilient members
+package enum Shape {
+  case Point
+  case Rect(Size)
+  case RoundedRect(Size, Size)
+}
+
+// Fixed-layout enum with indirect resilient members
+package enum FunnyShape {
+  indirect case Parallelogram(Size)
+  indirect case Trapezoid(Size)
+}
+
+package enum FullyFixedLayout {
+  case noPayload
+  case hasPayload(Int)
+}
+
+// The enum payload has fixed layout inside this module, but
+// resilient layout outside. Make sure we emit the payload
+// size in the metadata.
+
+package struct Color {
+  package let r: Int, g: Int, b: Int
+
+  package init(r: Int, g: Int, b: Int) {
+    self.r = r
+    self.g = g
+    self.b = b
+  }
+}
+
+package enum CustomColor {
+  case Black
+  case White
+  case Custom(Color)
+  case Bespoke(Color, Color)
+}
+
+// Resilient enum
+package enum Medium {
+  // Indirect case
+  indirect case Pamphlet(Medium)  // -1
+
+  // Case with resilient payload
+  case Postcard(Size)             // -2
+
+  // Empty cases
+  case Paper                      // 0
+  case Canvas                     // 1
+}
+
+// Indirect resilient enum
+package indirect enum IndirectApproach {
+  case Angle(Double)              // -1
+}
+
+// Resilient enum with resilient empty payload case
+package struct EmptyStruct {
+  package init() {}
+}
+
+package enum ResilientEnumWithEmptyCase {
+  case A                          // 0
+  case B                          // 1
+  case Empty(EmptyStruct)         // -1
+}
+
+package func getResilientEnumWithEmptyCase() -> [ResilientEnumWithEmptyCase] {
+  return [.A, .B, .Empty(EmptyStruct())]
+}
+
+// Specific enum implementations for executable tests
+package enum ResilientEmptyEnum {
+  case X
+}
+
+package enum ResilientSingletonEnum {
+  case X(AnyObject)
+}
+
+package enum ResilientSingletonGenericEnum<T> {
+  case X(T)
+}
+
+package enum ResilientNoPayloadEnum {
+  case A
+  case B
+  case C
+}
+
+package enum ResilientSinglePayloadEnum {
+  case X(AnyObject)               // -1
+  case A                          // 0
+  case B                          // 1
+  case C                          // 2
+}
+
+package enum ResilientSinglePayloadGenericEnum<T> {
+  case X(T)                       // -1
+  case A                          // 0
+  case B                          // 1
+  case C                          // 2
+}
+
+package class ArtClass {
+  package init() {}
+}
+
+package enum ResilientMultiPayloadEnum {
+  case A
+  case B
+  case C
+  case X(Int)
+  case Y(Int)
+}
+
+package func makeResilientMultiPayloadEnum(_ n: Int, i: Int)
+    -> ResilientMultiPayloadEnum {
+  switch i {
+  case 0:
+    return .A
+  case 1:
+    return .B
+  case 2:
+    return .C
+  case 3:
+    return .X(n)
+  case 4:
+    return .Y(n)
+  default:
+    while true {}
+  }
+}
+
+package enum ResilientMultiPayloadEnumSpareBits {
+  case A                          // 0
+  case B                          // 1
+  case C                          // 2
+  case X(ArtClass)                // -1
+  case Y(ArtClass)                // -2
+}
+
+package func makeResilientMultiPayloadEnumSpareBits(_ o: ArtClass, i: Int)
+    -> ResilientMultiPayloadEnumSpareBits {
+  switch i {
+  case 0:
+    return .A
+  case 1:
+    return .B
+  case 2:
+    return .C
+  case 3:
+    return .X(o)
+  case 4:
+    return .Y(o)
+  default:
+    while true {}
+  }
+}
+
+package typealias SevenSpareBits = (Bool, Int8, Int8, Int8, Int8, Int8, Int8, Int8)
+
+package enum ResilientMultiPayloadEnumSpareBitsAndExtraBits {
+  // On 64-bit little endian, 7 spare bits at the LSB end
+  case P1(SevenSpareBits)
+  // On 64-bit, 8 spare bits at the MSB end and 3 at the LSB end
+  case P2(ArtClass)
+  case P3(ArtClass)
+  case P4(ArtClass)
+  case P5(ArtClass)
+  case P6(ArtClass)
+  case P7(ArtClass)
+  case P8(ArtClass)
+}
+
+package enum ResilientMultiPayloadGenericEnum<T> {
+  case A                          // 0
+  case B                          // 1
+  case C                          // 2
+  case X(T)                       // -1
+  case Y(T)                       // -2
+}
+
+package enum ResilientMultiPayloadGenericEnumFixedSize<T> {
+  case A                          // 0
+  case B                          // 1
+  case C                          // 2
+  case X(Int)                     // -1
+  case Y(Int)                     // -2
+}
+
+package enum ResilientIndirectEnum {
+  // 0
+  case Base
+
+  // -1
+  indirect case A(ResilientIndirectEnum)
+
+  // -2
+  indirect case B(ResilientIndirectEnum, ResilientIndirectEnum)
+}
+
+package enum ResilientEnumWithUnavailableCase {
+  case available
+
+  @available(*, unavailable)
+  case unavailable
+}