TypeCheckType: Make ExistentialAny warn until Swift 7 rather than error

This enables programmers to opt in to assisted adoption of the new
syntax without breaking code and, thus, migrate in increments.

Author: AnthonyLatsis

include/swift/AST/Decl.h

@@ -5547,12 +5547,6 @@ class ProtocolDecl final : public NominalTypeDecl {
   ///   value requirement.
   bool hasSelfOrAssociatedTypeRequirements() const;
 
-  /// Determine whether an existential type constrained by this protocol must
-  /// be written using `any` syntax.
-  ///
-  /// \Note This method takes language feature state into account.
-  bool existentialRequiresAny() const;
-
   /// Returns a list of protocol requirements that must be assessed to
   /// determine a concrete's conformance effect polymorphism kind.
   PolymorphicEffectRequirementList getPolymorphicEffectRequirements(

lib/AST/Decl.cpp

@@ -6856,13 +6856,6 @@ bool ProtocolDecl::hasSelfOrAssociatedTypeRequirements() const {
                            resultForCycle);
 }
 
-bool ProtocolDecl::existentialRequiresAny() const {
-  if (getASTContext().LangOpts.hasFeature(Feature::ExistentialAny))
-    return true;
-
-  return hasSelfOrAssociatedTypeRequirements();
-}
-
 ArrayRef<AssociatedTypeDecl *>
 ProtocolDecl::getPrimaryAssociatedTypes() const {
   return evaluateOrDefault(getASTContext().evaluator,

lib/Sema/TypeCheckType.cpp

@@ -6161,16 +6161,16 @@ class ExistentialTypeSyntaxChecker : public ASTWalker {
   ASTContext &Ctx;
   const bool checkStatements;
   bool hitTopStmt;
-  bool warnUntilSwift7;
+  const bool downgradeErrorsToWarnings;
 
   unsigned exprCount = 0;
   llvm::SmallVector<TypeRepr *, 4> reprStack;
 
 public:
   ExistentialTypeSyntaxChecker(ASTContext &ctx, bool checkStatements,
-                               bool warnUntilSwift7 = false)
+                               bool downgradeErrorsToWarnings = false)
       : Ctx(ctx), checkStatements(checkStatements), hitTopStmt(false),
-        warnUntilSwift7(warnUntilSwift7) {}
+        downgradeErrorsToWarnings(downgradeErrorsToWarnings) {}
 
   MacroWalking getMacroWalkingBehavior() const override {
     return MacroWalking::ArgumentsAndExpansion;
@@ -6355,6 +6355,50 @@ class ExistentialTypeSyntaxChecker : public ASTWalker {
     return isa<OpaqueReturnTypeRepr>(*it) || isa<ExistentialTypeRepr>(*it);
   }
 
+  /// Returns the behavior with which to diagnose a missing `any` or `some`
+  /// keyword.
+  ///
+  /// \param constraintTy The constraint type that is missing the keyword.
+  /// \param isInverted Whether the constraint type is an object of an `~`
+  ///  inversion.
+  static DiagnosticBehavior getDiagnosticBehaviorForMissingAnyOrSomeKeyword(
+      Type constraintTy, bool isInverted, ASTContext &ctx) {
+    // `Any` and `AnyObject` are always exempt from `any` syntax.
+    if (constraintTy->isAny() || constraintTy->isAnyObject()) {
+      return DiagnosticBehavior::Ignore;
+    }
+
+    // If the type is inverted, a missing `any` or `some` is an error.
+    if (isInverted) {
+      return DiagnosticBehavior::Error;
+    }
+
+    // If one of the protocols is inverted, a missing `any` or `some` is
+    // an error.
+    if (auto *PCT = constraintTy->getAs<ProtocolCompositionType>()) {
+      if (!PCT->getInverses().empty()) {
+        return DiagnosticBehavior::Error;
+      }
+    }
+
+    // If one of the protocols has "Self or associated type" requirements,
+    // a missing `any` or `some` is an error.
+    auto layout = constraintTy->getExistentialLayout();
+    for (auto *protoDecl : layout.getProtocols()) {
+      if (protoDecl->hasSelfOrAssociatedTypeRequirements()) {
+        return DiagnosticBehavior::Error;
+      }
+    }
+
+    if (ctx.LangOpts.hasFeature(Feature::ExistentialAny)) {
+      // For anything else, a missing `any` or `some` is a warning if this
+      // feature is enabled.
+      return DiagnosticBehavior::Warning;
+    }
+
+    return DiagnosticBehavior::Ignore;
+  }
+
   void checkDeclRefTypeRepr(DeclRefTypeRepr *T) const {
     if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
       return;
@@ -6403,49 +6447,33 @@ class ExistentialTypeSyntaxChecker : public ASTWalker {
       return dyn_cast<InverseTypeRepr>(*it);
     }();
 
-    const bool shouldDiagnose = [&] {
-      // `Any` and `AnyObject` are always exempt from `any` syntax.
-      if (type->isAny() || type->isAnyObject()) {
-        return false;
-      }
-
-      // Look for protocol members that require 'any'.
-      auto layout = type->getExistentialLayout();
-      for (auto *protoDecl : layout.getProtocols()) {
-        if (protoDecl->existentialRequiresAny()) {
-          return true;
-        }
-      }
-
-      // If inverses are present, require 'any' too.
-      if (auto *PCT = type->getAs<ProtocolCompositionType>()) {
-        if (!PCT->getInverses().empty()) {
-          return true;
-        }
-      }
-
-      if (outerInversion) {
-        return true;
-      }
+    DiagnosticBehavior behavior =
+        this->getDiagnosticBehaviorForMissingAnyOrSomeKeyword(
+            type, /*isInverted=*/outerInversion, this->Ctx);
 
-      return false;
-    }();
+    if (behavior == DiagnosticBehavior::Ignore) {
+      return;
+    }
 
-    if (shouldDiagnose) {
-      std::optional<InFlightDiagnostic> diag;
-      if (outerInversion) {
-        diag.emplace(Ctx.Diags.diagnose(outerInversion->getTildeLoc(),
-                                        diag::inverse_requires_any));
-      } else {
-        diag.emplace(Ctx.Diags.diagnose(T->getNameLoc(),
-                                        diag::existential_requires_any, type,
-                                        ExistentialType::get(type),
-                                        /*isAlias=*/isa<TypeAliasDecl>(decl)));
-      }
+    // If we were asked to downgrade errors, respect it.
+    if (behavior == DiagnosticBehavior::Error &&
+        this->downgradeErrorsToWarnings) {
+      behavior = DiagnosticBehavior::Warning;
+    }
 
-      diag->warnUntilSwiftVersionIf(warnUntilSwift7, 7);
-      emitInsertAnyFixit(*diag, T);
+    std::optional<InFlightDiagnostic> diag;
+    if (outerInversion) {
+      diag.emplace(Ctx.Diags.diagnose(outerInversion->getTildeLoc(),
+                                      diag::inverse_requires_any));
+    } else {
+      diag.emplace(Ctx.Diags.diagnose(T->getNameLoc(),
+                                      diag::existential_requires_any, type,
+                                      ExistentialType::get(type),
+                                      /*isAlias=*/isa<TypeAliasDecl>(decl)));
     }
+
+    diag->limitBehaviorUntilSwiftVersion(behavior, 7);
+    emitInsertAnyFixit(*diag, T);
   }
 
 public:
@@ -6523,12 +6551,12 @@ void TypeChecker::checkExistentialTypes(ASTContext &ctx, Stmt *stmt,
 
   // Previously we missed this diagnostic on 'catch' statements, downgrade
   // to a warning until Swift 7.
-  auto downgradeUntilSwift7 = false;
+  auto downgradeErrorsToWarnings = false;
   if (auto *CS = dyn_cast<CaseStmt>(stmt))
-    downgradeUntilSwift7 = CS->getParentKind() == CaseParentKind::DoCatch;
+    downgradeErrorsToWarnings = CS->getParentKind() == CaseParentKind::DoCatch;
 
   ExistentialTypeSyntaxChecker checker(ctx, /*checkStatements=*/true,
-                                       downgradeUntilSwift7);
+                                       downgradeErrorsToWarnings);
   stmt->walk(checker);
 }
 

test/type/explicit_existential.swift

@@ -18,8 +18,10 @@ protocol Bar {
 }
 
 class Bistro {
-  convenience init(_: Bar){ self.init()} // expected-explicit-any-error{{use of protocol 'Bar' as a type must be written 'any Bar'}}{{23-26=any Bar}}
-  class func returnBar() -> Bar {} // expected-explicit-any-error {{use of protocol 'Bar' as a type must be written 'any Bar'}}{{29-32=any Bar}}
+  convenience init(_: Bar){ self.init()}
+  // expected-explicit-any-warning@-1 {{use of protocol 'Bar' as a type must be written 'any Bar'; this will be an error in a future Swift language mode}}{{23-26=any Bar}}
+  class func returnBar() -> Bar {}
+  // expected-explicit-any-warning@-1 {{use of protocol 'Bar' as a type must be written 'any Bar'; this will be an error in a future Swift language mode}}{{29-32=any Bar}}
 }
 
 func useBarAsType(_ x: any Bar) {}
@@ -217,7 +219,8 @@ protocol RawRepresentable {
 enum E1: RawRepresentable {
   typealias RawValue = P1
 
-  var rawValue: P1 { // expected-explicit-any-error {{use of protocol 'P1' as a type must be written 'any P1'}}{{17-19=any P1}}
+  var rawValue: P1 {
+    // expected-explicit-any-warning@-1 {{use of protocol 'P1' as a type must be written 'any P1'; this will be an error in a future Swift language mode}}{{17-19=any P1}}
     return ConcreteComposition()
   }
 }
@@ -315,9 +318,9 @@ enum EE : Equatable, any Empty { // expected-error {{raw type 'any Empty' is not
 
 // Protocols from a serialized module (the standard library).
 do {
-  // expected-explicit-any-error@+1 {{use of protocol 'Decodable' as a type must be written 'any Decodable'}}
+  // expected-explicit-any-warning@+1 {{use of protocol 'Decodable' as a type must be written 'any Decodable'; this will be an error in a future Swift language mode}}
   let _: Decodable
-  // expected-explicit-any-error@+1 {{use of 'Codable' (aka 'Decodable & Encodable') as a type must be written 'any Codable' (aka 'any Decodable & Encodable')}}
+  // expected-explicit-any-warning@+1 {{use of 'Codable' (aka 'Decodable & Encodable') as a type must be written 'any Codable' (aka 'any Decodable & Encodable'); this will be an error in a future Swift language mode}}
   let _: Codable
 }
 
@@ -543,7 +546,7 @@ func testEnumAssociatedValue() {
     case c1((any HasAssoc) -> Void)
     // expected-error@+1 {{use of protocol 'HasAssoc' as a type must be written 'any HasAssoc'}}
     case c2((HasAssoc) -> Void)
-    // expected-explicit-any-error@+1 {{use of protocol 'P' as a type must be written 'any P'}}
+    // expected-explicit-any-warning@+1 {{use of protocol 'P' as a type must be written 'any P'; this will be an error in a future Swift language mode}}
     case c3((P) -> Void)
   }
 }
@@ -568,5 +571,7 @@ typealias Objectlike = AnyObject
 func f(_ x: Objectlike) {}
 
 typealias Copy = Copyable
-func h(_ z1: Copy, // expected-explicit-any-error {{use of 'Copy' (aka 'Copyable') as a type must be written 'any Copy' (aka 'any Copyable')}}
-       _ z2: Copyable) {} // expected-explicit-any-error {{use of protocol 'Copyable' as a type must be written 'any Copyable'}}
+func h(_ z1: Copy,
+       // expected-explicit-any-warning@-1 {{use of 'Copy' (aka 'Copyable') as a type must be written 'any Copy' (aka 'any Copyable'); this will be an error in a future Swift language mode}}
+       _ z2: Copyable) {}
+       // expected-explicit-any-warning@-1 {{use of protocol 'Copyable' as a type must be written 'any Copyable'; this will be an error in a future Swift language mode}}

test/type/explicit_existential_cyclic_protocol.swift

@@ -10,24 +10,24 @@ do {
   do {
     protocol P1 : P2 {}
     // expected-no-explicit-any-note@-1 2 {{protocol 'P1' declared here}}
-    // expected-explicit-any-note@-2 1 {{protocol 'P1' declared here}}
+    // expected-explicit-any-note@-2 2 {{protocol 'P1' declared here}}
     protocol P2 : P1 {}
     // expected-no-explicit-any-error@-1 2 {{protocol 'P2' refines itself}}
-    // expected-explicit-any-error@-2 1 {{protocol 'P2' refines itself}}
+    // expected-explicit-any-error@-2 2 {{protocol 'P2' refines itself}}
 
     // Diagnosed only with the feature enabled, as a protocol without
     // "HasSelfOrAssociatedTypeRequirements" should.
     let _: P2
-    // expected-explicit-any-error@-1 {{use of protocol 'P2' as a type must be written 'any P2'}}
+    // expected-explicit-any-warning@-1 {{use of protocol 'P2' as a type must be written 'any P2'}}
   }
   do {
     protocol P0 { associatedtype A }
     protocol P1 : P2, P0 {}
     // expected-no-explicit-any-note@-1 2 {{protocol 'P1' declared here}}
-    // expected-explicit-any-note@-2 1 {{protocol 'P1' declared here}}
+    // expected-explicit-any-note@-2 2 {{protocol 'P1' declared here}}
     protocol P2 : P1 {}
     // expected-no-explicit-any-error@-1 2 {{protocol 'P2' refines itself}}
-    // expected-explicit-any-error@-2 1 {{protocol 'P2' refines itself}}
+    // expected-explicit-any-error@-2 2 {{protocol 'P2' refines itself}}
 
     let _: P2
     // expected-error@-1 {{use of protocol 'P2' as a type must be written 'any P2'}}

test/type/explicit_existential_multimodule2.swift

@@ -4,14 +4,16 @@
 
 // REQUIRES: swift_feature_ExistentialAny
 
-// Test that a protocol that requires 'any' *only* when the feature is enabled
-// is diagnosed as expected when said protocol originates in a different module.
+// Test that a protocol that requires 'any' *only* under ExistentialAny
+// is diagnosed as expected with the feature enabled when said protocol
+// originates in a different module.
 // In other words, test that deserialization does not affect 'any' migration
 // diagnostics.
 
 #if M
 public protocol P {}
 #else
 import M
-func test(_: P) {} // expected-error {{use of protocol 'P' as a type must be written 'any P'}}
+func test(_: P) {}
+// expected-warning@-1 {{use of protocol 'P' as a type must be written 'any P'}}
 #endif