Merge pull request #66871 from kavon/generics-error-noncopyable

Be more specific than "noncopyable type T can't be used with generics yet"

Author: swift-ci

include/swift/AST/DiagnosticsSema.def

@@ -5520,7 +5520,9 @@ ERROR(tuple_pack_element_label,none,
       "cannot use label with pack expansion tuple element",
       ())
 ERROR(tuple_move_only_not_supported,none,
-      "tuples with noncopyable elements are not supported", ())
+      "tuple with noncopyable element type %0 is not supported", (Type))
+ERROR(tuple_containing_move_only_not_supported,none,
+      "type %0 containing noncopyable element is not supported", (Type))
 ERROR(vararg_not_allowed,none,
       "variadic parameter cannot appear outside of a function parameter list",
       ())
@@ -7267,7 +7269,33 @@ ERROR(self_ownership_specifier_copyable,none,
       (SelfAccessKind, DescriptiveDeclKind))
 ERROR(ownership_specifier_nonescaping_closure,none,
       "'%0' cannot be applied to nonescaping closure", (StringRef))
-ERROR(noncopyable_generics, none, "noncopyable type %0 cannot be used with generics yet", (Type))
+ERROR(noncopyable_generics, none,
+      "noncopyable type %0 cannot be used with generics yet",
+      (Type))
+ERROR(noncopyable_generics_variadic, none,
+      "noncopyable type %0 cannot be used within a variadic type yet",
+      (Type))
+ERROR(noncopyable_generics_specific, none,
+      "noncopyable type %0 cannot be used with generic type %1 yet",
+      (Type, Type))
+ERROR(noncopyable_generics_erasure, none,
+      "noncopyable type %0 cannot be erased to copyable existential type %1",
+      (Type, Type))
+ERROR(noncopyable_generics_metatype_cast, none,
+      "metatype %0 cannot be cast to %1 because %2 is noncopyable",
+      (Type, Type, Type))
+ERROR(noncopyable_generics_generic_param, none,
+      "noncopyable type %0 cannot be substituted for copyable %1 %2 in %3",
+      (Type, DescriptiveDeclKind, Type, DeclName))
+ERROR(noncopyable_generics_generic_param_metatype, none,
+      "metatype %4 of noncopyable type %0 cannot be substituted for copyable %1 %2 in %3",
+      (Type, DescriptiveDeclKind, Type, DeclName, Type))
+NOTE(noncopyable_generics_implicit_copyable, none,
+      "%0 %1 has an implicit Copyable requirement",
+      (DescriptiveDeclKind, Type))
+ERROR(noncopyable_element_of_pack_not_supported,none,
+      "parameter pack containing noncopyable element %0 is not supported",
+      (Type))
 ERROR(noncopyable_effectful_getter,none,
       "%0 of noncopyable type cannot be 'async' or 'throws'", (DescriptiveDeclKind))
 ERROR(noncopyable_enums_do_not_support_indirect,none,

include/swift/Sema/CSFix.h

@@ -2082,10 +2082,53 @@ class NotCompileTimeConst final : public ContextualMismatch {
   }
 };
 
