crash once we get to code i want to better understand

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -6589,6 +6589,7 @@ ERROR(noimplicitcopy_attr_valid_only_on_local_let_params,
       none, "'@_noImplicitCopy' attribute can only be applied to local lets and params", ())
 ERROR(noimplicitcopy_attr_invalid_in_generic_context,
       none, "'@_noImplicitCopy' attribute cannot be applied to entities in generic contexts", ())
+ERROR(moveonly_generics, none, "move-only type %0 cannot be used with generics yet", (Type))
 
 //------------------------------------------------------------------------------
 // MARK: Type inference from default expressions

include/swift/Sema/CSFix.h

@@ -421,6 +421,9 @@ enum class FixKind : uint8_t {
 
   /// Macro that has parameters but was not provided with any arguments.
   MacroMissingArguments,
+
+  /// Produce an error about a type that must be Copyable
+  MustBeCopyable,
 };
 
 class ConstraintFix {
@@ -2019,6 +2022,25 @@ class NotCompileTimeConst final : public ContextualMismatch {
   }
 };
 
+class MustBeCopyable final : public ConstraintFix {
+  Type noncopyableTy;
+
+  MustBeCopyable(ConstraintSystem &cs, Type noncopyableTy, ConstraintLocator *locator);
+
+public:
+  std::string getName() const override { return "remove move-only from type"; }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static MustBeCopyable *create(ConstraintSystem &cs,
+                             Type noncopyableTy,
+                             ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::MustBeCopyable;
+  }
+};
+
 class CollectionElementContextualMismatch final
     : public ContextualMismatch,
       private llvm::TrailingObjects<CollectionElementContextualMismatch,

lib/Sema/CSDiagnostics.cpp

@@ -5803,6 +5803,11 @@ bool NotCompileTimeConstFailure::diagnoseAsError() {
   return true;
 }
 
+bool NotCopyableFailure::diagnoseAsError() {
+  emitDiagnostic(diag::moveonly_generics, noncopyableTy);
+  return true;
+}
+
 bool CollectionElementContextualFailure::diagnoseAsError() {
   auto anchor = getRawAnchor();
   auto *locator = getLocator();

lib/Sema/CSDiagnostics.h

@@ -1823,6 +1823,15 @@ class NotCompileTimeConstFailure final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+class NotCopyableFailure final : public FailureDiagnostic {
+  Type noncopyableTy;
+public:
+  NotCopyableFailure(const Solution &solution, Type noncopyableTy, ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator), noncopyableTy(noncopyableTy) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnose a contextual mismatch between expected collection element type
 /// and the one provided (e.g. source of the assignment or argument to a call)
 /// e.g.:

lib/Sema/CSFix.cpp

@@ -1326,6 +1326,21 @@ bool NotCompileTimeConst::diagnose(const Solution &solution, bool asNote) const
   return failure.diagnose(asNote);
 }
 
+MustBeCopyable::MustBeCopyable(ConstraintSystem &cs, Type noncopyableTy, ConstraintLocator *locator)
+    : ConstraintFix(cs, FixKind::MustBeCopyable, locator, FixBehavior::Error),
+      noncopyableTy(noncopyableTy) {}
+
+bool MustBeCopyable::diagnose(const Solution &solution, bool asNote) const {
+  NotCopyableFailure failure(solution, noncopyableTy, getLocator());
+  return failure.diagnose(asNote);
+}
+
+MustBeCopyable* MustBeCopyable::create(ConstraintSystem &cs,
+                                              Type noncopyableTy,
+                                              ConstraintLocator *locator) {
+  return new (cs.getAllocator()) MustBeCopyable(cs, noncopyableTy, locator);
+}
+
 bool CollectionElementContextualMismatch::diagnose(const Solution &solution,
                                                    bool asNote) const {
   CollectionElementContextualFailure failure(

lib/Sema/CSSimplify.cpp

@@ -4203,8 +4203,15 @@ ConstraintSystem::matchTypesBindTypeVar(
 
   // If the type variable cannot bind to a move-only type, fail.
   if (!typeVar->getImpl().canBindToMoveOnly() && type->isPureMoveOnly()) {
-    // TODO: record a fix that just emits an error to reject the substitution.
-    return getTypeMatchFailure(locator);
+    if (shouldAttemptFixes()) {
+      auto *fix = MustBeCopyable::create(*this, type,
+                                         getConstraintLocator(locator));
+      if (recordFix(fix))
+        return getTypeMatchFailure(locator);
+
+    } else {
+      return getTypeMatchFailure(locator);
+    }
   }
 
   // We do not allow keypaths to go through AnyObject. Let's create a fix
@@ -13810,6 +13817,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::RenameConflictingPatternVariables:
   case FixKind::MacroMissingPound:
   case FixKind::MacroMissingArguments: {
+  case FixKind::RenameConflictingPatternVariables:
+  case FixKind::MustBeCopyable: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }
   case FixKind::IgnoreInvalidASTNode: {