add $SuppressedConformances feature flag

This will help prevent condfails when older compilers try
to typecheck interfaces with `~Swift.Copyable` in them.

Author: kavon

include/swift/AST/Decl.h

@@ -1117,6 +1117,13 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     return getAttrs().hasAttribute<NoImplicitCopyAttr>();
   }
 
+  /// Determines whether this Decl has any suppressed entries in its inheritance
+  /// clause, or within its generic context (e.g., its generic parameters).
+  ///
+  /// IMPLEMENTATION NOTE: as of today this does _not_ look into 'where' clauses
+  /// but it probably should.
+  bool hasSuppressedConformance() const;
+
   AvailabilityContext getAvailabilityForLinkage() const;
 
   /// Whether this declaration or one of its outer contexts has the

include/swift/Basic/Features.def

@@ -100,6 +100,7 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(
         hasSwiftSwiftParser)
 LANGUAGE_FEATURE(AttachedMacros, 389, "Attached macros", hasSwiftSwiftParser)
 LANGUAGE_FEATURE(MoveOnly, 390, "noncopyable types", true)
+LANGUAGE_FEATURE(SuppressedConformances, 390, "suppression of implicit conformance", true)
 LANGUAGE_FEATURE(ParameterPacks, 393, "Value and type parameter packs", true)
 
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)

lib/AST/ASTPrinter.cpp

@@ -3276,6 +3276,34 @@ static bool usesFeatureMoveOnly(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureSuppressedConformances(Decl *decl) {
+  // first check the decl itself.
+  if (decl->hasSuppressedConformance())
+    return true;
+
+  // for extensions, check the type it extends.
+  if (auto *extnDecl = dyn_cast<ExtensionDecl>(decl))
+    if (auto *nom = extnDecl->getSelfNominalTypeDecl())
+      if (nom->hasSuppressedConformance())
+        return true;
+
+  // otherwise, search the decl's interface for a type with suppressed entries
+  if (auto value = dyn_cast<ValueDecl>(decl)) {
+    if (Type type = value->getInterfaceType()) {
+      return type.findIf([&](Type t) {
+        auto canType = t->getCanonicalType();
+
+        if (auto *decl = canType->getAnyNominal())
+          return decl->hasSuppressedConformance();
+
+        return false;
+      });
+    }
+  }
+
+  return false;
+}
+
 static bool usesFeatureMoveOnlyClasses(Decl *decl) {
   return isa<ClassDecl>(decl) && usesFeatureMoveOnly(decl);
 }

lib/AST/Decl.cpp

@@ -10573,3 +10573,45 @@ MacroDiscriminatorContext::getParentOf(MacroExpansionDecl *expansion) {
   return getParentOf(
       expansion->getLoc(), expansion->getDeclContext());
 }
+
+bool Decl::hasSuppressedConformance() const {
+  if (auto typeDecl = dyn_cast<TypeDecl>(this))
+    if (!typeDecl->getSuppressed().empty())
+      return true;
+
+  if (auto *gc = getAsGenericContext()) {
+    if (auto *genericParams = gc->getGenericParams()) {
+      auto suppressedParam =
+          llvm::any_of(genericParams->getParams(),
+                       [](GenericTypeParamDecl const *param) {
+                         return param->hasSuppressedConformance();
+                       });
+
+      if (suppressedParam)
+        return true;
+
+      // TODO: eventually once where clauses support suppression, this ought to
+      //  look for their corresponding requirements.
+    }
+  }
+
+  if (auto extnDecl = dyn_cast<ExtensionDecl>(this)) {
+    // NOTE: The presence of suppressed entries in extensions creates some
+    // difficulty in determining whether there is a suppressed conformance
+    // purely from looking at suppressed entries, as both the nominal and its
+    // extension has space for these entries. We'd need a form of lookup
+    // similar to conformance lookups that merges together all information
+    // from extensions and the original declaration to determine whether there
+    // was a suppressed entry anywhere. That's why the previous check for the
+    // TypeDecl is so simple, and doesn't search its extensions.
+    //
+    // Extensions with suppressed entries should have been rejected in
+    // type checking, so crash if there is one here.
+    if (!extnDecl->getSuppressed().empty())
+      llvm_unreachable("unexpected suppression in extension");
+
+    return false;
+  }
+
+  return false;
+}

test/ModuleInterface/moveonly_interface_flag.swift

@@ -1,27 +1,30 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-emit-module-interface(%t/Library.swiftinterface) %s -module-name Library
 // RUN: %target-swift-typecheck-module-from-interface(%t/Library.swiftinterface) -I %t
-// RUN: %FileCheck %s < %t/Library.swiftinterface
+// RUN: %FileCheck --implicit-check-not SuppressedConformances %s < %t/Library.swiftinterface
 
 // this test makes sure that decls containing a move-only type are guarded by the $MoveOnly feature flag
 
-// CHECK:       #if compiler(>=5.3) && $MoveOnly
+// CHECK:       #if compiler(>=5.3) && $MoveOnly && $SuppressedConformances
 // CHECK-NEXT:    public struct MoveOnlyStruct : ~Swift.Copyable {
 
 // CHECK:       #if compiler(>=5.3) && $MoveOnly
 // CHECK-NEXT:    @_moveOnly public struct OldAttr_MoveOnlyStruct {
 
-// CHECK:      #if compiler(>=5.3) && $MoveOnly
+// CHECK:      #if compiler(>=5.3) && $MoveOnly && $SuppressedConformances
 // CHECK-NEXT:   public enum MoveOnlyEnum : ~Swift.Copyable {
 
-// CHECK:      #if compiler(>=5.3) && $MoveOnly
+// CHECK:      #if compiler(>=5.3) && $MoveOnly && $SuppressedConformances
 // CHECK-NEXT:   public func someFn() -> Library.MoveOnlyEnum
 
+// CHECK:      #if compiler(>=5.3) && $MoveOnly
+// CHECK-NEXT:   public func oldFn() -> Library.OldAttr_MoveOnlyStruct
+
 // CHECK:     public class What {
-// CHECK:       #if compiler(>=5.3) && $MoveOnly
+// CHECK:       #if compiler(>=5.3) && $MoveOnly && $SuppressedConformances
 // CHECK-NEXT:    public func diamonds(_ f: (borrowing Library.MoveOnlyStruct) -> Swift.Int)
 
-// CHECK: #if compiler(>=5.3) && $MoveOnly
+// CHECK: #if compiler(>=5.3) && $MoveOnly && $SuppressedConformances
 // CHECK-NEXT:  extension Library.MoveOnlyStruct {
 
 public struct MoveOnlyStruct : ~Copyable {
@@ -38,6 +41,8 @@ public enum MoveOnlyEnum : ~Copyable {
 
 public func someFn() -> MoveOnlyEnum { return .depth }
 
+public func oldFn() -> OldAttr_MoveOnlyStruct { return OldAttr_MoveOnlyStruct() }
+
 public class What {
   public func diamonds(_ f: (borrowing MoveOnlyStruct) -> Int) {}
 }