Implement SE-0117.

Author: rjmccall

include/swift/AST/Attr.h

@@ -201,9 +201,9 @@ class DeclAttribute : public AttributeBase {
     friend class AbstractAccessibilityAttr;
     unsigned : NumDeclAttrBits;
 
-    unsigned AccessLevel : 2;
+    unsigned AccessLevel : 3;
   };
-  enum { NumAccessibilityAttrBits = NumDeclAttrBits + 2 };
+  enum { NumAccessibilityAttrBits = NumDeclAttrBits + 3 };
   static_assert(NumAccessibilityAttrBits <= 32, "fits in an unsigned");
 
   class AutoClosureAttrBitFields {

include/swift/AST/AttrKind.h

@@ -55,8 +55,11 @@ enum class Accessibility : uint8_t {
   FilePrivate,
   /// Internal access is limited to the current module.
   Internal,
-  /// Public access is not limited.
-  Public
+  /// Public access is not limited, but some capabilities may be
+  /// restricted outside of the current module.
+  Public,
+  /// Open access is not limited, and all capabilities are unrestricted.
+  Open,
 };
 
 enum class InlineKind : uint8_t {

include/swift/AST/Decl.h

@@ -813,6 +813,13 @@ class alignas(1 << DeclAlignInBits) Decl {
   /// Whether this declaration is weak-imported.
   bool isWeakImported(ModuleDecl *fromModule) const;
 
+  /// Returns true if the nature of this declaration allows overrides.
+  /// Note that this does not consider whether it is final or whether
+  /// the class it's on is final.
+  ///
+  /// If this returns true, the decl can be safely casted to ValueDecl.
+  bool isPotentiallyOverridable() const;
+
   // Make vanilla new/delete illegal for Decls.
   void *operator new(size_t Bytes) = delete;
   void operator delete(void *Data) = delete;
@@ -2184,7 +2191,8 @@ class ValueDecl : public Decl {
   Accessibility getFormalAccess(const DeclContext *useDC = nullptr) const {
     assert(hasAccessibility() && "accessibility not computed yet");
     Accessibility result = TypeAndAccess.getInt().getValue();
-    if (useDC && result == Accessibility::Internal)
+    if (useDC && (result == Accessibility::Internal ||
+                  result == Accessibility::Public))
       return getFormalAccessImpl(useDC);
     return result;
   }
@@ -6138,6 +6146,16 @@ inline ArrayRef<Requirement> ExtensionDecl::getGenericRequirements() const {
   return GenericSig->getRequirements();
 }
 
+inline bool Decl::isPotentiallyOverridable() const {
+  if (isa<VarDecl>(this) ||
+      isa<SubscriptDecl>(this) ||
+      isa<FuncDecl>(this)) {
+    return getDeclContext()->getAsClassOrClassExtensionContext();
+  } else {
+    return false;
+  }
+}
+
 } // end namespace swift
 
 #endif

include/swift/AST/DiagnosticsSema.def

@@ -988,6 +988,12 @@ ERROR(access_control_extension_more,none,
       "extension of %select{private|fileprivate|internal|PUBLIC}0 %1 cannot "
       "be declared %select{PRIVATE|fileprivate|internal|public}2",
       (Accessibility, DescriptiveDeclKind, Accessibility))
+ERROR(access_control_extension_open,none,
+      "extensions cannot use 'open' as their default access; use 'public'",
+      ())
+ERROR(access_control_open_bad_decl,none,
+      "only classes and overridable class members can be declared 'open';"
+      " use 'public'", ())
 
 ERROR(invalid_decl_attribute_simple,none,
       "attribute cannot be applied to declaration", ())
@@ -1513,6 +1519,10 @@ ERROR(override_not_accessible,none,
       "%select{its enclosing type|the declaration it overrides}2",
       (bool, DescriptiveDeclKind, bool))
 
+ERROR(override_of_non_open,none,
+      "overriding non-open %0 outside of its defining module",
+      (DescriptiveDeclKind))
+
 ERROR(method_does_not_override,none,
       "method does not override any method from its superclass", ())
 ERROR(property_does_not_override,none,
@@ -1602,6 +1612,8 @@ ERROR(override_mutable_covariant_subscript,none,
       (Type, Type))
 ERROR(decl_already_final,none,
       "static declarations are already final", ())
+ERROR(open_decl_cannot_be_final,none,
+      "%0 cannot be declared both 'final' and 'open'", (DescriptiveDeclKind))
 NOTE(decl_init_here,none,
      "initial value is here", ())
 
@@ -1621,6 +1633,9 @@ ERROR(inheritance_from_non_protocol,none,
   "inheritance from non-protocol type %0", (Type))
 ERROR(superclass_not_first,none,
   "superclass %0 must appear first in the inheritance clause", (Type))
+ERROR(superclass_not_open,none,
+  "cannot inherit from non-open class %0 outside of its defining module",
+  (Type))
 ERROR(circular_class_inheritance,none,
       "circular class inheritance %0", (StringRef))
 NOTE(class_here,none,

include/swift/Serialization/ModuleFormat.h

@@ -53,7 +53,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 259; // Last change: drop explicitlyEscaping
+const uint16_t VERSION_MINOR = 260; // Last change: open
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;
@@ -291,8 +291,9 @@ enum class AccessibilityKind : uint8_t {
   FilePrivate,
   Internal,
   Public,
+  Open,
 };
-using AccessibilityKindField = BCFixed<2>;
+using AccessibilityKindField = BCFixed<3>;
 
 // These IDs must \em not be renumbered or reordered without incrementing
 // VERSION_MAJOR.

lib/AST/ASTDumper.cpp

@@ -579,6 +579,9 @@ namespace {
         case Accessibility::Public:
           OS << "public";
           break;
+        case Accessibility::Open:
+          OS << "open";
+          break;
         }
       }
 

lib/AST/ASTPrinter.cpp

@@ -1146,6 +1146,9 @@ class PrintAST : public ASTVisitor<PrintAST> {
     case Accessibility::Public:
       Printer << tok::kw_public;
       break;
+    case Accessibility::Open:
+      Printer.printKeyword("open");
+      break;
     }
     Printer << suffix << " ";
   }

lib/AST/ASTVerifier.cpp

@@ -692,7 +692,7 @@ struct ASTNodeBase {};
       if (D->hasAccessibility()) {
         PrettyStackTraceDecl debugStack("verifying access", D);
         if (D->getFormalAccessScope() == nullptr &&
-            D->getFormalAccess() != Accessibility::Public) {
+            D->getFormalAccess() < Accessibility::Public) {
           Out << "non-public decl has no formal access scope\n";
           D->dump(Out);
           abort();

lib/AST/Attr.cpp

@@ -553,7 +553,10 @@ StringRef DeclAttribute::getAttrName() const {
       return "internal";
     case Accessibility::Public:
       return "public";
+    case Accessibility::Open:
+      return "open";
     }
+    llvm_unreachable("bad accessibility kind");
 
   case DAK_Ownership:
     switch (cast<OwnershipAttr>(this)->get()) {
@@ -562,6 +565,7 @@ StringRef DeclAttribute::getAttrName() const {
     case Ownership::Unowned:   return "unowned";
     case Ownership::Unmanaged: return "unowned(unsafe)";
     }
+    llvm_unreachable("bad ownership kind");
   case DAK_RawDocComment:
     return "<<raw doc comment>>";
   case DAK_ObjCBridged:

lib/AST/Decl.cpp

@@ -1227,7 +1227,7 @@ bool AbstractStorageDecl::hasFixedLayout() const {
 
   // Private and (unversioned) internal variables always have a
   // fixed layout.
-  if (getEffectiveAccess() != Accessibility::Public)
+  if (getEffectiveAccess() < Accessibility::Public)
     return true;
 
   // Check for an explicit @_fixed_layout attribute.
@@ -1794,12 +1794,9 @@ SourceLoc ValueDecl::getAttributeInsertionLoc(bool forModifier) const {
   return resultLoc.isValid() ? resultLoc : getStartLoc();
 }
 
-/// Returns true if \p VD needs to be treated as publicly-accessible at the SIL,
-/// LLVM, and machine levels.
-///
-/// The most common causes of this are -enable-testing and versioned non-public
-/// declarations.
-static bool isInternalDeclEffectivelyPublic(const ValueDecl *VD) {
+/// Returns true if \p VD needs to be treated as publicly-accessible
+/// at the SIL, LLVM, and machine levels due to being versioned.
+static bool isVersionedInternalDecl(const ValueDecl *VD) {
   assert(VD->getFormalAccess() == Accessibility::Internal);
 
   if (VD->getAttrs().hasAttribute<VersionedAttr>())
@@ -1810,21 +1807,43 @@ static bool isInternalDeclEffectivelyPublic(const ValueDecl *VD) {
       if (ASD->getAttrs().hasAttribute<VersionedAttr>())
         return true;
 
-  if (VD->getModuleContext()->isTestingEnabled())
-    return true;
-
   return false;
 }
 
+/// Return the accessibility of an internal or public declaration
+/// that's been testably imported.
+static Accessibility getTestableAccess(const ValueDecl *decl) {
+  // Non-final classes are considered open to @testable importers.
+  if (auto cls = dyn_cast<ClassDecl>(decl)) {
+    if (!cls->isFinal())
+      return Accessibility::Open;
+
+  // Non-final overridable class members are considered open to
+  // @testable importers.
+  } else if (decl->isPotentiallyOverridable()) {
+    if (!cast<ValueDecl>(decl)->isFinal())
+      return Accessibility::Open;
+  }
+
+  // Everything else is considered public.
+  return Accessibility::Public;
+}
+
 Accessibility ValueDecl::getEffectiveAccess() const {
   Accessibility effectiveAccess = getFormalAccess();
 
   // Handle @testable.
   switch (effectiveAccess) {
   case Accessibility::Public:
+    if (getModuleContext()->isTestingEnabled())
+      effectiveAccess = getTestableAccess(this);
+    break;
+  case Accessibility::Open:
     break;
   case Accessibility::Internal:
-    if (isInternalDeclEffectivelyPublic(this))
+    if (getModuleContext()->isTestingEnabled())
+      effectiveAccess = getTestableAccess(this);
+    else if (isVersionedInternalDecl(this))
       effectiveAccess = Accessibility::Public;
     break;
   case Accessibility::FilePrivate:
@@ -1856,13 +1875,14 @@ Accessibility ValueDecl::getEffectiveAccess() const {
 }
 
 Accessibility ValueDecl::getFormalAccessImpl(const DeclContext *useDC) const {
-  assert(getFormalAccess() == Accessibility::Internal &&
+  assert((getFormalAccess() == Accessibility::Internal ||
+          getFormalAccess() == Accessibility::Public) &&
          "should be able to fast-path non-internal cases");
   assert(useDC && "should fast-path non-scoped cases");
   if (auto *useSF = dyn_cast<SourceFile>(useDC->getModuleScopeContext()))
     if (useSF->hasTestableImport(getModuleContext()))
-      return Accessibility::Public;
-  return Accessibility::Internal;
+      return getTestableAccess(this);
+  return getFormalAccess();
 }
 
 const DeclContext *
@@ -1908,6 +1928,7 @@ ValueDecl::getFormalAccessScope(const DeclContext *useDC) const {
   case Accessibility::Internal:
     return result->getParentModule();
   case Accessibility::Public:
+  case Accessibility::Open:
     return nullptr;
   }
 
@@ -1947,7 +1968,7 @@ Type TypeDecl::getDeclaredInterfaceType() const {
 bool NominalTypeDecl::hasFixedLayout() const {
   // Private and (unversioned) internal types always have a
   // fixed layout.
-  if (getEffectiveAccess() != Accessibility::Public)
+  if (getEffectiveAccess() < Accessibility::Public)
     return true;
 
   // Check for an explicit @_fixed_layout attribute.