move noncopyable types out from behind the feature flag

Since these types depend on lexical borrow scopes (a SIL
option), we're now making that the requirement whenever
such types appear.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -6744,11 +6744,6 @@ 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(experimental_moveonly_feature_can_only_be_imported_when_enabled,
-      none, "Can not import module %0 that uses move only features when "
-      "experimental move only is disabled! Pass the frontend flag "
-      "-enable-experimental-move-only to swift to enable the usage of this "
-      "language feature", (Identifier))
 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,
@@ -6831,6 +6826,10 @@ ERROR(move_expression_not_passed_lvalue,none,
 ERROR(borrow_expression_not_passed_lvalue,none,
       "'borrow' can only be applied to lvalues", ())
 
+ERROR(moveOnly_requires_lexical_lifetimes,none,
+      "noncopyable types require lexical borrow scopes "
+      "(add -enable-lexical-borrow-scopes=true)", ())
+
 //------------------------------------------------------------------------------
 // MARK: #_hasSymbol
 //------------------------------------------------------------------------------

lib/Sema/TypeCheckAttr.cpp

@@ -2159,12 +2159,17 @@ void AttributeChecker::visitFinalAttr(FinalAttr *attr) {
 }
 
 void AttributeChecker::visitMoveOnlyAttr(MoveOnlyAttr *attr) {
-  if (!D->getASTContext().LangOpts.hasFeature(Feature::MoveOnly)) {
-    auto error =
-        diag::experimental_moveonly_feature_can_only_be_used_when_enabled;
-    diagnoseAndRemoveAttr(attr, error);
-    return;
-  }
+#ifndef NDEBUG
+  // Try to catch uses of @_moveOnly when we don't have the Copyable protocol.
+  // This can only happen in rare circumstances with test cases where you're
+  // building with -parse-stdlib. You need to also specify that you're building
+  // the Swift module (`-module-name Swift`) and then explicitly define Copyable
+  if (!D->getASTContext().getProtocol(KnownProtocolKind::Copyable))
+    llvm_unreachable("must define Copyable protocol when using -parse-stdlib");
+#endif
+
+  if (!D->getASTContext().supportsMoveOnlyTypes())
+    D->diagnose(diag::moveOnly_requires_lexical_lifetimes);
 
   if (isa<StructDecl>(D) || isa<EnumDecl>(D))
     return;

lib/Sema/TypeCheckDecl.cpp

@@ -918,8 +918,14 @@ IsFinalRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
 
 bool IsMoveOnlyRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
   // For now only do this for nominal type decls.
-  if (isa<NominalTypeDecl>(decl))
-    return decl->getAttrs().hasAttribute<MoveOnlyAttr>();
+  if (isa<NominalTypeDecl>(decl)) {
+      if (decl->getAttrs().hasAttribute<MoveOnlyAttr>()) {
+        if (!decl->getASTContext().supportsMoveOnlyTypes())
+            decl->diagnose(diag::moveOnly_requires_lexical_lifetimes);
+
+        return true;
+      }
+  }
   return false;
 }
 

lib/Serialization/Deserialization.cpp

@@ -5484,17 +5484,6 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
         MF.fatal(llvm::make_error<InvalidRecordKindError>(recordID));
       }
 
-      // Do a quick check to see if this attribute is a move only attribute. If
-      // so, emit a nice error if we don't have experimental move only enabled.
-      if (Attr && Attr->getKind() == DeclAttrKind::DAK_MoveOnly &&
-          !MF.getContext().LangOpts.Features.contains(Feature::MoveOnly)) {
-        MF.getContext().Diags.diagnose(
-            SourceLoc(),
-            diag::
-                experimental_moveonly_feature_can_only_be_imported_when_enabled,
-            MF.getAssociatedModule()->getName());
-      }
-
       if (!skipAttr) {
         if (!Attr)
           return llvm::Error::success();

test/Sema/moveonly_lexical_borrow_required.swift

@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend -typecheck %s
+// RUN: %target-typecheck-verify-swift -enable-lexical-borrow-scopes=false
+
+@_moveOnly
+public struct MO { // expected-error 2{{noncopyable types require lexical borrow scopes (add -enable-lexical-borrow-scopes=true)}}
+  let x = 0
+}
+
+public func whatever(_ mo: borrowing MO) {}

test/Serialization/moveonly_error_on_import_into_module_without_flag.swift

@@ -1,18 +1,26 @@
 // RUN: %empty-directory(%t)
 // TODO: re-enable the simplification passes once rdar://104875010 is fixed
-// RUN: %target-swift-frontend -Xllvm -sil-disable-pass=simplification -emit-module -o %t/Library.swiftmodule -module-name Library %S/Inputs/moveonly_deinit.swift -enable-experimental-move-only
-// RUN: not %target-swift-frontend -DUSE_MOVEONLY_TYPE -I %t %s -emit-sil -o /dev/null 2>&1 | %FileCheck %s
-// RUN: %target-swift-frontend -I %t %s -emit-sil -verify -o /dev/null
+// RUN: %target-swift-frontend -Xllvm -sil-disable-pass=simplification -emit-module -o %t/Library.swiftmodule -module-name Library %S/Inputs/moveonly_deinit.swift
 
-// This test makes sure that if we import a move only type and do not set the
-// experimental move only flag, we get a nice error.
+// >>> make sure borrow scopes are required when using a move-only type from another module
+// RUN: not %target-swift-frontend -DUSE_MOVEONLY_TYPE -typecheck -enable-lexical-borrow-scopes=false -I %t %s 2>&1 | %FileCheck %s --check-prefix CHECK-ERROR
+// RUN: %target-swift-frontend -DUSE_MOVEONLY_TYPE -typecheck -I %t %s 2>&1 | %FileCheck %s --allow-empty
+
+// >>> try turning off lexical borrow scopes with no move-only types; shouldn't be an error.
+//     we have to pipe into FileCheck because -verify ignores errors from other files.
+// RUN: %target-swift-frontend -enable-lexical-borrow-scopes=false -typecheck -I %t %s 2>&1 | %FileCheck %s --allow-empty
+
+// This test makes sure that if we import a move only type
+// and do not have lexical borrow scopes enabled, we emit an error.
 
 import Library
 
-// CHECK: error: Can not import module 'Library' that uses move only features when experimental move only is disabled! Pass the frontend flag -enable-experimental-move-only to swift to enable the usage of this language feature
+// CHECK-ERROR: Library.MoveOnlyStruct{{.*}} error: noncopyable types require lexical borrow scopes (add -enable-lexical-borrow-scopes=true)
+
+// CHECK-NOT: error
 
 #if USE_MOVEONLY_TYPE
-func f(_ k: MoveOnlyStruct) {}
+func f(_ k: borrowing MoveOnlyStruct) {}
 #endif
 
 func g(_ k: NormalStruct) {}