+/// Describes the reason why the type must be copyable
+struct NoncopyableMatchFailure {
+  enum Kind {
+    CopyableConstraint,
+    ExistentialCast,
+  };
+
+private:
+  Kind reason;
+  union {
+    Type type;
+  };
+
+  NoncopyableMatchFailure(Kind reason, Type type)
+      : reason(reason), type(type) {}
+
+public:
+  Kind getKind() const { return reason; }
+
+  Type getType() const {
+    switch (reason) {
+    case ExistentialCast:
+      return type;
+
+    case CopyableConstraint:
+      llvm_unreachable("no type payload");
+    };
+  }
+
+  static NoncopyableMatchFailure forCopyableConstraint() {
+    return NoncopyableMatchFailure(CopyableConstraint, Type());
+  }
+
+  static NoncopyableMatchFailure forExistentialCast(Type existential) {
+    assert(existential->isAnyExistentialType());
+    return NoncopyableMatchFailure(ExistentialCast, existential);
+  }
+};
+
 class MustBeCopyable final : public ConstraintFix {
   Type noncopyableTy;
+  NoncopyableMatchFailure failure;
 
-  MustBeCopyable(ConstraintSystem &cs, Type noncopyableTy, ConstraintLocator *locator);
+  MustBeCopyable(ConstraintSystem &cs,
+                 Type noncopyableTy,
+                 NoncopyableMatchFailure failure,
+                 ConstraintLocator *locator);
 
 public:
   std::string getName() const override { return "remove move-only from type"; }
@@ -2096,6 +2139,7 @@ class MustBeCopyable final : public ConstraintFix {
 
   static MustBeCopyable *create(ConstraintSystem &cs,
                              Type noncopyableTy,
+                             NoncopyableMatchFailure failure,
                              ConstraintLocator *locator);
 
   static bool classof(const ConstraintFix *fix) {

lib/Sema/CSDiagnostics.cpp

@@ -6154,6 +6154,72 @@ bool NotCompileTimeConstFailure::diagnoseAsError() {
 }
 
 bool NotCopyableFailure::diagnoseAsError() {
+  switch (failure.getKind()) {
+  case NoncopyableMatchFailure::ExistentialCast: {
+    if (noncopyableTy->is<AnyMetatypeType>())
+      emitDiagnostic(diag::noncopyable_generics_metatype_cast,
+                     noncopyableTy,
+                     failure.getType(),
+                     noncopyableTy->getMetatypeInstanceType());
+    else
+      emitDiagnostic(diag::noncopyable_generics_erasure,
+                     noncopyableTy,
+                     failure.getType());
+    return true;
+  }
+
+  case NoncopyableMatchFailure::CopyableConstraint: {
+    auto *loc = getLocator();
+
+    if (loc->isLastElement<LocatorPathElt::AnyTupleElement>()) {
+      assert(!noncopyableTy->is<TupleType>() && "will use poor wording");
+      emitDiagnostic(diag::tuple_move_only_not_supported, noncopyableTy);
+      return true;
+    }
+
+    if (loc->isLastElement<LocatorPathElt::PackElement>()) {
+      emitDiagnostic(diag::noncopyable_element_of_pack_not_supported,
+                     noncopyableTy);
+      return true;
+    }
+
+    // a bit paranoid of nulls and such...
+    if (auto *genericParam = loc->getGenericParameter()) {
+      if (auto *paramDecl = genericParam->getDecl()) {
+        if (auto *owningDecl =
+            dyn_cast_or_null<ValueDecl>(paramDecl->getDeclContext()->getAsDecl())) {
+
+          // FIXME: these owningDecl names are kinda bad. like just `init(describing:)`
+          if (noncopyableTy->is<AnyMetatypeType>())
+            emitDiagnostic(diag::noncopyable_generics_generic_param_metatype,
+                           noncopyableTy->getMetatypeInstanceType(),
+                           paramDecl->getDescriptiveKind(),
+                           genericParam,
+                           owningDecl->getName(),
+                           noncopyableTy);
+          else
+            emitDiagnostic(diag::noncopyable_generics_generic_param,
+                           noncopyableTy,
+                           paramDecl->getDescriptiveKind(),
+                           genericParam,
+                           owningDecl->getName());
+
+          // If we have a location for the parameter, point it out in a note.
+          if (auto loc = paramDecl->getNameLoc()) {
+            emitDiagnosticAt(loc,
+                             diag::noncopyable_generics_implicit_copyable,
+                             paramDecl->getDescriptiveKind(),
+                             genericParam);
+          }
+
+          return true;
+        }
+      }
+    }
+    break;
+  }
+  }
+
   emitDiagnostic(diag::noncopyable_generics, noncopyableTy);
   return true;
 }

lib/Sema/CSDiagnostics.h

@@ -539,16 +539,16 @@ class MemberAccessOnOptionalBaseFailure final : public MemberReferenceFailure {
         ResultTypeIsOptional(resultOptional) {}
 
   bool diagnoseAsError() override;
-  
+
   Type getMemberBaseType() const {
     return MemberBaseType;
   }
-  
+
   SourceLoc getLoc() const override {
     // The end location points to the dot in the member access.
     return getSourceRange().End;
   }
-  
+
   SourceRange getSourceRange() const override;
 
 };
@@ -670,7 +670,7 @@ class ContextualFailure : public FailureDiagnostic {
 
   /// If we're trying to convert something to `nil`.
   bool diagnoseConversionToNil() const;
-  
+
   /// Diagnose failed conversion in a `CoerceExpr`.
   bool diagnoseCoercionToUnrelatedType() const;
 
@@ -1829,9 +1829,14 @@ class NotCompileTimeConstFailure final : public FailureDiagnostic {
 
 class NotCopyableFailure final : public FailureDiagnostic {
   Type noncopyableTy;
+  NoncopyableMatchFailure failure;
 public:
-  NotCopyableFailure(const Solution &solution, Type noncopyableTy, ConstraintLocator *locator)
-      : FailureDiagnostic(solution, locator), noncopyableTy(noncopyableTy) {}
+  NotCopyableFailure(const Solution &solution,
+                     Type noncopyableTy,
+                     NoncopyableMatchFailure failure,
+                     ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator),
+        noncopyableTy(noncopyableTy), failure(failure) {}
 
   bool diagnoseAsError() override;
 };

lib/Sema/CSFix.cpp

@@ -1368,19 +1368,24 @@ bool NotCompileTimeConst::diagnose(const Solution &solution, bool asNote) const
   return failure.diagnose(asNote);
 }
 
-MustBeCopyable::MustBeCopyable(ConstraintSystem &cs, Type noncopyableTy, ConstraintLocator *locator)
+MustBeCopyable::MustBeCopyable(ConstraintSystem &cs,
+                               Type noncopyableTy,
+                               NoncopyableMatchFailure failure,
+                               ConstraintLocator *locator)
     : ConstraintFix(cs, FixKind::MustBeCopyable, locator, FixBehavior::Error),
-      noncopyableTy(noncopyableTy) {}
+      noncopyableTy(noncopyableTy), failure(failure) {}
 
 bool MustBeCopyable::diagnose(const Solution &solution, bool asNote) const {
-  NotCopyableFailure failure(solution, noncopyableTy, getLocator());
-  return failure.diagnose(asNote);
+  NotCopyableFailure failDiag(solution, noncopyableTy, failure, getLocator());
+  return failDiag.diagnose(asNote);
 }
 
 MustBeCopyable* MustBeCopyable::create(ConstraintSystem &cs,
                                               Type noncopyableTy,
+                                              NoncopyableMatchFailure failure,
                                               ConstraintLocator *locator) {
-  return new (cs.getAllocator()) MustBeCopyable(cs, noncopyableTy, locator);
+  return new (cs.getAllocator()) MustBeCopyable(cs, noncopyableTy,
+                                                failure, locator);
 }
 
 bool MustBeCopyable::diagnoseForAmbiguity(CommonFixesArray commonFixes) const {

lib/Sema/CSSimplify.cpp

@@ -3832,8 +3832,11 @@ ConstraintSystem::matchExistentialTypes(Type type1, Type type2,
   if (type1->getMetatypeInstanceType()->isPureMoveOnly()) {
     // tailor error message
     if (shouldAttemptFixes()) {
-      auto *fix = MustBeCopyable::create(*this, type1,
-                                        getConstraintLocator(locator));
+      auto *fix = MustBeCopyable::create(*this,
+                                         type1,
+                                         NoncopyableMatchFailure::forExistentialCast(
+                                             type2),
+                                         getConstraintLocator(locator));
       if (!recordFix(fix))
         return getTypeMatchSuccess();
     }
@@ -8492,7 +8495,10 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     // If this is a failure to conform to Copyable, tailor the error message.
     if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
       auto *fix =
-          MustBeCopyable::create(*this, type, getConstraintLocator(locator));
+          MustBeCopyable::create(*this,
+                                 type,
+                                 NoncopyableMatchFailure::forCopyableConstraint(),
+                                 getConstraintLocator(locator));
       if (!recordFix(fix))
         return SolutionKind::Solved;
     }

lib/Sema/MiscDiagnostics.cpp

@@ -329,7 +329,11 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
         // Diagnose attempts to form a tuple with any noncopyable elements.
         if (E->getType()->isPureMoveOnly()
             && !Ctx.LangOpts.hasFeature(Feature::MoveOnlyTuples)) {
-          Ctx.Diags.diagnose(E->getLoc(), diag::tuple_move_only_not_supported);
+          auto noncopyableTy = E->getType();
+          assert(noncopyableTy->is<TupleType>() && "will use poor wording");
+          Ctx.Diags.diagnose(E->getLoc(),
+                             diag::tuple_containing_move_only_not_supported,
+                             noncopyableTy);
         }
       }