Sema: Tighten up SwiftUI conformance hack and add a warning

Author: AnthonyLatsis

include/swift/AST/DiagnosticsSema.def

@@ -1925,6 +1925,11 @@ NOTE(invalid_nominal_extension_rewrite,none,
 // Protocols
 ERROR(type_does_not_conform,none,
       "type %0 does not conform to protocol %1", (Type, Type))
+
+// FIXME: SwiftUI source compatibility hack; see usage for details.
+WARNING(type_does_not_conform_swiftui_warning,none,
+        "type %0 does not conform to protocol %1", (Type, Type))
+
 ERROR(cannot_use_nil_with_this_type,none,
       "'nil' cannot be used in context expecting type %0", (Type))
 
@@ -2300,6 +2305,10 @@ NOTE(protocol_witness_type_conflict,none,
 NOTE(protocol_witness_missing_requirement,none,
      "candidate would match if %0 %select{conformed to|subclassed|"
      "was the same type as}2 %1", (Type, Type, unsigned))
+NOTE(protocol_type_witness_missing_requirement,none,
+     "candidate would match if the conformance required that %0 "
+     "%select{conformed to|subclassed|was the same type as}2 %1",
+     (Type, Type, unsigned))
 
 NOTE(protocol_witness_optionality_conflict,none,
      "candidate %select{type has|result type has|parameter type has|"

lib/Sema/TypeCheckProtocol.cpp

@@ -4745,14 +4745,30 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
       continue;
 
     // As a narrow fix for a source compatibility issue with SwiftUI's
-    // swiftinterface, allow the conformance if the underlying type of
-    // the typealias is Never.
+    // swiftinterface, allow a 'typealias' type witness with an underlying type
+    // of 'Never' if it is declared in a context that does not satisfy the
+    // requirements of the conformance context.
     //
-    // FIXME: This should be conditionalized on a new language version.
+    // FIXME: If SwiftUI redeclares the typealias under the correct constraints,
+    // this can be removed.
     bool skipRequirementCheck = false;
     if (auto *typeAliasDecl = dyn_cast<TypeAliasDecl>(typeDecl)) {
-      if (typeAliasDecl->getUnderlyingType()->isUninhabited())
-        skipRequirementCheck = true;
+      if (typeAliasDecl->getUnderlyingType()->isNever()) {
+        if (typeAliasDecl->getParentModule()->getName().is("SwiftUI")) {
+          if (typeAliasDecl->getDeclContext()->getSelfNominalTypeDecl() ==
+              Adoptee->getAnyNominal()) {
+            const auto reqs =
+                typeAliasDecl->getGenericSignature().requirementsNotSatisfiedBy(
+                    DC->getGenericSignatureOfContext());
+            if (!reqs.empty()) {
+              SwiftUIInvalidTyWitness = {assocType, typeAliasDecl,
+                                         reqs.front()};
+
+              skipRequirementCheck = true;
+            }
+          }
+        }
+      }
     }
 
     // Skip typealiases with an unbound generic type as their underlying type.
@@ -5216,6 +5232,36 @@ void ConformanceChecker::checkConformance(MissingWitnessDiagnosisKind Kind) {
       }
     }
   }
+
+  if (Conformance->isInvalid()) {
+    return;
+  }
+
+  // As a narrow fix for a source compatibility issue with SwiftUI's
+  // swiftinterface, but only if the conformance succeeds, warn about an
+  // actually malformed conformance if we recorded a 'typealias' type witness
+  // with an underlying type of 'Never', which resides in a context that does
+  // not satisfy the requirements of the conformance context.
+  //
+  // FIXME: If SwiftUI redeclares the typealias under the correct constraints,
+  // this can be removed.
+  if (SwiftUIInvalidTyWitness) {
+    const auto &info = SwiftUIInvalidTyWitness.getValue();
+    const auto &failedReq = info.FailedReq;
+
+    auto &diags = getASTContext().Diags;
+    diags.diagnose(Loc, diag::type_does_not_conform_swiftui_warning, Adoptee,
+                   Proto->getDeclaredInterfaceType());
+    diags.diagnose(info.AssocTypeDecl, diag::no_witnesses_type,
+                   info.AssocTypeDecl->getName());
+
+    if (failedReq.getKind() != RequirementKind::Layout) {
+      diags.diagnose(info.TypeWitnessDecl,
+                     diag::protocol_type_witness_missing_requirement,
+                     failedReq.getFirstType(), failedReq.getSecondType(),
+                     (unsigned)failedReq.getKind());
+    }
+  }
 }
 
 /// Retrieve the Objective-C method key from the given function.

lib/Sema/TypeCheckProtocol.h

