polish noncopyable types diagnostic wordings

- replaces "move-only" terminology with "noncopyable"
- replaces compiler jargon like "guaranteed parameters"
  and "lvalue" with corresponding language-level notions

Author: kavon

docs/SIL.rst

@@ -2805,7 +2805,7 @@ canonical SIL that the value was never copied and thus is a "move only value"
 even though the actual underlying wrapped type is copyable. As an example of
 this, consider the following Swift::
 
-  func doSomething(@_noImplicitCopy _ x: Klass) -> () { // expected-error {{'x' has guaranteed ownership but was consumed}}
+  func doSomething(@_noImplicitCopy _ x: Klass) -> () { // expected-error {{'x' is borrowed and cannot be consumed}}
     x.doSomething()
     let x2 = x // expected-note {{consuming use}}
     x2.doSomething()

include/swift/AST/DiagnosticsSIL.def

@@ -753,9 +753,9 @@ ERROR(sil_moveonlychecker_owned_value_consumed_and_used_at_same_time, none,
 ERROR(sil_moveonlychecker_value_used_after_consume, none,
       "'%0' used after consume", (StringRef))
 ERROR(sil_moveonlychecker_guaranteed_value_consumed, none,
-      "'%0' has guaranteed ownership but was consumed", (StringRef))
+      "'%0' is borrowed and cannot be consumed", (StringRef))
 ERROR(sil_moveonlychecker_guaranteed_value_captured_by_closure, none,
-      "'%0' has guaranteed ownership but was consumed due to being captured by a closure", (StringRef))
+      "'%0' is borrowed and cannot be consumed by closure capture", (StringRef))
 ERROR(sil_moveonlychecker_let_value_consumed_in_closure, none,
       "'%0' consumed in closure. This is illegal since if the closure is invoked more than once the binding will be uninitialized on later invocations", (StringRef))
 ERROR(sil_moveonlychecker_inout_not_reinitialized_before_end_of_function, none,

include/swift/AST/DiagnosticsSema.def

@@ -6930,30 +6930,6 @@ ERROR(wrap_invalid_attr_added_by_access_note, none,
 
 #undef WHICH_ACCESS_NOTE
 
-// Move Only diagnostics
-
-ERROR(experimental_moveonly_feature_can_only_be_used_when_enabled,
-      none, "Can not use feature when experimental move only is disabled! Pass"
-      " the frontend flag -enable-experimental-move-only to swift to enable "
-      "the usage of this language feature", ())
-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))
-ERROR(moveonly_effectful_getter,none,
-      "%0 of move-only type cannot be 'async' or 'throws'", (DescriptiveDeclKind))
-ERROR(noimplicitcopy_attr_not_allowed_on_moveonlytype,none,
-      "'@_noImplicitCopy' has no effect when applied to a move only type", ())
-ERROR(moveonly_enums_do_not_support_indirect,none,
-      "move-only enum %0 cannot be marked indirect or have indirect cases yet", (Identifier))
-ERROR(moveonly_cast,none,
-      "move-only types cannot be conditionally cast", ())
-ERROR(moveonly_failable_init,none,
-      "move-only types cannot have failable initializers yet", ())
-ERROR(moveonly_objc_enum_banned, none,
-      "@objc enums cannot be marked as move-only", ())
-
 //------------------------------------------------------------------------------
 // MARK: Type inference from default expressions
 //------------------------------------------------------------------------------
@@ -7011,21 +6987,6 @@ ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
       "annotating a type with a global actor %0 is not permitted within %1",
       (TypeRepr*, StringRef))
 
-ERROR(moveOnly_not_allowed_here,none,
-      "'moveOnly' only applies to structs or enums", ())
-ERROR(consume_expression_not_passed_lvalue,none,
-      "'consume' can only be applied to lvalues", ())
-ERROR(borrow_expression_not_passed_lvalue,none,
-      "'borrow' can only be applied to lvalues", ())
-ERROR(copy_expression_not_passed_lvalue,none,
-      "'copy' can only be applied to lvalues", ())
-ERROR(copy_expression_cannot_be_used_with_noncopyable_types,none,
-      "'copy' cannot be applied to noncopyable types", ())
-
-ERROR(moveOnly_requires_lexical_lifetimes,none,
-      "noncopyable types require lexical borrow scopes "
-      "(add -enable-lexical-borrow-scopes=true)", ())
-
 //------------------------------------------------------------------------------
 // MARK: #_hasSymbol
 //------------------------------------------------------------------------------
