Feedback, round 2

Author: Greg Titus

include/swift/Sema/CSFix.h

@@ -459,9 +459,12 @@ enum class FixKind : uint8_t {
   /// because its name doesn't appear in 'initializes' or 'accesses' attributes.
   AllowInvalidMemberReferenceInInitAccessor,
 
-  /// Ignore an attempt to specialize a generic function or non-generic type.
+  /// Ignore an attempt to specialize a non-generic type.
   AllowConcreteTypeSpecialization,
 
+  /// Ignore an attempt to specialize a generic function.
+  AllowGenericFunctionSpecialization,
+
   /// Ignore an out-of-place \c then statement.
   IgnoreOutOfPlaceThenStmt,
 
@@ -3705,16 +3708,41 @@ class AllowConcreteTypeSpecialization final : public ConstraintFix {
     return diagnose(*commonFixes.front().first);
   }
 
-  static AllowConcreteTypeSpecialization *create(ConstraintSystem &cs,
-                                                 Type concreteTy,
-                                                 ValueDecl *decl,
-                                                 ConstraintLocator *locator);
+  static AllowConcreteTypeSpecialization *
+  create(ConstraintSystem &cs, Type concreteTy, ConstraintLocator *locator);
 
   static bool classof(const ConstraintFix *fix) {
     return fix->getKind() == FixKind::AllowConcreteTypeSpecialization;
   }
 };
 
