[Diagnostics] Generalize the "protocol type cannot conform" error to

hborla · hborla · commit 40985b6eb7d8 · 2019-09-13T14:51:17.000-07:00
work for all types that cannot conform to protocols.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -1660,10 +1660,9 @@ ERROR(cannot_use_nil_with_this_type,none,
 ERROR(use_of_equal_instead_of_equality,none,
       "use of '=' in a boolean context, did you mean '=='?", ())
 
-
-ERROR(protocol_does_not_conform_objc,none,
-      "protocol type %0 cannot conform to %1 because only concrete "
-      "types can conform to protocols", (Type, Type))
+ERROR(type_cannot_conform, none,
+      "%0 type %1 cannot conform to %2; only struct/enum/class "
+      "types can conform to protocols", (StringRef, Type, Type))
 ERROR(protocol_does_not_conform_static,none,
       "%0 cannot be used as a type conforming to protocol %1 because %1 "
       "has static requirements",
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -570,13 +570,26 @@ bool MissingConformanceFailure::diagnoseAsError() {
     }
   }
 
-  if (nonConformingType->isExistentialType()) {
-    auto diagnostic = diag::protocol_does_not_conform_objc;
-    if (nonConformingType->isObjCExistentialType())
-      diagnostic = diag::protocol_does_not_conform_static;
+  if (nonConformingType->isObjCExistentialType()) {
+    emitDiagnostic(anchor->getLoc(), diag::protocol_does_not_conform_static,
+                   nonConformingType, protocolType);
+    return true;
+  }
 
-    emitDiagnostic(anchor->getLoc(), diagnostic, nonConformingType,
-                   protocolType);
+  // Diagnose types that cannot conform to protocols.
+  Optional<StringRef> prohibitedTypeKind = None;
+  if (nonConformingType->is<AnyFunctionType>())
+    prohibitedTypeKind = "function";
+  else if (nonConformingType->is<TupleType>())
+    prohibitedTypeKind = "tuple";
+  else if (nonConformingType->isExistentialType())
+    prohibitedTypeKind = "protocol";
+  else if (nonConformingType->is<AnyMetatypeType>())
+    prohibitedTypeKind = "metatype";
+
+  if (prohibitedTypeKind.hasValue()) {
+    emitDiagnostic(anchor->getLoc(), diag::type_cannot_conform,
+                   *prohibitedTypeKind, nonConformingType, protocolType);
     return true;
   }
 
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -3970,7 +3970,7 @@ static void diagnoseConformanceFailure(Type T,
       TypeChecker::containsProtocol(T, Proto, DC, None)) {
 
     if (!T->isObjCExistentialType()) {
-      diags.diagnose(ComplainLoc, diag::protocol_does_not_conform_objc,
+      diags.diagnose(ComplainLoc, diag::type_cannot_conform, "protocol",
                      T, Proto->getDeclaredType());
       return;
     }
diff --git a/test/Constraints/diagnostics.swift b/test/Constraints/diagnostics.swift
@@ -47,7 +47,7 @@ f0(i, i,
 
 
 // Position mismatch
-f5(f4)  // expected-error {{argument type '(Int) -> Int' does not conform to expected type 'P2'}}
+f5(f4)  // expected-error {{function type '(Int) -> Int' cannot conform to 'P2'; only struct/enum/class types can conform to protocols}}
 
 // Tuple element not convertible.
 f0(i,
@@ -97,7 +97,7 @@ func f8<T:P2>(_ n: T, _ f: @escaping (T) -> T) {}
 f8(3, f4) // expected-error {{argument type 'Int' does not conform to expected type 'P2'}}
 typealias Tup = (Int, Double)
 func f9(_ x: Tup) -> Tup { return x }
-f8((1,2.0), f9) // expected-error {{argument type 'Tup' (aka '(Int, Double)') does not conform to expected type 'P2'}}
+f8((1,2.0), f9) // expected-error {{tuple type 'Tup' (aka '(Int, Double)') cannot conform to 'P2'; only struct/enum/class types can conform to protocols}}
 
 // <rdar://problem/19658691> QoI: Incorrect diagnostic for calling nonexistent members on literals
 1.doesntExist(0)  // expected-error {{value of type 'Int' has no member 'doesntExist'}}
diff --git a/test/Constraints/function_builder_diags.swift b/test/Constraints/function_builder_diags.swift
@@ -144,7 +144,7 @@ struct TupleP<U> : P {
 
 @_functionBuilder
 struct Builder {
-  static func buildBlock<S0, S1>(_ stmt1: S0, _ stmt2: S1) // expected-note {{where 'S1' = 'Label<Any>.Type'}}
+  static func buildBlock<S0, S1>(_ stmt1: S0, _ stmt2: S1)
            -> TupleP<(S0, S1)> where S0: P, S1: P {
     return TupleP((stmt1, stmt2))
   }
@@ -166,7 +166,7 @@ struct Label<L> : P where L : P { // expected-note {{'L' declared as parameter t
 }
 
 func test_51167632() -> some P {
-  AnyP(G { // expected-error {{static method 'buildBlock' requires that 'Label<Any>.Type' conform to 'P'}}
+  AnyP(G { // expected-error {{metatype type 'Label<Any>.Type' cannot conform to 'P'; only struct/enum/class types can conform to protocols}}
     Text("hello")
     Label  // expected-error {{generic parameter 'L' could not be inferred}}
     // expected-note@-1 {{explicitly specify the generic arguments to fix this issue}} {{10-10=<<#L: P#>>}}
diff --git a/test/Constraints/generics.swift b/test/Constraints/generics.swift
@@ -191,7 +191,7 @@ func r22459135() {
 
 // <rdar://problem/19710848> QoI: Friendlier error message for "[] as Set"
 // <rdar://problem/22326930> QoI: "argument for generic parameter 'Element' could not be inferred" lacks context
-_ = [] as Set  // expected-error {{protocol type 'Any' cannot conform to 'Hashable' because only concrete types can conform to protocols}}
+_ = [] as Set  // expected-error {{protocol type 'Any' cannot conform to 'Hashable'; only struct/enum/class types can conform to protocols}}
 
 
 //<rdar://problem/22509125> QoI: Error when unable to infer generic archetype lacks greatness
diff --git a/test/Constraints/operator.swift b/test/Constraints/operator.swift
@@ -220,7 +220,7 @@ func rdar46459603() {
   // expected-error@-1 {{binary operator '==' cannot be applied to operands of type 'Dictionary<String, E>.Values' and '[E]'}}
   // expected-note@-2  {{expected an argument list of type '(Self, Self)'}}
   _ = [arr.values] == [[e]]
-  // expected-error@-1 {{protocol type 'Any' cannot conform to 'Equatable' because only concrete types can conform to protocols}}
+  // expected-error@-1 {{protocol type 'Any' cannot conform to 'Equatable'; only struct/enum/class types can conform to protocols}}
 }
 
 // SR-10843
diff --git a/test/Generics/conditional_conformances_literals.swift b/test/Generics/conditional_conformances_literals.swift
@@ -127,9 +127,9 @@ func combined() {
 
     // Needs self conforming protocols:
     let _: Conforms = [[0: [1 : [works]] as Conforms]]
-    // expected-error@-1 {{protocol type 'Conforms' cannot conform to 'Conforms' because only concrete types can conform to protocols}}
+    // expected-error@-1 {{protocol type 'Conforms' cannot conform to 'Conforms'; only struct/enum/class types can conform to protocols}}
 
     let _: Conforms = [[0: [1 : [fails]] as Conforms]]
     // expected-error@-1 {{protocol 'Conforms' requires that 'Fails' conform to 'Conforms'}}
-    // expected-error@-2 {{protocol type 'Conforms' cannot conform to 'Conforms' because only concrete types can conform to protocols}}
+    // expected-error@-2 {{protocol type 'Conforms' cannot conform to 'Conforms'; only struct/enum/class types can conform to protocols}}
 }
diff --git a/test/Generics/existential_restrictions.swift b/test/Generics/existential_restrictions.swift
@@ -17,7 +17,7 @@ func fAOE(_ t: AnyObject) { }
 func fT<T>(_ t: T) { }
 
 func testPassExistential(_ p: P, op: OP, opp: OP & P, cp: CP, sp: SP, any: Any, ao: AnyObject) {
-  fP(p) // expected-error{{protocol type 'P' cannot conform to 'P' because only concrete types can conform to protocols}}
+  fP(p) // expected-error{{protocol type 'P' cannot conform to 'P'; only struct/enum/class types can conform to protocols}}
   fAO(p) // expected-error{{cannot invoke 'fAO' with an argument list of type '(P)'}} // expected-note{{expected an argument list of type '(T)'}}
   fAOE(p) // expected-error{{argument type 'P' does not conform to expected type 'AnyObject'}}
   fT(p)
@@ -31,8 +31,8 @@ func testPassExistential(_ p: P, op: OP, opp: OP & P, cp: CP, sp: SP, any: Any,
   fAOE(cp)
   fT(cp)
 
-  fP(opp) // expected-error{{protocol type 'OP & P' cannot conform to 'P' because only concrete types can conform to protocols}}
-  fOP(opp) // expected-error{{protocol type 'OP & P' cannot conform to 'OP' because only concrete types can conform to protocols}}
+  fP(opp) // expected-error{{protocol type 'OP & P' cannot conform to 'P'; only struct/enum/class types can conform to protocols}}
+  fOP(opp) // expected-error{{protocol type 'OP & P' cannot conform to 'OP'; only struct/enum/class types can conform to protocols}}
   fAO(opp) // expected-error{{cannot invoke 'fAO' with an argument list of type '(OP & P)'}} // expected-note{{expected an argument list of type '(T)'}}
   fAOE(opp)
   fT(opp)
@@ -58,9 +58,9 @@ class GAO<T : AnyObject> {} // expected-note 2{{requirement specified as 'T' : '
 func blackHole(_ t: Any) {}
 
 func testBindExistential() {
-  blackHole(GP<P>()) // expected-error{{protocol type 'P' cannot conform to 'P' because only concrete types can conform to protocols}}
+  blackHole(GP<P>()) // expected-error{{protocol type 'P' cannot conform to 'P'; only struct/enum/class types can conform to protocols}}
   blackHole(GOP<OP>())
-  blackHole(GCP<CP>()) // expected-error{{protocol type 'CP' cannot conform to 'CP' because only concrete types can conform to protocols}}
+  blackHole(GCP<CP>()) // expected-error{{protocol type 'CP' cannot conform to 'CP'; only struct/enum/class types can conform to protocols}}
   blackHole(GAO<P>()) // expected-error{{'GAO' requires that 'P' be a class type}}
   blackHole(GAO<OP>())
   blackHole(GAO<CP>()) // expected-error{{'GAO' requires that 'CP' be a class type}}
@@ -85,5 +85,5 @@ func foo() {
   // generic no overloads error path. The error should actually talk
   // about the return type, and this can happen in other contexts as well;
   // <rdar://problem/21900971> tracks improving QoI here.
-  allMine.takeAll() // expected-error{{protocol type 'Mine' cannot conform to 'Mine' because only concrete types can conform to protocols}}
+  allMine.takeAll() // expected-error{{protocol type 'Mine' cannot conform to 'Mine'; only struct/enum/class types can conform to protocols}}
 }
diff --git a/test/decl/protocol/conforms/error_self_conformance.swift b/test/decl/protocol/conforms/error_self_conformance.swift
@@ -8,15 +8,15 @@ func testSimple(error: Error) {
 
 protocol ErrorRefinement : Error {}
 func testErrorRefinment(error: ErrorRefinement) {
-  wantsError(error) // expected-error {{protocol type 'ErrorRefinement' cannot conform to 'Error' because only concrete types can conform to protocols}}
+  wantsError(error) // expected-error {{protocol type 'ErrorRefinement' cannot conform to 'Error'; only struct/enum/class types can conform to protocols}}
 }
 
 protocol OtherProtocol {}
 func testErrorComposition(error: Error & OtherProtocol) {
-  wantsError(error) // expected-error {{protocol type 'Error & OtherProtocol' cannot conform to 'Error' because only concrete types can conform to protocols}}
+  wantsError(error) // expected-error {{protocol type 'Error & OtherProtocol' cannot conform to 'Error'; only struct/enum/class types can conform to protocols}}
 }
 
 class C {}
 func testErrorCompositionWithClass(error: Error & C) {
-  wantsError(error) // expected-error {{protocol type 'C & Error' cannot conform to 'Error' because only concrete types can conform to protocols}}
+  wantsError(error) // expected-error {{protocol type 'C & Error' cannot conform to 'Error'; only struct/enum/class types can conform to protocols}}
 }
diff --git a/test/stmt/foreach.swift b/test/stmt/foreach.swift
@@ -179,7 +179,7 @@ func testOptionalSequence() {
 
 // Crash with (invalid) for each over an existential
 func testExistentialSequence(s: Sequence) { // expected-error {{protocol 'Sequence' can only be used as a generic constraint because it has Self or associated type requirements}}
-  for x in s { // expected-error {{protocol type 'Sequence' cannot conform to 'Sequence' because only concrete types can conform to protocols}}
+  for x in s { // expected-error {{protocol type 'Sequence' cannot conform to 'Sequence'; only struct/enum/class types can conform to protocols}}
     _ = x
   }
 }
diff --git a/test/type/opaque.swift b/test/type/opaque.swift
@@ -377,8 +377,7 @@ protocol P_51641323 {
 func rdar_51641323() {
   struct Foo: P_51641323 {
     var foo: some P_51641323 { {} }
-    // expected-error@-1 {{return type of property 'foo' requires that '() -> ()' conform to 'P_51641323'}}
-    // expected-note@-2 {{opaque return type declared here}}
+    // expected-error@-1 {{function type '() -> ()' cannot conform to 'P_51641323'; only struct/enum/class types can conform to protocols}}
   }
 }
 
diff --git a/test/type/subclass_composition.swift b/test/type/subclass_composition.swift
@@ -412,7 +412,7 @@ func conformsTo<T1 : P2, T2 : Base<Int> & P2>(
   // expected-note@-2 {{expected an argument list of type '(T)'}}
 
   conformsToP1(p1)
-  // expected-error@-1 {{protocol type 'P1' cannot conform to 'P1' because only concrete types can conform to protocols}}
+  // expected-error@-1 {{protocol type 'P1' cannot conform to 'P1'; only struct/enum/class types can conform to protocols}}
 
   // FIXME: Following diagnostics are not great because when
   // `conformsTo*` methods are re-typechecked, they loose information
diff --git a/validation-test/Sema/type_checker_crashers_fixed/rdar27830834.swift b/validation-test/Sema/type_checker_crashers_fixed/rdar27830834.swift
@@ -1,4 +1,4 @@
 // RUN: %target-swift-frontend %s -typecheck -verify
 
 var d = [String:String]()
-_ = "\(d.map{ [$0 : $0] })" // expected-error {{generic struct 'Dictionary' requires that '(key: String, value: String)' conform to 'Hashable'}}
+_ = "\(d.map{ [$0 : $0] })" // expected-error {{tuple type '(key: String, value: String)' cannot conform to 'Hashable'; only struct/enum/class types can conform to protocols}}
diff --git a/validation-test/compiler_crashers_2_fixed/0196-rdar48937223.swift b/validation-test/compiler_crashers_2_fixed/0196-rdar48937223.swift
@@ -2,10 +2,10 @@
 
 protocol P {}
 
-func fn<T, U: P>(_ arg1: T, arg2: (T) -> U) {} // expected-note {{where 'U' = '()'}}
+func fn<T, U: P>(_ arg1: T, arg2: (T) -> U) {}
 
 func test(str: String) {
-  fn(str) { arg in // expected-error {{global function 'fn(_:arg2:)' requires that '()' conform to 'P'}}
+  fn(str) { arg in // expected-error {{tuple type '()' cannot conform to 'P'; only struct/enum/class types can conform to protocols}}
     <#FOO#> // expected-error {{editor placeholder in source file}}
   }
 }
diff --git a/validation-test/compiler_crashers_fixed/00017-llvm-foldingset-llvm-attributesetnode-nodeequals.swift b/validation-test/compiler_crashers_fixed/00017-llvm-foldingset-llvm-attributesetnode-nodeequals.swift
@@ -19,4 +19,4 @@ extension Bool : BooleanProtocol {
 }
 func f<T : BooleanProtocol>(_ b: T) {
 }
-f(true as BooleanProtocol) // expected-error {{protocol type 'BooleanProtocol' cannot conform to 'BooleanProtocol' because only concrete types can conform to protocols}}
+f(true as BooleanProtocol) // expected-error {{protocol type 'BooleanProtocol' cannot conform to 'BooleanProtocol'; only struct/enum/class types can conform to protocols}}

Original file line number	Diff line number	Diff line change
`@@ -3970,7 +3970,7 @@ static void diagnoseConformanceFailure(Type T,`
`3970`	`3970`	`TypeChecker::containsProtocol(T, Proto, DC, None)) {`
`3971`	`3971`
`3972`	`3972`	`if (!T->isObjCExistentialType()) {`
`3973`		`- diags.diagnose(ComplainLoc, diag::protocol_does_not_conform_objc,`
	`3973`	`+ diags.diagnose(ComplainLoc, diag::type_cannot_conform, "protocol",`
`3974`	`3974`	`T, Proto->getDeclaredType());`
`3975`	`3975`	`return;`
`3976`	`3976`	`}`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ func rdar46459603() {`
`220`	`220`	`// expected-error@-1 {{binary operator '==' cannot be applied to operands of type 'Dictionary<String, E>.Values' and '[E]'}}`
`221`	`221`	`// expected-note@-2 {{expected an argument list of type '(Self, Self)'}}`
`222`	`222`	`_ = [arr.values] == [[e]]`
`223`		`- // expected-error@-1 {{protocol type 'Any' cannot conform to 'Equatable' because only concrete types can conform to protocols}}`
	`223`	`+ // expected-error@-1 {{protocol type 'Any' cannot conform to 'Equatable'; only struct/enum/class types can conform to protocols}}`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`// SR-10843`
Original file line number	Diff line number	Diff line change
`@@ -8,15 +8,15 @@ func testSimple(error: Error) {`
`8`	`8`
`9`	`9`	`protocol ErrorRefinement : Error {}`
`10`	`10`	`func testErrorRefinment(error: ErrorRefinement) {`
`11`		`- wantsError(error) // expected-error {{protocol type 'ErrorRefinement' cannot conform to 'Error' because only concrete types can conform to protocols}}`
	`11`	`+ wantsError(error) // expected-error {{protocol type 'ErrorRefinement' cannot conform to 'Error'; only struct/enum/class types can conform to protocols}}`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`protocol OtherProtocol {}`
`15`	`15`	`func testErrorComposition(error: Error & OtherProtocol) {`
`16`		`- wantsError(error) // expected-error {{protocol type 'Error & OtherProtocol' cannot conform to 'Error' because only concrete types can conform to protocols}}`
	`16`	`+ wantsError(error) // expected-error {{protocol type 'Error & OtherProtocol' cannot conform to 'Error'; only struct/enum/class types can conform to protocols}}`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`class C {}`
`20`	`20`	`func testErrorCompositionWithClass(error: Error & C) {`
`21`		`- wantsError(error) // expected-error {{protocol type 'C & Error' cannot conform to 'Error' because only concrete types can conform to protocols}}`
	`21`	`+ wantsError(error) // expected-error {{protocol type 'C & Error' cannot conform to 'Error'; only struct/enum/class types can conform to protocols}}`
`22`	`22`	`}`