[TypeCheckAttr] Provide better error messages for a typeEraser that

has invalid init candidates.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -4426,6 +4426,10 @@ ERROR(type_eraser_missing_init,none,
 
 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",())
 
 //------------------------------------------------------------------------------
 // MARK: @available

lib/Sema/TypeCheckAttr.cpp

@@ -2418,10 +2418,17 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
   // 3. The type eraser must have an init of the form init<T: Protocol>(erasing: T)
   auto lookupResult = TypeChecker::lookupMember(dc, typeEraser,
                                                 DeclNameRef::createConstructor());
+
+  // Keep track of unviable init candidates for diagnostics
+  enum class UnviableReason {
+    Failable,
+    UnsatisfiedRequirements,
+  };
+  SmallVector<std::pair<ConstructorDecl *, UnviableReason>, 2> unviable;
+
   bool foundMatch = llvm::any_of(lookupResult, [&](const LookupResultEntry &entry) {
     auto *init = cast<ConstructorDecl>(entry.getValueDecl());
-    if (init->isFailable() || !init->isGeneric() ||
-        init->getGenericParams()->size() != 1)
+    if (!init->isGeneric() || init->getGenericParams()->size() != 1)
       return false;
 
     auto genericSignature = init->getGenericSignature();
@@ -2455,31 +2462,49 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
           return getSubstitution(type);
         }, TypeChecker::LookUpConformance(dc));
 
-    // Listener to suppress diagnostics while checking if the generic
-    // requirements are satisfied.
-    class Listener : public GenericRequirementsCheckListener {
-      bool diagnoseUnsatisfiedRequirement(
-          const Requirement &req, Type first, Type second,
-          ArrayRef<ParentConditionalConformance> parents) override {
-        return true;
-      }
-    } listener;
-
-    auto loc = attr->getLocation();
+    // Use invalid 'SourceLoc's to suppress diagnostics.
     auto result = TypeChecker::checkGenericArguments(
-          protocol, loc, loc, typeEraser,
+          protocol, SourceLoc(), SourceLoc(), typeEraser,
           genericSignature->getGenericParams(),
           genericSignature->getRequirements(),
           QuerySubstitutionMap{subMap},
           TypeChecker::LookUpConformance(dc),
-          None, &listener);
-    return result == RequirementCheckResult::Success;
+          None);
+
+    if (result != RequirementCheckResult::Success) {
+      unviable.push_back({init, UnviableReason::UnsatisfiedRequirements});
+      return false;
+    }
+
+    if (init->isFailable()) {
+      unviable.push_back({init, UnviableReason::Failable});
+      return false;
+    }
+
+    return true;
   });
 
   if (!foundMatch) {
     diags.diagnose(attr->getLocation(), diag::type_eraser_missing_init,
                    typeEraser, protocolType);
-    diags.diagnose(nominalTypeDecl->getLoc(), diag::type_eraser_declared_here);
+    if (unviable.empty())
+      diags.diagnose(nominalTypeDecl->getLoc(),
+                     diag::type_eraser_declared_here);
+
+    for (auto &candidate: unviable) {
+      auto init = candidate.first;
+      auto reason = candidate.second;
+
+      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);
+        break;
+      }
+    }
     return false;
   }
 

test/attr/typeEraser.swift

@@ -89,8 +89,14 @@ class NoLabel: D5 { // expected-note {{type eraser declared here}}
 @_typeEraser(NoLabel) // expected-error {{type eraser 'NoLabel' must have an initializer of the form 'init<T: 'D5'>(erasing: T)'}}
 protocol D5 {}
 
-class FailableInit: D6 { // expected-note {{type eraser declared here}}
-  init?<T: D6>(erasing t: T) {}
+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 {}