+class AllowGenericFunctionSpecialization final : public ConstraintFix {
+  ValueDecl *Decl;
+
+  AllowGenericFunctionSpecialization(ConstraintSystem &cs, ValueDecl *decl,
+                                     ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowConcreteTypeSpecialization, locator),
+        Decl(decl) {}
+
+public:
+  std::string getName() const override {
+    return "allow generic function specialization";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
+  static AllowGenericFunctionSpecialization *
+  create(ConstraintSystem &cs, ValueDecl *decl, ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowGenericFunctionSpecialization;
+  }
+};
+
 class IgnoreOutOfPlaceThenStmt final : public ConstraintFix {
   IgnoreOutOfPlaceThenStmt(ConstraintSystem &cs, ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::IgnoreOutOfPlaceThenStmt, locator) {}

lib/Sema/CSDiagnostics.cpp

@@ -9338,11 +9338,12 @@ bool InvalidMemberReferenceWithinInitAccessor::diagnoseAsError() {
 }
 
 bool ConcreteTypeSpecialization::diagnoseAsError() {
-  if (ConcreteType) {
-    emitDiagnostic(diag::not_a_generic_type, resolveType(ConcreteType));
-  } else {
-    emitDiagnostic(diag::cannot_explicitly_specialize_generic_function);
-  }
+  emitDiagnostic(diag::not_a_generic_type, resolveType(ConcreteType));
+  return true;
+}
+
+bool GenericFunctionSpecialization::diagnoseAsError() {
+  emitDiagnostic(diag::cannot_explicitly_specialize_generic_function);
   return true;
 }
 

lib/Sema/CSDiagnostics.h

@@ -3121,6 +3121,17 @@ class ConcreteTypeSpecialization final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+class GenericFunctionSpecialization final : public FailureDiagnostic {
+  ValueDecl *Decl;
+
+public:
+  GenericFunctionSpecialization(const Solution &solution, ValueDecl *decl,
+                                ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator), Decl(decl) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnose an out-of-place ThenStmt.
 class OutOfPlaceThenStmtFailure final : public FailureDiagnostic {
 public:

lib/Sema/CSFix.cpp

@@ -2599,19 +2599,23 @@ bool AllowConcreteTypeSpecialization::diagnose(const Solution &solution,
 
 AllowConcreteTypeSpecialization *
 AllowConcreteTypeSpecialization::create(ConstraintSystem &cs, Type concreteTy,
-                                        ValueDecl *decl,
                                         ConstraintLocator *locator) {
-  // Check the decl and null the type to signal that the actual problem is trying to specialize a generic function
-  if (isa<AbstractFunctionDecl>(decl)) {
-    auto genericContext = decl->getAsGenericContext();
-    if (genericContext && genericContext->getGenericParams()) {
-      concreteTy = nullptr;
-    }
-  }
   return new (cs.getAllocator())
       AllowConcreteTypeSpecialization(cs, concreteTy, locator);
 }
 
+bool AllowGenericFunctionSpecialization::diagnose(const Solution &solution,
+                                                  bool asNote) const {
+  GenericFunctionSpecialization failure(solution, Decl, getLocator());
+  return failure.diagnose(asNote);
+}
+
+AllowGenericFunctionSpecialization *AllowGenericFunctionSpecialization::create(
+    ConstraintSystem &cs, ValueDecl *decl, ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      AllowGenericFunctionSpecialization(cs, decl, locator);
+}
+
 bool IgnoreOutOfPlaceThenStmt::diagnose(const Solution &solution,
                                         bool asNote) const {
   OutOfPlaceThenStmtFailure failure(solution, getLocator());

lib/Sema/CSGen.cpp

@@ -1903,12 +1903,11 @@ namespace {
     /// introduce them as an explicit generic arguments constraint.
     ///
     /// \returns true if resolving any of the specialization types failed.
-    bool addSpecializationConstraint(
-        ConstraintLocator *locator, Type boundType,
-        ArrayRef<TypeRepr *> specializationArgs) {
+    void addSpecializationConstraint(ConstraintLocator *locator, Type boundType,
+                                     SourceLoc lAngleLoc,
+                                     ArrayRef<TypeRepr *> specializationArgs) {
       // Resolve each type.
       SmallVector<Type, 2> specializationArgTypes;
-      bool hasError = false;
       auto options =
           TypeResolutionOptions(TypeResolverContext::InExpression);
       for (auto specializationArg : specializationArgs) {
@@ -1927,28 +1926,23 @@ namespace {
           auto &ctxt = CS.getASTContext();
           auto *repr = new (ctxt) PlaceholderTypeRepr(specializationArg->getLoc());
           result = PlaceholderType::get(ctxt, repr);
-          hasError = true;
+          auto &diags = CS.getASTContext().Diags;
+          diags.diagnose(lAngleLoc, diag::while_parsing_as_left_angle_bracket);
         }
         specializationArgTypes.push_back(result);
       }
 
       CS.addConstraint(
           ConstraintKind::ExplicitGenericArguments, boundType,
-          PackType::get(CS.getASTContext(), specializationArgTypes),
-          locator);
-      return hasError;
+          PackType::get(CS.getASTContext(), specializationArgTypes), locator);
     }
 
     Type visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *expr) {
       auto baseTy = CS.getType(expr->getSubExpr());
       auto *overloadLocator = CS.getConstraintLocator(expr->getSubExpr());
-      if (addSpecializationConstraint(overloadLocator, baseTy->getMetatypeInstanceType(),
-                                      expr->getUnresolvedParams())) {
-        // Diagnosis of failed type lookup - add a bit of context
-        auto &de = CS.getASTContext().Diags;
-        de.diagnose(expr->getLAngleLoc(),
-                    diag::while_parsing_as_left_angle_bracket);
-      }
+      addSpecializationConstraint(
+          overloadLocator, baseTy->getMetatypeInstanceType(),
+          expr->getLAngleLoc(), expr->getUnresolvedParams());
       return baseTy;
     }
 
@@ -4062,6 +4056,7 @@ namespace {
       // Add explicit generic arguments, if there were any.
       if (expr->getGenericArgsRange().isValid()) {
         addSpecializationConstraint(CS.getConstraintLocator(expr), macroRefType,
+                                    expr->getGenericArgsRange().Start,
                                     expr->getGenericArgs());
       }
 

lib/Sema/CSSimplify.cpp

@@ -14023,7 +14023,7 @@ ConstraintSystem::simplifyExplicitGenericArgumentsConstraint(
   auto genericParams = getGenericParams(decl);
   if (!decl->getAsGenericContext() || !genericParams) {
     return recordFix(AllowConcreteTypeSpecialization::create(
-               *this, type1, decl, getConstraintLocator(locator)))
+               *this, type1, getConstraintLocator(locator)))
                ? SolutionKind::Error
                : SolutionKind::Solved;
   }
@@ -14064,8 +14064,8 @@ ConstraintSystem::simplifyExplicitGenericArgumentsConstraint(
     if (!shouldAttemptFixes())
       return SolutionKind::Error;
 
-    return recordFix(AllowConcreteTypeSpecialization::create(
-               *this, type1, decl, getConstraintLocator(locator)))
+    return recordFix(AllowGenericFunctionSpecialization::create(
+               *this, decl, getConstraintLocator(locator)))
                ? SolutionKind::Error
                : SolutionKind::Solved;
   }
@@ -15196,6 +15196,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowAssociatedValueMismatch:
   case FixKind::GenericArgumentsMismatch:
   case FixKind::AllowConcreteTypeSpecialization:
+  case FixKind::AllowGenericFunctionSpecialization:
   case FixKind::IgnoreGenericSpecializationArityMismatch:
   case FixKind::IgnoreKeyPathSubscriptIndexMismatch:
   case FixKind::AllowMemberRefOnExistential: {

test/Parse/generic_disambiguation.swift

@@ -27,13 +27,13 @@ _ = a < b
 _ = (a < b, c > d)
 // Parses as generic because of lparen after '>'
 (a < b, c > (d)) // expected-error{{cannot find type 'b' in scope}}
-// expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
+// expected-note@-1 2 {{while parsing this '<' as a type parameter bracket}}
 // expected-error@-2 {{cannot specialize non-generic type 'Int'}}
 // expected-error@-3 {{cannot call value of non-function type 'Int'}}
 // expected-error@-4 {{cannot find type 'c' in scope}}
 // Parses as generic because of lparen after '>'
 (a<b, c>(d)) // expected-error{{cannot find type 'b' in scope}}
-// expected-note@-1 {{while parsing this '<' as a type parameter bracket}}
+// expected-note@-1 2 {{while parsing this '<' as a type parameter bracket}}
 // expected-error@-2 {{cannot specialize non-generic type 'Int'}}
 // expected-error@-3 {{cannot call value of non-function type 'Int'}}
 // expected-error@-4 {{cannot find type 'c' in scope}}