Merge pull request #39937 from hborla/opaque-type-fixit

[Diagnostics] Add a fix-it to insert 'some' when associated type inference failed because existential types can't conform to protocols.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -2263,6 +2263,11 @@ NOTE(associated_type_witness_conform_impossible,none,
      "candidate can not infer %0 = %1 because %1 "
      "is not a nominal type and so can't conform to %2",
      (Identifier, Type, Type))
+NOTE(suggest_opaque_type_witness,none,
+     "cannot infer %0 = %1 because %1 as a type cannot "
+     "conform to protocols; did you mean to use an opaque "
+     "result type?",
+     (Identifier, Type, Type))
 NOTE(associated_type_witness_inherit_impossible,none,
      "candidate can not infer %0 = %1 because %1 "
      "is not a class type and so can't inherit from %2",

lib/Sema/TypeCheckProtocolInference.cpp

@@ -1776,6 +1776,34 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
           if ((!failed.TypeWitness->getAnyNominal() ||
                failed.TypeWitness->isExistentialType()) &&
               failed.Result.isConformanceRequirement()) {
+            Type resultType;
+            SourceRange typeRange;
+            if (auto *var = dyn_cast<VarDecl>(failed.Witness)) {
+              resultType = var->getValueInterfaceType();
+              typeRange = var->getTypeSourceRangeForDiagnostics();
+            } else if (auto *func = dyn_cast<FuncDecl>(failed.Witness)) {
+              resultType = func->getResultInterfaceType();
+              typeRange = func->getResultTypeSourceRange();
+            } else if (auto *subscript = dyn_cast<SubscriptDecl>(failed.Witness)) {
+              resultType = subscript->getElementInterfaceType();
+              typeRange = subscript->getElementTypeSourceRange();
+            }
+
+            // If the type witness was inferred from an existential
+            // result type, suggest an opaque result type instead,
+            // which can conform to protocols.
+            if (failed.TypeWitness->isExistentialType() &&
+                resultType && resultType->isEqual(failed.TypeWitness) &&
+                typeRange.isValid()) {
+              diags.diagnose(typeRange.Start,
+                             diag::suggest_opaque_type_witness,
+                             assocType->getName(), failed.TypeWitness,
+                             failed.Result.getRequirement())
+                .highlight(typeRange)
+                .fixItInsert(typeRange.Start, "some ");
+              continue;
+            }
+
             diags.diagnose(failed.Witness,
                            diag::associated_type_witness_conform_impossible,
                            assocType->getName(), failed.TypeWitness,

test/decl/protocol/req/missing_conformance.swift

@@ -107,7 +107,25 @@ protocol P12 {
 extension Int : P11 {}
 struct S3 : P12 { // expected-error {{type 'S3' does not conform to protocol 'P12'}}
     func bar() -> P11 { return 0 }
-    // expected-note@-1 {{candidate can not infer 'A' = 'P11' because 'P11' is not a nominal type and so can't conform to 'P11'}}
+    // expected-note@-1 {{cannot infer 'A' = 'P11' because 'P11' as a type cannot conform to protocols; did you mean to use an opaque result type?}}{{19-19=some }}
+}
+
+protocol P13 {
+  associatedtype A : P11 // expected-note {{unable to infer associated type 'A' for protocol 'P13'}}
+  var bar: A { get }
+}
+struct S4: P13 { // expected-error {{type 'S4' does not conform to protocol 'P13'}}
+  var bar: P11 { return 0 }
+  // expected-note@-1 {{cannot infer 'A' = 'P11' because 'P11' as a type cannot conform to protocols; did you mean to use an opaque result type?}}{{12-12=some }}
+}
+
+protocol P14 {
+  associatedtype A : P11 // expected-note {{unable to infer associated type 'A' for protocol 'P14'}}
+  subscript(i: Int) -> A { get }
+}
+struct S5: P14 { // expected-error {{type 'S5' does not conform to protocol 'P14'}}
+  subscript(i: Int) -> P11 { return i }
+  // expected-note@-1 {{cannot infer 'A' = 'P11' because 'P11' as a type cannot conform to protocols; did you mean to use an opaque result type?}}{{24-24=some }}
 }
 
 // SR-12759