Merge pull request #7138 from slavapestov/fix-more-inlineable-bugs

slavapestov · web-flow · commit 00bceec61331 · 2017-01-29T23:27:55.000-08:00
Fix more @_inlineable bugs
diff --git a/lib/SIL/SILDeclRef.cpp b/lib/SIL/SILDeclRef.cpp
@@ -438,11 +438,6 @@ SILLinkage SILDeclRef::getLinkage(ForDefinition_t forDefinition) const {
   if (isEnumElement())
     return SILLinkage::Shared;
 
-  // Stored property initializers have hidden linkage, since they are
-  // not meant to be used from outside of their module.
-  if (isStoredPropertyInitializer())
-    return (forDefinition ? SILLinkage::Hidden : SILLinkage::HiddenExternal);
-
   // Declarations imported from Clang modules have shared linkage.
   const SILLinkage ClangLinkage = SILLinkage::Shared;
 
@@ -499,9 +494,16 @@ bool SILDeclRef::isFragile() const {
   DeclContext *dc;
   if (auto closure = getAbstractClosureExpr())
     dc = closure->getLocalContext();
-  else
+  else {
     dc = getDecl()->getInnermostDeclContext();
 
+    // Enum case constructors are serialized if the enum is @_versioned
+    // or public.
+    if (isEnumElement())
+      if (cast<EnumDecl>(dc)->getEffectiveAccess() >= Accessibility::Public)
+        return true;
+  }
+
   // This is stupid
   return (dc->getResilienceExpansion() == ResilienceExpansion::Minimal);
 }
diff --git a/lib/Sema/ResilienceDiagnostics.cpp b/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) {
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -292,9 +292,12 @@ void AttributeEarlyChecker::visitIBActionAttr(IBActionAttr *attr) {
 
 void AttributeEarlyChecker::visitIBDesignableAttr(IBDesignableAttr *attr) {
   if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
-    NominalTypeDecl *extendedType = ED->getExtendedType()->getAnyNominal();
-    if (extendedType && !isa<ClassDecl>(extendedType))
-      return diagnoseAndRemoveAttr(attr, diag::invalid_ibdesignable_extension);
+    if (auto extendedType = ED->getExtendedType()) {
+      if (auto *nominalDecl = extendedType->getAnyNominal()) {
+        if (!isa<ClassDecl>(nominalDecl))
+          return diagnoseAndRemoveAttr(attr, diag::invalid_ibdesignable_extension);
+      }
+    }
   }
 }
 
@@ -1770,14 +1773,19 @@ void AttributeChecker::visitSpecializeAttr(SpecializeAttr *attr) {
   attr->setRequirements(DC->getASTContext(), convertedRequirements);
 }
 
+static Accessibility getAccessForDiagnostics(const ValueDecl *D) {
+  return std::min(D->getFormalAccess(),
+                  D->getEffectiveAccess());
+}
+
 void AttributeChecker::visitFixedLayoutAttr(FixedLayoutAttr *attr) {
   auto *VD = cast<ValueDecl>(D);
 
   if (VD->getEffectiveAccess() < Accessibility::Public) {
     TC.diagnose(attr->getLocation(),
                 diag::fixed_layout_attr_on_internal_type,
                 VD->getName(),
-                VD->getFormalAccess())
+                getAccessForDiagnostics(VD))
         .fixItRemove(attr->getRangeWithAt());
     attr->setInvalid();
   }
@@ -1800,7 +1808,7 @@ void AttributeChecker::visitVersionedAttr(VersionedAttr *attr) {
     TC.diagnose(attr->getLocation(),
                 diag::versioned_attr_with_explicit_accessibility,
                 VD->getName(),
-                VD->getFormalAccess())
+                getAccessForDiagnostics(VD))
         .fixItRemove(attr->getRangeWithAt());
     attr->setInvalid();
     return;
diff --git a/test/SILGen/inlineable_attribute.swift b/test/SILGen/inlineable_attribute.swift
@@ -24,3 +24,23 @@ public class MyCls {
   // CHECK-LABEL: sil [fragile] @_T020inlineable_attribute5MyClsCfD : $@convention(method) (@owned MyCls) -> ()
   @_inlineable deinit {}
 }
+
+// Make sure enum case constructors for public and versioned enums are
+// [fragile].
+@_versioned enum MyEnum {
+  case c(MySt)
+}
+
+// CHECK-LABEL: sil shared [transparent] [fragile] [thunk] @_T020inlineable_attribute6MyEnumO1cAcA0C2StVcACmFTc : $@convention(thin) (@thin MyEnum.Type) -> @owned @callee_owned (MySt) -> MyEnum
+
+@_inlineable public func referencesMyEnum() {
+  _ = MyEnum.c
+}
+
+// CHECK-LABEL: sil [transparent] @_T020inlineable_attribute15HasInitializersV1xSivfi : $@convention(thin) () -> Int
+
+public struct HasInitializers {
+  public let x = 1234
+
+  @_inlineable public init() {}
+}
diff --git a/test/attr/attr_fixed_layout.swift b/test/attr/attr_fixed_layout.swift
@@ -50,9 +50,13 @@ struct Rectangle {
 // Diagnostics
 //
 
-@_fixed_layout struct InternalStruct {}
+@_fixed_layout struct InternalStruct {
 // expected-error@-1 {{'@_fixed_layout' attribute can only be applied to '@_versioned' or public declarations, but 'InternalStruct' is internal}}
 
+  @_fixed_layout public struct NestedStruct {}
+  // expected-error@-1 {{'@_fixed_layout' attribute can only be applied to '@_versioned' or public declarations, but 'NestedStruct' is internal}}
+}
+
 @_fixed_layout fileprivate struct FileprivateStruct {}
 // expected-error@-1 {{'@_fixed_layout' attribute can only be applied to '@_versioned' or public declarations, but 'FileprivateStruct' is fileprivate}}
 
diff --git a/test/attr/attr_inlineable.swift b/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
 }
diff --git a/validation-test/compiler_crashers_fixed/28608-swift-typebase-getcanonicaltype.swift b/validation-test/compiler_crashers_fixed/28608-swift-typebase-getcanonicaltype.swift
@@ -5,5 +5,5 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+// RUN: not %target-swift-frontend %s -emit-ir
 do{@IBDesignable extension
diff --git a/validation-test/compiler_crashers_fixed/28660-false-encountered-error-in-diagnostic-text.swift b/validation-test/compiler_crashers_fixed/28660-false-encountered-error-in-diagnostic-text.swift
@@ -6,5 +6,5 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // REQUIRES: asserts
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+// RUN: not %target-swift-frontend %s -emit-ir
 class C{@_fixed_layout public struct P
