Add specialization constraints for func types and variables and diagnose with fixes.

Author: Greg Titus

include/swift/Sema/CSFix.h

@@ -459,7 +459,7 @@ enum class FixKind : uint8_t {
   /// because its name doesn't appear in 'initializes' or 'accesses' attributes.
   AllowInvalidMemberReferenceInInitAccessor,
 
-  /// Ignore an attempt to specialize non-generic type.
+  /// Ignore an attempt to specialize a generic function or non-generic type.
   AllowConcreteTypeSpecialization,
 
   /// Ignore an out-of-place \c then statement.
@@ -3688,11 +3688,12 @@ class AllowInvalidMemberReferenceInInitAccessor final : public ConstraintFix {
 
 class AllowConcreteTypeSpecialization final : public ConstraintFix {
   Type ConcreteType;
+  ValueDecl *Decl;
 
   AllowConcreteTypeSpecialization(ConstraintSystem &cs, Type concreteTy,
-                                  ConstraintLocator *locator)
+                                  ValueDecl *decl, ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::AllowConcreteTypeSpecialization, locator),
-        ConcreteType(concreteTy) {}
+        ConcreteType(concreteTy), Decl(decl) {}
 
 public:
   std::string getName() const override {
@@ -3705,8 +3706,10 @@ class AllowConcreteTypeSpecialization final : public ConstraintFix {
     return diagnose(*commonFixes.front().first);
   }
 
-  static AllowConcreteTypeSpecialization *
-  create(ConstraintSystem &cs, Type concreteTy, ConstraintLocator *locator);
+  static AllowConcreteTypeSpecialization *create(ConstraintSystem &cs,
+                                                 Type concreteTy,
+                                                 ValueDecl *decl,
+                                                 ConstraintLocator *locator);
 
   static bool classof(const ConstraintFix *fix) {
     return fix->getKind() == FixKind::AllowConcreteTypeSpecialization;

lib/Sema/CSApply.cpp

@@ -3225,7 +3225,6 @@ namespace {
     }
 
     Expr *visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *expr) {
-      // Our specializations should have resolved the subexpr to the right type.
       return expr->getSubExpr();
     }
 

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();
@@ -9338,6 +9339,13 @@ bool InvalidMemberReferenceWithinInitAccessor::diagnoseAsError() {
 }
 
 bool ConcreteTypeSpecialization::diagnoseAsError() {
+  if (isa<AbstractFunctionDecl>(Decl)) {
+    auto genericContext = Decl->getAsGenericContext();
+    if (genericContext && genericContext->getGenericParams()) {
+      emitDiagnostic(diag::cannot_explicitly_specialize_generic_function);
+      return true;
+    }
+  }
   emitDiagnostic(diag::not_a_generic_type, ConcreteType);
   return true;
 }

lib/Sema/CSDiagnostics.h

@@ -3111,12 +3111,13 @@ class InvalidMemberReferenceWithinInitAccessor final
 /// \endcode
 class ConcreteTypeSpecialization final : public FailureDiagnostic {
   Type ConcreteType;
+  ValueDecl *Decl;
 
 public:
   ConcreteTypeSpecialization(const Solution &solution, Type concreteTy,
-                             ConstraintLocator *locator)
+                             ValueDecl *decl, ConstraintLocator *locator)
       : FailureDiagnostic(solution, locator),
-        ConcreteType(resolveType(concreteTy)) {}
+        ConcreteType(resolveType(concreteTy)), Decl(decl) {}
 
   bool diagnoseAsError() override;
 };

lib/Sema/CSFix.cpp

@@ -2593,15 +2593,17 @@ AllowInvalidMemberReferenceInInitAccessor::create(ConstraintSystem &cs,
 
 bool AllowConcreteTypeSpecialization::diagnose(const Solution &solution,
                                                bool asNote) const {
-  ConcreteTypeSpecialization failure(solution, ConcreteType, getLocator());
+  ConcreteTypeSpecialization failure(solution, ConcreteType, Decl,
+                                     getLocator());
   return failure.diagnose(asNote);
 }
 
 AllowConcreteTypeSpecialization *
 AllowConcreteTypeSpecialization::create(ConstraintSystem &cs, Type concreteTy,
+                                        ValueDecl *decl,
                                         ConstraintLocator *locator) {
   return new (cs.getAllocator())
-      AllowConcreteTypeSpecialization(cs, concreteTy, locator);
+      AllowConcreteTypeSpecialization(cs, concreteTy, decl, locator);
 }
 
 bool IgnoreOutOfPlaceThenStmt::diagnose(const Solution &solution,

lib/Sema/CSGen.cpp

@@ -1937,40 +1937,30 @@ namespace {
 
     Type visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *expr) {
       auto baseTy = CS.getType(expr->getSubExpr());
+      Type specializeTy = nullptr;
 
-      if (baseTy->isTypeVariableOrMember()) {
-        return baseTy;
-      }
-
-      // 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>()) {
+      if (baseTy->isTypeVariableOrMember() || baseTy->is<AnyFunctionType>()) {
+        specializeTy = baseTy;
+      } else 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::cannot_explicitly_specialize_generic_function);
+                    diag::not_a_generic_definition);
         de.diagnose(expr->getLAngleLoc(),
                     diag::while_parsing_as_left_angle_bracket);
         return Type();
       }
-      
-      if (AnyMetatypeType *meta = baseTy->getAs<AnyMetatypeType>()) {
-        auto *overloadLocator = CS.getConstraintLocator(expr->getSubExpr());
-        if (addSpecializationConstraint(overloadLocator,
-                                        meta->getInstanceType(),
-                                        expr->getUnresolvedParams())) {
-          return Type();
-        }
 
-        return baseTy;
+      auto *overloadLocator = CS.getConstraintLocator(expr->getSubExpr());
+      if (addSpecializationConstraint(overloadLocator, specializeTy,
+                                      expr->getUnresolvedParams())) {
+        return Type();
       }
 
-      // FIXME: If the base type is a type variable, constrain it to a metatype
-      // of a bound generic type.
-      de.diagnose(expr->getSubExpr()->getLoc(),
-                  diag::not_a_generic_definition);
-      de.diagnose(expr->getLAngleLoc(),
-                  diag::while_parsing_as_left_angle_bracket);
-      return Type();
+      return baseTy;
     }
 
     Type visitSequenceExpr(SequenceExpr *expr) {

lib/Sema/CSSimplify.cpp

@@ -13926,6 +13926,8 @@ ConstraintSystem::simplifyExplicitGenericArgumentsConstraint(
 
   // Bail out if we haven't selected an overload yet.
   auto simplifiedBoundType = simplifyType(type1, flags);
+  if (simplifiedBoundType->isPlaceholder())
+    return SolutionKind::Solved;
   if (simplifiedBoundType->isTypeVariableOrMember())
     return formUnsolved();
 
@@ -14018,13 +14020,12 @@ ConstraintSystem::simplifyExplicitGenericArgumentsConstraint(
     }
   }
 
-  if (!decl->getAsGenericContext())
-    return SolutionKind::Error;
-
   auto genericParams = getGenericParams(decl);
-  if (!genericParams) {
-    // FIXME: Record an error here that we're ignoring the parameters.
-    return SolutionKind::Solved;
+  if (!decl->getAsGenericContext() || !genericParams) {
+    return recordFix(AllowConcreteTypeSpecialization::create(
+               *this, type1, decl, getConstraintLocator(locator)))
+               ? SolutionKind::Error
+               : SolutionKind::Solved;
   }
 
   // Map the generic parameters we have over to their opened types.
@@ -14057,12 +14058,14 @@ ConstraintSystem::simplifyExplicitGenericArgumentsConstraint(
     }
   }
 
-  if (openedGenericParams.empty()) {
+  // FIXME: We could support explicit function specialization.
+  if (openedGenericParams.empty() ||
+      (isa<AbstractFunctionDecl>(decl) && !hasParameterPack)) {
     if (!shouldAttemptFixes())
       return SolutionKind::Error;
 
     return recordFix(AllowConcreteTypeSpecialization::create(
-               *this, type1, getConstraintLocator(locator)))
+               *this, type1, decl, getConstraintLocator(locator)))
                ? SolutionKind::Error
                : SolutionKind::Solved;
   }

test/Constraints/ambiguous_specialized_name_diagnostics.swift

@@ -42,7 +42,6 @@ func test() {
 
   S<Int>(t: 42).test() // expected-error {{ambiguous use of 'init(t:)'}}
 
-  // FIXME(diagnostics): This should produce ambiguity diagnostic too
   S<Int>.staticFn()
-  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+  // expected-error@-1 {{ambiguous use of 'staticFn()'}}
 }

test/Parse/generic_disambiguation.swift

@@ -34,7 +34,7 @@ _ = (a < b, c > d)
 _ = a>(b)
 _ = a > (b)
 
-generic<Int>(0) // expected-error{{cannot explicitly specialize a generic function}} expected-note{{while parsing this '<' as a type parameter bracket}}
+generic<Int>(0) // expected-error{{cannot explicitly specialize a generic function}}
 
 A<B>.c()
 A<A<B>>.c()

test/Sema/generic-arg-list.swift

@@ -0,0 +1,40 @@
+// 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 non-generic type '() -> Int'}}
+
+  let _ = i.gen<Int>() // expected-error {{cannot explicitly specialize a generic function}}
+  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+
+  let _ = 0.foo<Int>() // expected-error {{cannot specialize non-generic type '() -> Int'}}
+
+  // 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 non-generic type 'Int'}}
+}
+
+extension Bool {
+  func foo<T>() -> T {}
+}
+
+let _: () -> Bool = false.foo<Int> // expected-error {{cannot explicitly specialize a generic function}}
+