@@ -7158,31 +7119,68 @@ NOTE(macro_expand_circular_reference_unnamed_through, none,
      "circular reference expanding %0 macros", (StringRef))
 
 //------------------------------------------------------------------------------
-// MARK: Move Only Errors
+// MARK: Noncopyable Types Diagnostics
 //------------------------------------------------------------------------------
 
-ERROR(moveonly_copyable_type_that_contains_moveonly_type, none,
-      "%0 %1 cannot contain a move-only type without also being move-only",
+ERROR(noncopyable_within_copyable, none,
+      "%0 %1 cannot contain a noncopyable type without also being noncopyable",
       (DescriptiveDeclKind, DeclName))
-NOTE(moveonly_copyable_type_that_contains_moveonly_type_location, none,
-     "contained move-only %0 '%1.%2'",
+NOTE(noncopyable_within_copyable_location, none,
+     "contained noncopyable %0 '%1.%2'",
      (DescriptiveDeclKind, StringRef, StringRef))
-ERROR(moveonly_cannot_conform_to_type, none,
-     "move-only %0 %1 cannot conform to %2",
+ERROR(noncopyable_cannot_conform_to_type, none,
+     "noncopyable %0 %1 cannot conform to %2",
      (DescriptiveDeclKind, DeclName, Type))
-ERROR(moveonly_parameter_missing_ownership, none,
+ERROR(noncopyable_parameter_requires_ownership, none,
       "noncopyable parameter must specify its ownership", ())
-ERROR(moveonly_parameter_subscript_unsupported, none,
+ERROR(noncopyable_parameter_subscript_unsupported, none,
       "subscripts cannot have noncopyable parameters yet", ())
-NOTE(moveonly_parameter_ownership_suggestion, none,
+NOTE(noncopyable_parameter_ownership_suggestion, none,
       "add '%0' %1", (StringRef, StringRef))
 ERROR(ownership_specifier_copyable,none,
-      "Copyable types cannot be 'consuming' or 'borrowing' yet", ())
+      "copyable types cannot be 'consuming' or 'borrowing' yet", ())
 ERROR(self_ownership_specifier_copyable,none,
-      "%0 is not yet valid on %1s in a Copyable type",
+      "%0 is not yet valid on %1s of a copyable type",
       (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_effectful_getter,none,
+      "%0 of noncopyable type cannot be 'async' or 'throws'", (DescriptiveDeclKind))
+ERROR(noncopyable_enums_do_not_support_indirect,none,
+      "noncopyable enum %0 cannot be marked indirect or have indirect cases yet", (Identifier))
+ERROR(noncopyable_cast,none,
+      "noncopyable types cannot be conditionally cast", ())
+ERROR(noncopyable_failable_init,none,
+      "noncopyable types cannot have failable initializers yet", ())
+ERROR(noncopyable_objc_enum, none,
+      "noncopyable enums cannot be marked '@objc'", ())
+ERROR(moveOnly_not_allowed_here,none,
+      "'@_moveOnly' attribute is only valid on structs or enums", ())
+ERROR(consume_expression_not_passed_lvalue,none,
+      "'consume' can only be applied to a local binding ('let', 'var', or parameter)", ())
+ERROR(borrow_expression_not_passed_lvalue,none,
+      "'borrow' can only be applied to a local binding ('let', 'var', or parameter)", ())
+ERROR(copy_expression_not_passed_lvalue,none,
+      "'copy' can only be applied to a local binding ('let', 'var', or parameter)", ())
+ERROR(copy_expression_cannot_be_used_with_noncopyable_types,none,
+      "'copy' cannot be applied to noncopyable types", ())
+
+ERROR(moveOnly_requires_lexical_lifetimes,none,
+      "noncopyable types require lexical borrow scopes "
+      "(add -enable-lexical-borrow-scopes=true)", ())
+
+// Experimental noncopyable feature diagnostics:
+ERROR(experimental_moveonly_feature_can_only_be_used_when_enabled,
+      none, "Can not use feature when experimental move only is disabled! Pass"
+            " the frontend flag -enable-experimental-move-only to swift to enable "
+            "the usage of this language feature", ())
+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(noimplicitcopy_attr_not_allowed_on_moveonlytype,none,
+      "'@_noImplicitCopy' has no effect when applied to a noncopyable type", ())
 
 //------------------------------------------------------------------------------
 // MARK: Runtime discoverable attributes (@runtimeMetadata)

lib/Sema/CSDiagnostics.cpp

@@ -6129,7 +6129,7 @@ bool NotCompileTimeConstFailure::diagnoseAsError() {
 }
 
 bool NotCopyableFailure::diagnoseAsError() {
-  emitDiagnostic(diag::moveonly_generics, noncopyableTy);
+  emitDiagnostic(diag::noncopyable_generics, noncopyableTy);
   return true;
 }
 

lib/Sema/MiscDiagnostics.cpp

@@ -388,7 +388,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
 
       if (castType->isPureMoveOnly()) {
         // can't cast anything to move-only; there should be no valid ones.
-        Ctx.Diags.diagnose(cast->getLoc(), diag::moveonly_cast);
+        Ctx.Diags.diagnose(cast->getLoc(), diag::noncopyable_cast);
         return;
       }
 
@@ -398,7 +398,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       if (auto fromType = cast->getSubExpr()->getType()) {
         if (fromType->isPureMoveOnly()) {
           // can't cast move-only to anything.
-          Ctx.Diags.diagnose(cast->getLoc(), diag::moveonly_cast);
+          Ctx.Diags.diagnose(cast->getLoc(), diag::noncopyable_cast);
           return;
         }
       }
@@ -6208,13 +6208,13 @@ void swift::diagnoseCopyableTypeContainingMoveOnlyType(
     if (auto *eltDecl = topFieldToError.dyn_cast<EnumElementDecl *>()) {
       DE.diagnoseWithNotes(
           copyableNominalType->diagnose(
-              diag::moveonly_copyable_type_that_contains_moveonly_type,
+              diag::noncopyable_within_copyable,
               copyableNominalType->getDescriptiveKind(),
               copyableNominalType->getBaseName()),
           [&]() {
             eltDecl->diagnose(
                 diag::
-                    moveonly_copyable_type_that_contains_moveonly_type_location,
+                    noncopyable_within_copyable_location,
                 fieldKind, parentName.userFacingName(),
                 fieldName.userFacingName());
           });
@@ -6224,12 +6224,12 @@ void swift::diagnoseCopyableTypeContainingMoveOnlyType(
     auto *varDecl = topFieldToError.get<VarDecl *>();
     DE.diagnoseWithNotes(
         copyableNominalType->diagnose(
-            diag::moveonly_copyable_type_that_contains_moveonly_type,
+            diag::noncopyable_within_copyable,
             copyableNominalType->getDescriptiveKind(),
             copyableNominalType->getBaseName()),
         [&]() {
           varDecl->diagnose(
-              diag::moveonly_copyable_type_that_contains_moveonly_type_location,
+              diag::noncopyable_within_copyable_location,
               fieldKind, parentName.userFacingName(),
               fieldName.userFacingName());
         });

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2609,7 +2609,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     //
 
     if (ED->isObjC() && ED->isMoveOnly()) {
-      ED->diagnose(diag::moveonly_objc_enum_banned);
+      ED->diagnose(diag::noncopyable_objc_enum);
     }
     // FIXME(kavon): see if these can be integrated into other parts of Sema
     diagnoseCopyableTypeContainingMoveOnlyType(ED);
@@ -2625,11 +2625,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // indirect cases.
     if (ED->getAttrs().hasAttribute<MoveOnlyAttr>()) {
       if (ED->isIndirect())
-        ED->diagnose(diag::moveonly_enums_do_not_support_indirect,
+        ED->diagnose(diag::noncopyable_enums_do_not_support_indirect,
                      ED->getBaseIdentifier());
       for (auto *elt : ED->getAllElements()) {
         if (elt->isIndirect()) {
-          elt->diagnose(diag::moveonly_enums_do_not_support_indirect,
+          elt->diagnose(diag::noncopyable_enums_do_not_support_indirect,
                         ED->getBaseIdentifier());
         }
       }
@@ -2797,7 +2797,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     auto &ctx = moveonlyType->getASTContext();
     ctx.Diags.diagnose(loc,
-                       diag::moveonly_cannot_conform_to_type,
+                       diag::noncopyable_cannot_conform_to_type,
                        moveonlyType->getDescriptiveKind(),
                        moveonlyType->getBaseName(),
                        type);
@@ -3646,7 +3646,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (CD->isFailable()) {
       if (auto *nom = CD->getDeclContext()->getSelfNominalTypeDecl()) {
         if (nom->isMoveOnly()) {
-          CD->diagnose(diag::moveonly_failable_init);
+          CD->diagnose(diag::noncopyable_failable_init);
         }
       }
     }

lib/Sema/TypeCheckStorage.cpp

@@ -629,7 +629,7 @@ OpaqueReadOwnershipRequest::evaluate(Evaluator &evaluator,
     if (auto *getter = storage->getEffectfulGetAccessor()) {
       switch (kind) {
       case DiagKind::NoncopyableType:
-        getter->diagnose(diag::moveonly_effectful_getter,
+        getter->diagnose(diag::noncopyable_effectful_getter,
                          getter->getDescriptiveKind());
         break;
       case DiagKind::BorrowedAttr:

lib/Sema/TypeCheckType.cpp

@@ -1006,7 +1006,7 @@ static bool didDiagnoseMoveOnlyGenericArgs(ASTContext &ctx,
     if (!t->isPureMoveOnly())
       continue;
 
-    ctx.Diags.diagnose(loc, diag::moveonly_generics, t);
+    ctx.Diags.diagnose(loc, diag::noncopyable_generics, t);
     didEmitDiag = true;
   }
 
@@ -2278,7 +2278,7 @@ bool TypeResolver::diagnoseInvalidPlaceHolder(OpaqueReturnTypeRepr *repr) {
 /// returns true if an error diagnostic was emitted
 bool TypeResolver::diagnoseMoveOnly(TypeRepr *repr, Type genericArgTy) {
   if (genericArgTy->isPureMoveOnly()) {
-    diagnoseInvalid(repr, repr->getLoc(), diag::moveonly_generics,
+    diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics,
                     genericArgTy);
     return true;
   }
@@ -2319,21 +2319,21 @@ bool TypeResolver::diagnoseMoveOnlyMissingOwnership(
   // decls, give a tailored error message saying you simply can't use a
   // noncopyable type here.
   if (options.hasBase(TypeResolverContext::SubscriptDecl)) {
-    diagnose(repr->getLoc(), diag::moveonly_parameter_subscript_unsupported);
+    diagnose(repr->getLoc(), diag::noncopyable_parameter_subscript_unsupported);
   } else {
     // general error diagnostic
     diagnose(repr->getLoc(),
-             diag::moveonly_parameter_missing_ownership);
+             diag::noncopyable_parameter_requires_ownership);
 
-    diagnose(repr->getLoc(), diag::moveonly_parameter_ownership_suggestion,
+    diagnose(repr->getLoc(), diag::noncopyable_parameter_ownership_suggestion,
              "borrowing", "for an immutable reference")
         .fixItInsert(repr->getStartLoc(), "borrowing ");
 
-    diagnose(repr->getLoc(), diag::moveonly_parameter_ownership_suggestion,
+    diagnose(repr->getLoc(), diag::noncopyable_parameter_ownership_suggestion,
              "inout", "for a mutable reference")
         .fixItInsert(repr->getStartLoc(), "inout ");
 
-    diagnose(repr->getLoc(), diag::moveonly_parameter_ownership_suggestion,
+    diagnose(repr->getLoc(), diag::noncopyable_parameter_ownership_suggestion,
              "consuming", "to take the value from the caller")
         .fixItInsert(repr->getStartLoc(), "consuming ");
   }