@@ -782,6 +782,14 @@ class ConformanceChecker : public WitnessChecker {
   /// Whether objcMethodRequirements has been computed.
   bool computedObjCMethodRequirements = false;
 
+  // FIXME: SwiftUI source compatibility hack; see usage for details.
+  struct SwiftUIInvalidTypeWitness final {
+    AssociatedTypeDecl *AssocTypeDecl;
+    TypeAliasDecl *TypeWitnessDecl;
+    Requirement FailedReq;
+  };
+  llvm::Optional<SwiftUIInvalidTypeWitness> SwiftUIInvalidTyWitness = None;
+
   /// Retrieve the associated types that are referenced by the given
   /// requirement with a base of 'Self'.
   ArrayRef<AssociatedTypeDecl *> getReferencedAssociatedTypes(ValueDecl *req);

test/Generics/constrained_type_witnesses.swift

@@ -2,7 +2,7 @@
 
 protocol P {
   associatedtype A
-  // expected-note@-1 3{{protocol requires nested type 'A'; do you want to add it?}}
+  // expected-note@-1 5{{protocol requires nested type 'A'; do you want to add it?}}
 }
 
 struct S1<T> {}
@@ -20,11 +20,7 @@ struct S2<T> {}
 extension S2 where T : P {
   typealias A = Never
 }
-
-// Hack: This is OK to make SwiftUI work, which accidentally relies on the
-// incorrect behavior with a typealias whose underlying type is 'Never'
-// (so it didn't hit the compiler crash).
-extension S2 : P {}
+extension S2 : P {} // expected-error {{type 'S2<T>' does not conform to protocol 'P'}}
 
 // Here we have a suitable witness
 struct S3<T> {}
@@ -48,7 +44,7 @@ struct S5<T> {
   typealias A = Never where T : P
 }
 
-extension S5 : P {}
+extension S5 : P {} // expected-error {{type 'S5<T>' does not conform to protocol 'P'}}
 
 struct S6<T> {
   typealias A = Int where T == Int

test/Generics/constrained_type_witnesses_swiftui_hack.swift

@@ -0,0 +1,36 @@
+// RUN: %target-typecheck-verify-swift -module-name SwiftUI
+
+class Class {}
+protocol P {
+  associatedtype A
+  // expected-note@-1 5{{protocol requires nested type 'A'; do you want to add it?}}
+}
+
+struct S1<T> {}
+extension S1 where T : P {
+  typealias A = Never // expected-note {{candidate would match if the conformance required that 'T' conformed to 'P'}}
+}
+extension S1 : P {} // expected-warning {{type 'S1<T>' does not conform to protocol 'P'}}
+
+struct S2<T> {
+  typealias A = Never where T : P // expected-note {{candidate would match if the conformance required that 'T' conformed to 'P'}}
+}
+extension S2 : P {} // expected-warning {{type 'S2<T>' does not conform to protocol 'P'}}
+
+struct S3<T> {}
+extension S3 where T : Class {
+  typealias A = Never // expected-note {{candidate would match if the conformance required that 'T' subclassed 'Class'}}
+}
+extension S3 : P {} // expected-warning {{type 'S3<T>' does not conform to protocol 'P'}}
+
+struct S4<T> {}
+extension S4 where T == Bool {
+  typealias A = Never // expected-note {{candidate would match if the conformance required that 'T' was the same type as 'Bool'}}
+}
+extension S4 : P {} // expected-warning {{type 'S4<T>' does not conform to protocol 'P'}}
+
+struct S5<T> {}
+extension S5 where T: AnyObject {
+  typealias A = Never
+}
+extension S5 : P {} // expected-warning {{type 'S5<T>' does not conform to protocol 'P'}}

test/decl/protocol/req/associated_type_inference.swift

@@ -537,14 +537,14 @@ protocol P32 {
   var bar: B { get }
 }
 protocol P33 {
-  associatedtype A
+  associatedtype A // expected-note {{protocol requires nested type 'A'; do you want to add it?}}
 
-  var baz: A { get } // expected-note {{protocol requires property 'baz' with type 'S31<T>.A' (aka 'Never'); do you want to add a stub?}}
+  var baz: A { get }
 }
 protocol P34 {
-  associatedtype A
+  associatedtype A  // expected-note {{protocol requires nested type 'A'; do you want to add it?}}
 
-  func boo() -> A // expected-note {{protocol requires function 'boo()' with type '() -> S31<T>.A' (aka '() -> Never'); do you want to add a stub?}}
+  func boo() -> A
 }
 struct S31<T> {}
 extension S31: P32 where T == Int {} // OK
@@ -556,11 +556,11 @@ extension S31 where T: Equatable {
 }
 extension S31: P33 where T == Never {} // expected-error {{type 'S31<T>' does not conform to protocol 'P33'}}
 extension S31 where T == String {
-  var baz: Bool { true } // expected-note {{candidate has non-matching type 'Bool' [with A = S31<T>.A]}}
+  var baz: Bool { true }
 }
 extension S31: P34 {} // expected-error {{type 'S31<T>' does not conform to protocol 'P34'}}
 extension S31 where T: P32 {
-  func boo() -> Void {} // expected-note {{candidate has non-matching type '<T> () -> Void' [with A = S31<T>.A]}}
+  func boo() -> Void {}
 }
 
 // SR-12707