Sema: Fix bug where enum cases could not be referenced from inlineable context

Enum cases do not have their own accessibility or @_versioned
attribute, and we already diagnose invalid references to the
enum type itself.

Author: slavapestov

lib/Sema/ResilienceDiagnostics.cpp

@@ -77,27 +77,42 @@ bool TypeChecker::diagnoseInlineableDeclRef(SourceLoc loc,
                                             const ValueDecl *D,
                                             const DeclContext *DC) {
   auto expansion = DC->getResilienceExpansion();
-  if (expansion == ResilienceExpansion::Minimal) {
-    if (!isa<GenericTypeParamDecl>(D) &&
-        // Protocol requirements are not versioned because there's no
-        // global entry point
-        !(isa<ProtocolDecl>(D->getDeclContext()) && isRequirement(D)) &&
-        // FIXME: Figure out what to do with typealiases
-        !isa<TypeAliasDecl>(D) &&
-        !D->getDeclContext()->isLocalContext() &&
-        D->hasAccessibility()) {
-      if (D->getEffectiveAccess() < Accessibility::Public) {
-        diagnose(loc, diag::resilience_decl_unavailable,
-                 D->getDescriptiveKind(), D->getFullName(),
-                 D->getFormalAccess(), getFragileFunctionKind(DC));
-        diagnose(D, diag::resilience_decl_declared_here,
-                 D->getDescriptiveKind(), D->getFullName());
-        return true;
-      }
-    }
-  }
 
-  return false;
+  // Internal declarations referenced from non-inlineable contexts are OK.
+  if (expansion == ResilienceExpansion::Maximal)
+    return false;
+
+  // Local declarations are OK.
+  if (D->getDeclContext()->isLocalContext())
+    return false;
+
+  // Type parameters are OK.
+  if (isa<AbstractTypeParamDecl>(D))
+    return false;
+
+  // Public declarations are OK.
+  if (D->getEffectiveAccess() >= Accessibility::Public)
+    return false;
+
+  // Enum cases are handled as part of their containing enum.
+  if (isa<EnumElementDecl>(D))
+    return false;
+    
+  // Protocol requirements are not versioned because there's no
+  // global entry point.
+  if (isa<ProtocolDecl>(D->getDeclContext()) && isRequirement(D))
+    return false;
+
+  // FIXME: Figure out what to do with typealiases
+  if (isa<TypeAliasDecl>(D))
+    return false;
+
+  diagnose(loc, diag::resilience_decl_unavailable,
+           D->getDescriptiveKind(), D->getFullName(),
+           D->getFormalAccess(), getFragileFunctionKind(DC));
+  diagnose(D, diag::resilience_decl_declared_here,
+           D->getDescriptiveKind(), D->getFullName());
+  return true;
 }
 
 void TypeChecker::diagnoseResilientValueConstructor(ConstructorDecl *ctor) {

test/attr/attr_inlineable.swift

@@ -217,32 +217,29 @@ extension VersionedProtocol {
   }
 }
 
-protocol InternalProtocol {
-  associatedtype T
-
-  func requirement() -> T
+enum InternalEnum {
+// expected-note@-1 2{{enum 'InternalEnum' is not '@_versioned' or public}}
+  case apple
+  case orange
 }
 
-extension InternalProtocol {
-  func internalMethod() {}
+@_inlineable public func usesInternalEnum() {
+  _ = InternalEnum.apple
+  // expected-error@-1 {{enum 'InternalEnum' is internal and cannot be referenced from an '@_inlineable' function}}
+  let _: InternalEnum = .orange
+  // expected-error@-1 {{enum 'InternalEnum' is internal and cannot be referenced from an '@_inlineable' function}}
+}
 
-  // FIXME: https://bugs.swift.org/browse/SR-3684
-  //
-  // This should either complain that the method cannot be '@_versioned' since
-  // we're inside an extension of an internal protocol, or if such methods are
-  // allowed, we should diagnose the reference to 'internalMethod()' from the
-  // body.
-  @_inlineable
-  @_versioned
-  func versionedMethod() -> T {
-    internalMethod()
-    return requirement()
-  }
+@_versioned enum VersionedEnum {
+  case apple
+  case orange
+  // FIXME: Should this be banned?
+  case pear(InternalEnum)
+  case persimmon(String)
+}
 
-  // Ditto, except s/@_versioned/public/.
-  @_inlineable
-  public func publicMethod() -> T {
-    internalMethod()
-    return requirement()
-  }
+@_inlineable public func usesVersionedEnum() {
+  _ = VersionedEnum.apple
+  let _: VersionedEnum = .orange
+  _ = VersionedEnum.persimmon
 }