[TypeCheckAttr] Improve diagnostics and candidate notes for typeEraser in

the case where the type eraser has no viable initializers.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -4420,21 +4420,25 @@ ERROR(non_nominal_type_eraser,none,
       "type eraser must be a class, struct, or enum", ())
 ERROR(type_eraser_does_not_conform,none,
       "type eraser %0 must conform to protocol %1", (Type, Type))
-ERROR(type_eraser_missing_init,none,
-      "type eraser %0 must have an initializer of the form "
-      "'init<T: %1>(erasing: T)'", (Type, Type))
 ERROR(type_eraser_not_accessible,none,
       "%select{private|fileprivate|internal|public|open}0 type eraser %1 "
       "cannot have more restrictive access than protocol %2 "
       "(which is %select{private|fileprivate|internal|public|open}3)",
       (AccessLevel, Identifier, Type, AccessLevel))
+ERROR(type_eraser_missing_init,none,
+      "type eraser %0 must have an initializer of the form "
+      "'init<T: %1>(erasing: T)'", (Type, StringRef))
+ERROR(type_eraser_unviable_init,none,
+      "type eraser %0 has no viable initializer of the form "
+      "'init<T: %1>(erasing: T)'", (Type, StringRef))
 
 NOTE(type_eraser_declared_here,none,
      "type eraser declared here",())
 NOTE(type_eraser_failable_init,none,
      "'init(erasing:)' cannot be failable",())
 NOTE(type_eraser_init_unsatisfied_requirements,none,
-     "'init(erasing:)' has unsatisfied requirements",())
+     "'init(erasing:)' cannot have unsatisfied requirements "
+     "when %0 = 'some %1'", (Type, StringRef))
 NOTE(type_eraser_init_not_accessible,none,
      "%select{private|fileprivate|internal|public|open}0 'init(erasing:)' "
      "cannot have more restrictive access than protocol %1 "

lib/Sema/TypeCheckAttr.cpp

@@ -2434,7 +2434,7 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
     UnsatisfiedRequirements,
     Inaccessible,
   };
