Recheck UnresolvedSpecializeExpr after type variables are gone.

Author: Greg Titus

lib/Sema/CSApply.cpp

@@ -3225,8 +3225,37 @@ namespace {
     }
 
     Expr *visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *expr) {
-      // Our specializations should have resolved the subexpr to the right type.
-      return expr->getSubExpr();
+      // Our specializations should have resolved the subexpr - recheck for
+      // validity.
+      auto subExpr = expr->getSubExpr();
+      while (1) {
+        if (auto apply = dyn_cast<ApplyExpr>(subExpr)) {
+          subExpr = apply->getFn();
+        } else if (auto ac = dyn_cast<AutoClosureExpr>(subExpr)) {
+          subExpr = ac->getSingleExpressionBody();
+        } else {
+          break;
+        }
+      }
+
+      if (auto tyExpr = dyn_cast<TypeExpr>(subExpr)) {
+        return subExpr;
+      }
+
+      auto diagnosis = diag::not_a_generic_definition;
+      if (auto declRef = dyn_cast<DeclRefExpr>(subExpr)) {
+        auto ty = declRef->getDecl()->getInterfaceType();
+        if (auto funTy = dyn_cast_or_null<AnyFunctionType>(ty)) {
+          if (!funTy->getOptGenericSignature().isNull()) {
+            diagnosis = diag::cannot_explicitly_specialize_generic_function;
+          }
+        }
+      }
+      auto &de = cs.getASTContext().Diags;
+      de.diagnose(subExpr->getLoc(), diagnosis);
+      de.diagnose(expr->getLAngleLoc(),
+                  diag::while_parsing_as_left_angle_bracket);
+      return nullptr;
     }
 
     Expr *visitMemberRefExpr(MemberRefExpr *expr) {

lib/Sema/CSDiagnostics.cpp

@@ -6602,6 +6602,7 @@ bool MissingGenericArgumentsFailure::diagnoseForAnchor(
 bool MissingGenericArgumentsFailure::diagnoseParameter(
     ASTNode anchor, GenericTypeParamType *GP) const {
   auto &solution = getSolution();
+  auto &CS = solution.getConstraintSystem();
   auto loc = ::getLoc(anchor);
 
   auto *locator = getLocator();
@@ -6621,6 +6622,10 @@ bool MissingGenericArgumentsFailure::diagnoseParameter(
     auto *NTD = castTo->getAnyNominal();
     emitDiagnosticAt(loc, diag::unbound_generic_parameter_cast, GP,
                      NTD ? NTD->getDeclaredType() : castTo);
+  } else if (auto *USE = dyn_cast_or_null<UnresolvedSpecializeExpr>(
+                 CS.getParentExpr(getAsExpr(anchor)))) {
+    emitDiagnosticAt(USE->getLoc(),
+                     diag::cannot_explicitly_specialize_generic_function);
   } else {
     emitDiagnosticAt(loc, diag::unbound_generic_parameter, GP);
   }

lib/Sema/CSGen.cpp

@@ -1945,14 +1945,12 @@ namespace {
       // We currently only support explicit specialization of generic types.
       // FIXME: We could support explicit function specialization.
       auto &de = CS.getASTContext().Diags;
-      if (baseTy->is<AnyFunctionType>()) {
-        de.diagnose(expr->getSubExpr()->getLoc(),
-                    diag::cannot_explicitly_specialize_generic_function);
-        de.diagnose(expr->getLAngleLoc(),
-                    diag::while_parsing_as_left_angle_bracket);
-        return Type();
+      if (auto funTy = dyn_cast<AnyFunctionType>(baseTy)) {
+        // Wait on diagnosis until after determining whether the func is
+        // generic or not
+        return baseTy;
       }
-      
+
       if (AnyMetatypeType *meta = baseTy->getAs<AnyMetatypeType>()) {
         auto *overloadLocator = CS.getConstraintLocator(expr->getSubExpr());
         if (addSpecializationConstraint(overloadLocator,

test/Constraints/ambiguous_specialized_name_diagnostics.swift

@@ -44,5 +44,5 @@ func test() {
 
   // FIXME(diagnostics): This should produce ambiguity diagnostic too
   S<Int>.staticFn()
-  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+  // expected-error@-1 {{cannot explicitly specialize a generic function}}
 }

test/Sema/generic-arg-list.swift

@@ -0,0 +1,43 @@
+// RUN: %target-typecheck-verify-swift
+
+extension Int {
+  func foo() -> Int {}
+  var bar: Int {
+    get {}
+  }
+
+  func baz() -> Int {}
+  func baz(_ x: Int = 0) -> Int {}
+
+  func gen<T>() -> T {} // expected-note {{in call to function 'gen()'}}
+}
+
+// https://github.com/swiftlang/swift/issues/74857
+func test(i: Int) {
+  let _ = i.foo<Int>() // expected-error {{cannot specialize a non-generic definition}}
+  // expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
+
+  let _ = i.gen<Int>() // expected-error {{cannot explicitly specialize a generic function}}
+
+  let _ = 0.foo<Int>() // expected-error {{cannot specialize a non-generic definition}}
+  // expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
+
+  // FIXME: These get parsed as postfix >, unless at the end of a block
+  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: ((), ()), (AnyIndex, AnyIndex), (Character, Character), (Int, Int), (Int16, Int16), (Int32, Int32), (Int64, Int64), (Int8, Int8), (Never, Never), (ObjectIdentifier, ObjectIdentifier), (String, String), (String.Index, String.Index), (UInt, UInt), (UInt16, UInt16), (UInt32, UInt32), (UInt64, UInt64), (UInt8, UInt8), (Unicode.CanonicalCombiningClass, Unicode.CanonicalCombiningClass), (Unicode.Scalar, Unicode.Scalar), (_ValidUTF8Buffer.Index, _ValidUTF8Buffer.Index)}}
+  let _ = i.baz<Int> // expected-error {{'>' is not a postfix unary operator}}
+  // 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 a non-generic definition}}
+  // expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
+}
+
+extension Bool {
+  func foo<T>() -> T {}
+}
+
+let _: () -> Bool = false.foo<Int> // expected-error {{cannot explicitly specialize a generic function}}
+// expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
+