Modified diagnostics a bit given feedback

Author: gregomni

include/swift/AST/DiagnosticsSema.def

@@ -1782,9 +1782,18 @@ NOTE(bad_associated_type_deduction,none,
      "unable to infer associated type %0 for protocol %1",
      (DeclName, DeclName))
 NOTE(associated_type_deduction_witness_failed,none,
-     "candidate would match and infer %0=%1 if %1 "
+     "candidate would match and infer %0 = %1 if %1 "
      "%select{inherited from|conformed to}3 %2",
      (DeclName, Type, Type, bool))
+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",
+     (DeclName, 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",
+     (DeclName, Type, Type))
+
 NOTE(ambiguous_associated_type_deduction,none,
      "ambiguous inference of associated type %0: %1 vs. %2",
      (DeclName, Type, Type))

lib/Sema/TypeCheckProtocol.cpp

@@ -861,8 +861,8 @@ swift::matchWitness(TypeChecker &tc,
             return RequirementMatch(witness, MatchKind::MissingConformance,
                                     assocType, protocolType);
       if (type->isEqual(conformance->getType())) {
-        if (auto bgt = type->getAs<BoundGenericType>())
-          type = bgt->getDecl()->getDeclaredType();
+        if (auto agt = type->getAs<AnyGenericType>())
+          type = agt->getDecl()->getDeclaredInterfaceType();
         return RequirementMatch(witness, MatchKind::MissingConformance, type,
                                 protocolType);
       }

lib/Sema/TypeCheckProtocolInference.cpp

@@ -1747,6 +1747,23 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
           if (failed.Result.isError())
             continue;
 
+          if (!failed.TypeWitness->is<NominalType>() &&
+              failed.Result.isConformanceRequirement()) {
+            diags.diagnose(failed.Witness,
+                           diag::associated_type_witness_conform_impossible,
+                           assocType->getName(), failed.TypeWitness,
+                           failed.Result.getRequirement());
+            continue;
+          }
+          if (!failed.TypeWitness->is<ClassType>() &&
+              !failed.Result.isConformanceRequirement()) {
+            diags.diagnose(failed.Witness,
+                           diag::associated_type_witness_inherit_impossible,
+                           assocType->getName(), failed.TypeWitness,
+                           failed.Result.getRequirement());
+            continue;
+          }
+
           diags.diagnose(failed.Witness,
                          diag::associated_type_deduction_witness_failed,
                          assocType->getName(),

test/Generics/associated_types_inherit.swift

@@ -19,7 +19,7 @@ struct X1 : P {
 }
 
 struct X2 : P { // expected-error{{type 'X2' does not conform to protocol 'P'}}
-  func getAssoc() -> E { return E() } // expected-note{{candidate would match and infer 'Assoc'='E' if 'E' inherited from 'C'}}
+  func getAssoc() -> E { return E() } // expected-note{{candidate would match and infer 'Assoc' = 'E' if 'E' inherited from 'C'}}
 }
 
 func testP<T:P>(_ t: T) {

test/decl/protocol/req/associated_type_inference.swift

@@ -50,8 +50,8 @@ struct X0f : P0 { // okay: Assoc1 = Int because Float doesn't conform to PSimple
 }
 
 struct X0g : P0 { // expected-error{{type 'X0g' does not conform to protocol 'P0'}}
-  func f0(_: Float) { } // expected-note{{candidate would match and infer 'Assoc1'='Float' if 'Float' conformed to 'PSimple'}}
-  func g0(_: Float) { } // expected-note{{candidate would match and infer 'Assoc1'='Float' if 'Float' conformed to 'PSimple'}}
+  func f0(_: Float) { } // expected-note{{candidate would match and infer 'Assoc1' = 'Float' if 'Float' conformed to 'PSimple'}}
+  func g0(_: Float) { } // expected-note{{candidate would match and infer 'Assoc1' = 'Float' if 'Float' conformed to 'PSimple'}}
 }
 
 struct X0h<T : PSimple> : P0 {
@@ -93,8 +93,8 @@ protocol P2 {
 }
 
 extension P2 where Self.P2Assoc : PSimple {
-  func f0(_ x: P2Assoc) { } // expected-note{{candidate would match and infer 'Assoc1'='Float' if 'Float' conformed to 'PSimple'}}
-  func g0(_ x: P2Assoc) { } // expected-note{{candidate would match and infer 'Assoc1'='Float' if 'Float' conformed to 'PSimple'}}
+  func f0(_ x: P2Assoc) { } // expected-note{{candidate would match and infer 'Assoc1' = 'Float' if 'Float' conformed to 'PSimple'}}
+  func g0(_ x: P2Assoc) { } // expected-note{{candidate would match and infer 'Assoc1' = 'Float' if 'Float' conformed to 'PSimple'}}
 }
 
 struct X0k : P0, P2 {
@@ -123,7 +123,7 @@ struct XProp0a : PropertyP0 { // okay PropType = Int
 }
 
 struct XProp0b : PropertyP0 { // expected-error{{type 'XProp0b' does not conform to protocol 'PropertyP0'}}
-  var property: Float // expected-note{{candidate would match and infer 'Prop'='Float' if 'Float' conformed to 'PSimple'}}
+  var property: Float // expected-note{{candidate would match and infer 'Prop' = 'Float' if 'Float' conformed to 'PSimple'}}
 }
 
 // Inference from subscripts
@@ -144,7 +144,7 @@ struct XSubP0a : SubscriptP0 {
 
 struct XSubP0b : SubscriptP0 {
 // expected-error@-1{{type 'XSubP0b' does not conform to protocol 'SubscriptP0'}}
-  subscript (i: Int) -> Float { get { return Float(i) } } // expected-note{{candidate would match and infer 'Element'='Float' if 'Float' conformed to 'PSimple'}}
+  subscript (i: Int) -> Float { get { return Float(i) } } // expected-note{{candidate would match and infer 'Element' = 'Float' if 'Float' conformed to 'PSimple'}}
 }
 
 struct XSubP0c : SubscriptP0 {

test/decl/protocol/req/func.swift

@@ -266,7 +266,7 @@ protocol P12 {
 struct XIndexType : P11 { }
 
 struct X12 : P12 { // expected-error{{type 'X12' does not conform to protocol 'P12'}}
-  func getIndex() -> XIndexType { return XIndexType() } // expected-note{{candidate would match and infer 'Index'='XIndexType' if 'XIndexType' conformed to 'P1'}}
+  func getIndex() -> XIndexType { return XIndexType() } // expected-note{{candidate would match and infer 'Index' = 'XIndexType' if 'XIndexType' conformed to 'P1'}}
 }
 
 func ==(x: X12.Index, y: X12.Index) -> Bool { return true }

test/decl/protocol/req/missing_conformance.swift

@@ -24,7 +24,7 @@ protocol LikeSequence {
     func makeIter() -> Iter
 }
 extension LikeSequence where Self == Self.Iter {
-    func makeIter() -> Self { return self } // expected-note {{candidate would match and infer 'Iter'='Y' if 'Y' conformed to 'IterProtocol'}}
+    func makeIter() -> Self { return self } // expected-note {{candidate would match and infer 'Iter' = 'Y' if 'Y' conformed to 'IterProtocol'}}
 }
 
 struct Y : LikeSequence {} // expected-error {{type 'Y' does not conform to protocol 'LikeSequence'}}
@@ -42,16 +42,41 @@ extension P1 where Result : P2 {
 }
 protocol P3 {}
 extension P1 where Self : P3 {
-    func got() {} // expected-note {{candidate would match if 'Z' conformed to 'P3'}}
+    func got() {} // expected-note {{candidate would match if 'Z<T1, T2, T3, Result, T4>' conformed to 'P3'}}
 }
 
 struct Z<T1, T2, T3, Result, T4> : P1 {} // expected-error {{type 'Z<T1, T2, T3, Result, T4>' does not conform to protocol 'P1'}}
 
 protocol P4 {
-    func this() // expected-note {{protocol requires function 'this()' with type '() -> ()'; do you want to add a stub?}}
+    func this() // expected-note 2 {{protocol requires function 'this()' with type '() -> ()'; do you want to add a stub?}}
 }
 protocol P5 {}
 extension P4 where Self : P5 {
     func this() {} // expected-note {{candidate would match if 'W' conformed to 'P5'}}
+    //// expected-note@-1 {{candidate would match if 'S<T>.SS' conformed to 'P5'}}
 }
 struct W : P4 {} // expected-error {{type 'W' does not conform to protocol 'P4'}}
+
+struct S<T> {
+    struct SS : P4 {} // expected-error {{type 'S<T>.SS' does not conform to protocol 'P4'}}
+}
+
+class C {}
+protocol P6 {
+    associatedtype T : C // expected-note {{unable to infer associated type 'T' for protocol 'P6'}}
+    func f(t: T)
+}
+
+struct A : P6 { // expected-error {{type 'A' does not conform to protocol 'P6'}}
+    func f(t: Int) {} // expected-note {{candidate can not infer 'T' = 'Int' because 'Int' is not a class type and so can't inherit from 'C'}}
+}
+
+protocol P7 {}
+protocol P8 {
+    associatedtype T : P7 // expected-note {{unable to infer associated type 'T' for protocol 'P8'}}
+    func g(t: T)
+}
+
+struct B : P8 { // expected-error {{type 'B' does not conform to protocol 'P8'}}
+    func g(t: (Int, String)) {} // expected-note {{candidate can not infer 'T' = '(Int, String)' because '(Int, String)' is not a nominal type and so can't conform to 'P7'}}
+}

test/stmt/foreach.swift

@@ -17,7 +17,7 @@ func bad_containers_2(bc: BadContainer2) {
 }
 
 struct BadContainer3 : Sequence { // expected-error{{type 'BadContainer3' does not conform to protocol 'Sequence'}}
-  func makeIterator() { } // expected-note{{candidate would match and infer 'Iterator'='()' if '()' conformed to 'IteratorProtocol'}}
+  func makeIterator() { } // expected-note{{candidate can not infer 'Iterator' = '()' because '()' is not a nominal type and so can't conform to 'IteratorProtocol'}}
 }
 
 func bad_containers_3(bc: BadContainer3) {