-  SmallVector<std::pair<ConstructorDecl *, UnviableReason>, 2> unviable;
+  SmallVector<std::tuple<ConstructorDecl *, UnviableReason, Type>, 2> unviable;
 
   bool foundMatch = llvm::any_of(lookupResult, [&](const LookupResultEntry &entry) {
     auto *init = cast<ConstructorDecl>(entry.getValueDecl());
@@ -2482,41 +2482,50 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
           None);
 
     if (result != RequirementCheckResult::Success) {
-      unviable.push_back({init, UnviableReason::UnsatisfiedRequirements});
+      unviable.push_back(
+          std::make_tuple(init, UnviableReason::UnsatisfiedRequirements,
+                          genericParamType));
       return false;
     }
 
     if (init->isFailable()) {
-      unviable.push_back({init, UnviableReason::Failable});
+      unviable.push_back(
+          std::make_tuple(init, UnviableReason::Failable, genericParamType));
       return false;
     }
 
     if (init->getFormalAccess() < protocol->getFormalAccess()) {
-      unviable.push_back({init, UnviableReason::Inaccessible});
+      unviable.push_back(
+          std::make_tuple(init, UnviableReason::Inaccessible, genericParamType));
       return false;
     }
 
     return true;
   });
 
   if (!foundMatch) {
-    diags.diagnose(attr->getLocation(), diag::type_eraser_missing_init,
-                   typeEraser, protocolType);
-    if (unviable.empty())
-      diags.diagnose(nominalTypeDecl->getLoc(),
-                     diag::type_eraser_declared_here);
+    if (unviable.empty()) {
+      diags.diagnose(attr->getLocation(), diag::type_eraser_missing_init,
+                     typeEraser, protocol->getName().str());
+      diags.diagnose(nominalTypeDecl->getLoc(), diag::type_eraser_declared_here);
+      return false;
+    }
 
+    diags.diagnose(attr->getLocation(), diag::type_eraser_unviable_init,
+                   typeEraser, protocol->getName().str());
     for (auto &candidate: unviable) {
-      auto init = candidate.first;
-      auto reason = candidate.second;
+      auto init = std::get<0>(candidate);
+      auto reason = std::get<1>(candidate);
+      auto genericParamType = std::get<2>(candidate);
 
       switch (reason) {
       case UnviableReason::Failable:
         diags.diagnose(init->getLoc(), diag::type_eraser_failable_init);
         break;
       case UnviableReason::UnsatisfiedRequirements:
         diags.diagnose(init->getLoc(),
-                       diag::type_eraser_init_unsatisfied_requirements);
+                       diag::type_eraser_init_unsatisfied_requirements,
+                       genericParamType, protocol->getName().str());
         break;
       case UnviableReason::Inaccessible:
         diags.diagnose(init->getLoc(), diag::type_eraser_init_not_accessible,

test/attr/typeEraser.swift

@@ -53,6 +53,12 @@ protocol B4 {}
 @_typeEraser(Generic<Int>) // bound generic is okay
 protocol B5 {}
 
+class MoreRestrictive: B6 { // expected-note {{type eraser declared here}}
+  init<T: B6>(erasing t: T) {}
+}
+@_typeEraser(MoreRestrictive) // expected-error {{internal type eraser 'MoreRestrictive' cannot have more restrictive access than protocol 'B6' (which is public)}}
+public protocol B6 {}
+
 // MARK: - Type eraser must conform to the annotated protocol
 
 class DoesNotConform {} // expected-note {{type eraser declared here}}
@@ -62,55 +68,44 @@ protocol C1 {}
 // MARK: - Type eraser must have an initializer in the form init<T>(erasing: T) with T constrained to annotated protocol
 
 class NoArgInit: D1 {} // expected-note {{type eraser declared here}}
-@_typeEraser(NoArgInit) // expected-error {{type eraser 'NoArgInit' must have an initializer of the form 'init<T: 'D1'>(erasing: T)'}}
+@_typeEraser(NoArgInit) // expected-error {{type eraser 'NoArgInit' must have an initializer of the form 'init<T: D1>(erasing: T)'}}
 protocol D1 {}
 
 class InvalidArgInit: D2 { // expected-note {{type eraser declared here}}
   init<T>(erasing t: T) {}
 }
-@_typeEraser(InvalidArgInit) // expected-error {{type eraser 'InvalidArgInit' must have an initializer of the form 'init<T: 'D2'>(erasing: T)'}}
+@_typeEraser(InvalidArgInit) // expected-error {{type eraser 'InvalidArgInit' must have an initializer of the form 'init<T: D2>(erasing: T)'}}
 protocol D2 {}
 
 class ExtraArgInit: D3 { // expected-note {{type eraser declared here}}
   init<T: D3>(erasing t: T, extraArg: Int) {}
 }
-@_typeEraser(ExtraArgInit) // expected-error {{type eraser 'ExtraArgInit' must have an initializer of the form 'init<T: 'D3'>(erasing: T)'}}
+@_typeEraser(ExtraArgInit) // expected-error {{type eraser 'ExtraArgInit' must have an initializer of the form 'init<T: D3>(erasing: T)'}}
 protocol D3 {}
 
 class WrongLabelInit: D4 { // expected-note {{type eraser declared here}}
   init<T: D4>(wrongLabel: T) {}
 }
-@_typeEraser(WrongLabelInit) // expected-error {{type eraser 'WrongLabelInit' must have an initializer of the form 'init<T: 'D4'>(erasing: T)'}}
+@_typeEraser(WrongLabelInit) // expected-error {{type eraser 'WrongLabelInit' must have an initializer of the form 'init<T: D4>(erasing: T)'}}
 protocol D4 {}
 
 class NoLabel: D5 { // expected-note {{type eraser declared here}}
   init<T: D5>(_ t: T) {}
 }
-@_typeEraser(NoLabel) // expected-error {{type eraser 'NoLabel' must have an initializer of the form 'init<T: 'D5'>(erasing: T)'}}
+@_typeEraser(NoLabel) // expected-error {{type eraser 'NoLabel' must have an initializer of the form 'init<T: D5>(erasing: T)'}}
 protocol D5 {}
 
-class FailableInit: D6 {
-  init?<T: D6>(erasing t: T) {} // expected-note {{'init(erasing:)' cannot be failable}}
-}
-@_typeEraser(FailableInit) // expected-error {{type eraser 'FailableInit' must have an initializer of the form 'init<T: 'D6'>(erasing: T)'}}
-protocol D6 {}
-
-class UnsatisfiedReq: D7 {
-  init<T: D7>(erasing t: T) where T: Hashable {} // expected-note {{'init(erasing:)' has unsatisfied requirements}}
-}
-@_typeEraser(UnsatisfiedReq) // expected-error {{type eraser 'UnsatisfiedReq' must have an initializer of the form 'init<T: 'D7'>(erasing: T)'}}
-protocol D7 {}
-
-// MARK: - Type eraser and initializer cannot be more restrictive than the annotated protocol
+// MARK: - Unviable initializers
 
-class MoreRestrictive: E1 { // expected-note {{type eraser declared here}}
-  init<T: E1>(erasing t: T) {}
+public class UnviableInits: E1 {
+  public init<T: E1>(erasing t: T) where T: Hashable {} // expected-note {{'init(erasing:)' cannot have unsatisfied requirements when 'T' = 'some E1'}}
+  init<T: E1>(erasing t: T) {} // expected-note {{internal 'init(erasing:)' cannot have more restrictive access than protocol 'E1' (which is public)}}
 }
-@_typeEraser(MoreRestrictive) // expected-error {{internal type eraser 'MoreRestrictive' cannot have more restrictive access than protocol 'E1' (which is public)}}
+@_typeEraser(UnviableInits) // expected-error {{type eraser 'UnviableInits' has no viable initializer of the form 'init<T: E1>(erasing: T)'}}
 public protocol E1 {}
 
-public class MoreRestrictiveInit: E2 {
-  init<T: E2>(erasing t: T) {} // expected-note {{internal 'init(erasing:)' cannot have more restrictive access than protocol 'E2' (which is public)}}
+class FailableInit: E2 {
+  init?<T: E2>(erasing t: T) {} // expected-note {{'init(erasing:)' cannot be failable}}
 }
-@_typeEraser(MoreRestrictiveInit) // expected-error {{type eraser 'MoreRestrictiveInit' must have an initializer of the form 'init<T: 'E2'>(erasing: T)'}}
-public protocol E2 {}
+@_typeEraser(FailableInit) // expected-error {{type eraser 'FailableInit' has no viable initializer of the form 'init<T: E2>(erasing: T)'}}
+protocol E2 {}