Merge pull request #25709 from jrose-apple/5.1-imply-in-the-sky

[5.1] [ModuleInterface] Explicitly print implied Hashable et al on enums

Author: jrose-apple

include/swift/AST/Attr.h

@@ -1528,6 +1528,9 @@ class DeclAttributes {
   void dump(const Decl *D = nullptr) const;
   void print(ASTPrinter &Printer, const PrintOptions &Options,
              const Decl *D = nullptr) const;
+  static void print(ASTPrinter &Printer, const PrintOptions &Options,
+                    ArrayRef<const DeclAttribute *> FlattenedAttrs,
+                    const Decl *D = nullptr);
 
   template <typename T, typename DERIVED>
   class iterator_base : public std::iterator<std::forward_iterator_tag, T *> {

lib/AST/Attr.cpp

@@ -332,9 +332,14 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
   if (!DeclAttrs)
     return;
 
+  SmallVector<const DeclAttribute *, 8> orderedAttributes(begin(), end());
+  print(Printer, Options, orderedAttributes, D);
+}
+
+void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
+                           ArrayRef<const DeclAttribute *> FlattenedAttrs,
+                           const Decl *D) {
   using AttributeVector = SmallVector<const DeclAttribute *, 8>;
-  AttributeVector orderedAttributes(begin(), end());
-  std::reverse(orderedAttributes.begin(), orderedAttributes.end());
 
   // Process attributes in passes.
   AttributeVector shortAvailableAttributes;
@@ -344,7 +349,7 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
   AttributeVector attributes;
   AttributeVector modifiers;
 
-  for (auto DA : orderedAttributes) {
+  for (auto DA : llvm::reverse(FlattenedAttrs)) {
     if (!Options.PrintImplicitAttrs && DA->isImplicit())
       continue;
     if (!Options.PrintUserInaccessibleAttrs &&

lib/Frontend/ParseableInterfaceSupport.cpp

@@ -178,11 +178,28 @@ class InheritedProtocolCollector {
   SmallVector<const ProtocolType *, 8> ConditionalConformanceProtocols;
 
   /// Helper to extract the `@available` attributes on a decl.
-  AvailableAttrList getAvailabilityAttrs(const Decl *D) {
-    AvailableAttrList result;
-    auto attrRange = D->getAttrs().getAttributes<AvailableAttr>();
-    result.insert(result.begin(), attrRange.begin(), attrRange.end());
-    return result;
+  static AvailableAttrList
+  getAvailabilityAttrs(const Decl *D, Optional<AvailableAttrList> &cache) {
+    if (cache.hasValue())
+      return cache.getValue();
+
+    cache.emplace();
+    while (D) {
+      for (auto *nextAttr : D->getAttrs().getAttributes<AvailableAttr>()) {
+        // FIXME: This is just approximating the effects of nested availability
+        // attributes for the same platform; formally they'd need to be merged.
+        bool alreadyHasMoreSpecificAttrForThisPlatform =
+            llvm::any_of(*cache, [nextAttr](const AvailableAttr *existingAttr) {
+          return existingAttr->Platform == nextAttr->Platform;
+        });
+        if (alreadyHasMoreSpecificAttrForThisPlatform)
+          continue;
+        cache->push_back(nextAttr);
+      }
+      D = D->getDeclContext()->getAsDecl();
+    }
+
+    return cache.getValue();
   }
 
   /// For each type in \p directlyInherited, classify the protocols it refers to
@@ -197,20 +214,30 @@ class InheritedProtocolCollector {
         continue;
 
       bool canPrintNormally = isPublicOrUsableFromInline(inheritedTy);
-      if (!canPrintNormally && !availableAttrs.hasValue())
-        availableAttrs = getAvailabilityAttrs(D);
-
       ExistentialLayout layout = inheritedTy->getExistentialLayout();
       for (ProtocolType *protoTy : layout.getProtocols()) {
         if (canPrintNormally)
           IncludedProtocols.push_back(protoTy->getDecl());
         else
           ExtraProtocols.push_back({protoTy->getDecl(),
-                                    availableAttrs.getValue()});
+                                    getAvailabilityAttrs(D, availableAttrs)});
       }
       // FIXME: This ignores layout constraints, but currently we don't support
       // any of those besides 'AnyObject'.
     }
+
+    // Check for synthesized protocols, like Hashable on enums.
+    if (auto *nominal = dyn_cast<NominalTypeDecl>(D)) {
+      SmallVector<ProtocolConformance *, 4> localConformances =
+          nominal->getLocalConformances(ConformanceLookupKind::NonInherited);
+
+      for (auto *conf : localConformances) {
+        if (conf->getSourceKind() != ConformanceEntryKind::Synthesized)
+          continue;
+        ExtraProtocols.push_back({conf->getProtocol(),
+                                  getAvailabilityAttrs(D, availableAttrs)});
+      }
+    }
   }
 
   /// For each type directly inherited by \p extension, record any protocols
@@ -332,8 +359,7 @@ class InheritedProtocolCollector {
     // a bit more memory.
     // FIXME: This will pick the availability attributes from the first sight
     // of a protocol rather than the maximally available case.
-    SmallVector<std::pair<ProtocolDecl *, AvailableAttrList>, 16>
-        protocolsToPrint;
+    SmallVector<ProtocolAndAvailability, 16> protocolsToPrint;
     for (const auto &protoAndAvailability : ExtraProtocols) {
       protoAndAvailability.first->walkInheritedProtocols(
           [&](ProtocolDecl *inherited) -> TypeWalker::Action {
@@ -354,8 +380,11 @@ class InheritedProtocolCollector {
 
     for (const auto &protoAndAvailability : protocolsToPrint) {
       StreamPrinter printer(out);
-      for (const AvailableAttr *attr : protoAndAvailability.second)
-        attr->print(printer, printOptions);
+      // FIXME: Shouldn't this be an implicit conversion?
+      TinyPtrVector<const DeclAttribute *> attrs;
+      attrs.insert(attrs.end(), protoAndAvailability.second.begin(),
+                   protoAndAvailability.second.end());
+      DeclAttributes::print(printer, printOptions, attrs);
 
       printer << "extension ";
       nominal->getDeclaredType().print(printer, printOptions);

test/ParseableInterface/conformances.swift

@@ -195,21 +195,21 @@ extension Bool: ExtraHashable {}
 @available(macOS, unavailable)
 public struct CoolTVType: PrivateSubProto {}
 // CHECK: public struct CoolTVType {
-// CHECK-END: @available(OSX, unavailable)
-// CHECK-END-NEXT: @available(iOS, unavailable)
+// CHECK-END: @available(iOS, unavailable)
+// CHECK-END-NEXT: @available(OSX, unavailable)
 // CHECK-END-NEXT: extension conformances.CoolTVType : conformances.PublicBaseProto {}
 
 @available(macOS 10.99, *)
 public struct VeryNewMacType: PrivateSubProto {}
 // CHECK: public struct VeryNewMacType {
-// CHECK-END: @available(OSX, introduced: 10.99)
+// CHECK-END: @available(OSX 10.99, *)
 // CHECK-END-NEXT: extension conformances.VeryNewMacType : conformances.PublicBaseProto {}
 
 public struct VeryNewMacProto {}
 @available(macOS 10.98, *)
 extension VeryNewMacProto: PrivateSubProto {}
 // CHECK: public struct VeryNewMacProto {
-// CHECK-END: @available(OSX, introduced: 10.98)
+// CHECK-END: @available(OSX 10.98, *)
 // CHECK-END-NEXT: extension conformances.VeryNewMacProto : conformances.PublicBaseProto {}
 
 public struct PrivateProtoConformer {}
@@ -228,5 +228,19 @@ extension PrivateProtoConformer : PrivateProto {
 // NEGATIVE-NOT: extension {{(Swift.)?}}Bool{{.+}}Equatable
 
 
+@available(macOS 10.97, iOS 22, *)
+@available(tvOS, unavailable)
+@available(swift 4.2.123)
+public struct NestedAvailabilityOuter {
+  @available(iOS 23, *)
+  public struct Inner: PrivateSubProto {}
+}
+
+// CHECK-END: @available(swift 4.2.123)
+// CHECK-END-NEXT: @available(OSX 10.97, iOS 23, *)
+// CHECK-END-NEXT: @available(tvOS, unavailable)
+// CHECK-END-NEXT: extension conformances.NestedAvailabilityOuter.Inner : conformances.PublicBaseProto {}
+
+
 // CHECK-END: @usableFromInline
 // CHECK-END-NEXT: internal protocol _ConstraintThatIsNotPartOfTheAPIOfThisLibrary {}

test/ParseableInterface/enums-layout.swift

@@ -1,5 +1,5 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend -emit-module-interface-path %t/Lib.swiftinterface -typecheck -enable-library-evolution -enable-objc-interop -disable-objc-attr-requires-foundation-module -swift-version 5 %S/Inputs/enums-layout-helper.swift
+// RUN: %target-swift-frontend -emit-module-interface-path %t/Lib.swiftinterface -typecheck -enable-library-evolution -enable-objc-interop -disable-objc-attr-requires-foundation-module -swift-version 5 %S/Inputs/enums-layout-helper.swift -module-name Lib
 // RUN: %FileCheck %S/Inputs/enums-layout-helper.swift < %t/Lib.swiftinterface
 // RUN: %target-swift-frontend -enable-objc-interop -O -emit-ir -primary-file %s -I %t | %FileCheck %s
 

test/ParseableInterface/synthesized.swift

@@ -1,4 +1,6 @@
-// RUN: %target-swift-frontend -typecheck -emit-parseable-module-interface-path - %s -disable-objc-attr-requires-foundation-module -enable-objc-interop | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck -emit-parseable-module-interface-path - %s -disable-objc-attr-requires-foundation-module -enable-objc-interop > %t.swiftinterface
+// RUN: %FileCheck %s < %t.swiftinterface
+// RUN: %FileCheck -check-prefix=NEGATIVE %s < %t.swiftinterface
 
 // CHECK-LABEL: public enum HasRawValue : Swift.Int {
 public enum HasRawValue: Int {
@@ -23,3 +25,35 @@ public enum HasRawValue: Int {
 // CHECK-DAG:   @inlinable get{{$}}
 // CHECK-DAG: }
 // CHECK: {{^}$}}
+
+// CHECK-LABEL: public enum NoRawValueWithExplicitEquatable : Swift.Equatable {
+public enum NoRawValueWithExplicitEquatable : Equatable {
+  // CHECK-NEXT: case a, b, c
+  case a, b, c
+} // CHECK: {{^}$}}
+
+// CHECK-LABEL: public enum NoRawValueWithExplicitHashable {
+public enum NoRawValueWithExplicitHashable {
+  // CHECK-NEXT: case a, b, c
+case a, b, c
+} // CHECK: {{^}$}}
+
+// CHECK-LABEL: extension NoRawValueWithExplicitHashable : Swift.Hashable {
+extension NoRawValueWithExplicitHashable : Hashable {
+  // CHECK-NEXT: public func foo()
+  public func foo() {}
+} // CHECK: {{^}$}}
+
+// CHECK: extension synthesized.HasRawValue : Swift.Equatable {}
+// CHECK: extension synthesized.HasRawValue : Swift.Hashable {}
+// CHECK: extension synthesized.HasRawValue : Swift.RawRepresentable {}
+
+// CHECK: extension synthesized.ObjCEnum : Swift.Equatable {}
+// CHECK: extension synthesized.ObjCEnum : Swift.Hashable {}
+// CHECK: extension synthesized.ObjCEnum : Swift.RawRepresentable {}
+
+// CHECK: extension synthesized.NoRawValueWithExplicitEquatable : Swift.Hashable {}
+// NEGATIVE-NOT: extension {{.+}}NoRawValueWithExplicitEquatable : Swift.Equatable
+
+// NEGATIVE-NOT: NoRawValueWithExplicitHashable : Swift.Equatable
+// NEGATIVE-NOT: NoRawValueWithExplicitHashable : Swift.Hashable {}