[SIL] improve SILType::isMoveOnly

We were missing some of the "artificial" types in the
TypeBase::isNoncopyable implementation. Rather than add them to the
frontend, I just check for those special SIL-only types in
SILType::isMoveOnly.

resolves rdar://117282929

Author: kavon

lib/SIL/IR/SILType.cpp

@@ -1044,10 +1044,20 @@ SILType::getSingletonAggregateFieldType(SILModule &M,
 }
 
 bool SILType::isMoveOnly() const {
-  // Nominal types are move-only if declared as such.
-  if (getASTType()->isNoncopyable())
+  // Legacy check.
+  if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    return getASTType()->isNoncopyable() || isMoveOnlyWrapped();
+  }
+
+  // Anything within the move-only wrapper is move-only.
+  if (isMoveOnlyWrapped())
     return true;
 
+  auto ty = getASTType();
+
+  // All kinds of references are copyable.
+  if (isa<ReferenceStorageType>(ty))
+    return false;
 
   // TODO: Nonescaping closures ought to be treated as move-only in SIL.
   // They aren't marked move-only now, because the necessary move-only passes
@@ -1060,7 +1070,19 @@ bool SILType::isMoveOnly() const {
     return fnTy->isTrivialNoEscape();
   }
    */
-  return isMoveOnlyWrapped();
+  if (isa<SILFunctionType>(ty))
+    return false;
+
+  // Treat all other SIL-specific types as Copyable.
+  if (isa<SILBlockStorageType,
+          SILBoxType,
+          SILPackType,
+          SILTokenType>(ty)) {
+    return false;
+  }
+
+  // Finally, for other ordinary types, ask the AST type.
+  return ty->isNoncopyable();
 }
 
 

test/SILOptimizer/moveonly_computed_property.swift

@@ -1,4 +1,7 @@
-// RUN: %target-swift-frontend -emit-sil -verify %s
+// RUN: %target-swift-frontend -emit-sil -verify %s > /dev/null
+// RUN: %target-swift-frontend -enable-experimental-feature NoncopyableGenerics -emit-sil -verify %s > /dev/null
+
+// REQUIRES: asserts
 
 // Applying a computed property to a move-only field in a class should occur
 // entirely within a formal access to the class property. rdar://105794506

test/SILOptimizer/moveonly_generics_basic.swift

@@ -0,0 +1,72 @@
+// RUN: %target-swift-frontend %s -sil-verify-all -verify -emit-sil -enable-experimental-feature MoveOnlyPartialConsumption -enable-experimental-feature NoncopyableGenerics
+
+// REQUIRES: asserts
+
+/// MARK: types
+
+struct FileDescriptor: ~Copyable { let fd: Int = 0 }
+
+struct Wrap<T: ~Copyable>: ~Copyable {
+  var item: T
+  init(_ t: consuming T) { self.item = t }
+}
+extension Wrap: Copyable where T: Copyable {}
+
+/// MARK: utilities
+
+func borrowAny<T: ~Copyable>(_ t: borrowing T) {}
+
+/// MARK: tests
+
+func barebones() {
+  let nc = FileDescriptor() // expected-error {{'nc' consumed more than once}}
+  borrowAny(nc)
+  let _ = nc // expected-note {{consumed}}
+  let _ = nc // expected-note {{consumed}}
+
+  let cpWrap = Wrap(100)
+  borrowAny(cpWrap)
+  let _ = cpWrap
+  let _ = cpWrap
+
+  let ncWrap = Wrap(FileDescriptor()) // expected-error {{'ncWrap' consumed more than once}}
+  borrowAny(ncWrap)
+  let _ = ncWrap // expected-note {{consumed}}
+  let _ = ncWrap // expected-note {{consumed}}
+}
+
+func test1<T: ~Copyable>(_ t: consuming T, // expected-error {{'t' consumed more than once}}
+                                           // expected-error@-1 {{'t' used after consume}}
+                         _ borrowArg: borrowing T) -> Wrap<T> {
+                         // expected-error@-1 {{'borrowArg' is borrowed and cannot be consumed}}
+  borrowAny(t)
+  borrowAny(borrowArg)
+
+  let wrap1 = Wrap(t) // expected-note {{consumed}}
+  let _ = Wrap(t)     // expected-note 2{{consumed}}
+
+  let _ = Wrap(borrowArg) // expected-note {{consumed}}
+
+  borrowAny(t) // expected-note {{used}}
+  borrowAny(borrowArg)
+
+  return wrap1
+}
+
+func testWrap<T: ~Copyable>(_ x: borrowing Wrap<T>,
+                             // expected-error@-1 {{'x' is borrowed and cannot be consumed}}
+                            _ y: consuming Wrap<T>,
+                            _ new: () -> T) -> T {
+  _ = x.item // expected-note {{consumed}}
+
+  // expected-error@+1 {{'result' consumed more than once}}
+  let result = { (v: inout Wrap<T>) -> T in
+   let result = v.item
+   v.item = new()
+   return result
+  }(&y)
+
+  let _ = result // expected-note {{consumed}}
+
+  return result // expected-note {{consumed}}
+}