Always add specialize constrain, add note if it fails

Author: Greg Titus

include/swift/AST/DiagnosticsSema.def

@@ -4628,8 +4628,6 @@ NOTE(duplicated_key_declared_here, none,
 // Generic specializations
 ERROR(cannot_explicitly_specialize_generic_function,none,
       "cannot explicitly specialize a generic function", ())
-ERROR(not_a_generic_definition,none,
-      "cannot specialize a non-generic definition", ())
 ERROR(not_a_generic_type,none,
       "cannot specialize non-generic type %0", (Type))
 ERROR(protocol_declares_unknown_primary_assoc_type,none,

lib/Sema/CSGen.cpp

@@ -1937,26 +1937,19 @@ namespace {
 
     Type visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *expr) {
       auto baseTy = CS.getType(expr->getSubExpr());
-      Type specializeTy = nullptr;
+      Type specializeTy = baseTy;
 
-      if (baseTy->isTypeVariableOrMember() || baseTy->is<AnyFunctionType>()) {
-        specializeTy = baseTy;
-      } else if (AnyMetatypeType *meta = baseTy->getAs<AnyMetatypeType>()) {
+      if (AnyMetatypeType *meta = baseTy->getAs<AnyMetatypeType>()) {
         specializeTy = meta->getInstanceType();
-      } else {
-        // FIXME: If the base type is a type variable, constrain it to a
-        // metatype of a bound generic type.
-        auto &de = CS.getASTContext().Diags;
-        de.diagnose(expr->getSubExpr()->getLoc(),
-                    diag::not_a_generic_definition);
-        de.diagnose(expr->getLAngleLoc(),
-                    diag::while_parsing_as_left_angle_bracket);
-        return Type();
       }
 
       auto *overloadLocator = CS.getConstraintLocator(expr->getSubExpr());
       if (addSpecializationConstraint(overloadLocator, specializeTy,
                                       expr->getUnresolvedParams())) {
+        // Diagnosis already happened, but add a bit of context
+        auto &de = CS.getASTContext().Diags;
+        de.diagnose(expr->getLAngleLoc(),
+                    diag::while_parsing_as_left_angle_bracket);
         return Type();
       }
 

test/Parse/enum_element_pattern_swift4.swift

@@ -9,10 +9,11 @@ enum E {
 
   static func testE(e: E) {
     switch e {
-    case A<UndefinedTy>(): // expected-error {{cannot specialize a non-generic definition}}
+    case A<UndefinedTy>(): // expected-error {{cannot find type 'UndefinedTy' in scope}}
     // expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
       break
-    case B<Int>(): // expected-error {{cannot specialize a non-generic definition}} expected-note {{while parsing this '<' as a type parameter bracket}}
+    case B<Int>(): // expected-error {{cannot specialize non-generic type 'E'}}
+    // expected-error@-1 {{cannot call value of non-function type 'E'}}
       break
     default:
       break;
@@ -22,10 +23,11 @@ enum E {
 
 func testE(e: E) {
   switch e {
-  case E.A<UndefinedTy>(): // expected-error {{cannot specialize a non-generic definition}}
+  case E.A<UndefinedTy>(): // expected-error {{cannot find type 'UndefinedTy' in scope}}
   // expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
     break
-  case E.B<Int>(): // expected-error {{cannot specialize a non-generic definition}} expected-note {{while parsing this '<' as a type parameter bracket}}
+  case E.B<Int>(): // expected-error {{cannot specialize non-generic type 'E'}}
+  // expected-error@-1 {{cannot call value of non-function type 'E'}}
     break
   case .C(): // expected-error {{pattern with associated values does not match enum case 'C'}}
              // expected-note@-1 {{remove associated values to make the pattern match}} {{10-12=}} 

test/Parse/generic_disambiguation.swift

@@ -26,10 +26,10 @@ var a, b, c, d : Int
 _ = a < b
 _ = (a < b, c > d)
 // Parses as generic because of lparen after '>'
-(a < b, c > (d)) // expected-error{{cannot specialize a non-generic definition}}
+(a < b, c > (d)) // expected-error{{cannot find type 'b' in scope}}
 // expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
 // Parses as generic because of lparen after '>'
-(a<b, c>(d)) // expected-error{{cannot specialize a non-generic definition}}
+(a<b, c>(d)) // expected-error{{cannot find type 'b' in scope}}
 // expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
 _ = a>(b)
 _ = a > (b)

test/Sema/generic-arg-list.swift

@@ -25,9 +25,7 @@ func test(i: Int) {
   let _ = i.gen<Int> // expected-error {{'>' is not a postfix unary operator}}
   // expected-error@-1 {{binary operator '<' cannot be applied to operands of type '() -> ()' and '()'}}
   // expected-note@-2 {{overloads for '<' exist with these partially matching parameter lists:}}
-  // expected-error@-1 {{function produces expected type 'Int'; did you mean to call it with '()'?}}
   let _ = i.bar<Int> // expected-error {{'>' is not a postfix unary operator}}
-
   let _ = 0.bar<Int> // expected-error {{cannot specialize non-generic type 'Int'}}
 }
 
@@ -37,3 +35,9 @@ extension Bool {
 
 let _: () -> Bool = false.foo<Int> // expected-error {{cannot explicitly specialize a generic function}}
 
+func foo(_ x: Int) {
+  _ = {
+    _ = x<String> // expected-error {{cannot specialize non-generic type 'Int'}}
+  }
+}
+