Merge pull request #69591 from kavon/noncopyable-generics-pt3

[NoncopyableGenerics] Basic end-to-end testing (without stdlib).

Author: swift-ci

include/swift/Basic/LangOptions.h

@@ -19,6 +19,7 @@
 #define SWIFT_BASIC_LANGOPTIONS_H
 
 #include "swift/Basic/Feature.h"
+#include "swift/Basic/FixedBitSet.h"
 #include "swift/Basic/FunctionBodySkipping.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Version.h"
@@ -28,7 +29,6 @@
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -429,7 +429,7 @@ namespace swift {
     bool EnableNewOperatorLookup = false;
 
     /// The set of features that have been enabled.
-    llvm::SmallSet<Feature, 2> Features;
+    FixedBitSet<numFeatures(), Feature> Features;
 
     /// Temporary flag to support LLDB's transition to using \c Features.
     bool EnableBareSlashRegexLiterals = false;

include/swift/SIL/SILType.h

@@ -862,10 +862,6 @@ class SILType {
     return getSILBoxFieldType(fn).isMoveOnly();
   }
 
-  bool isBoxedNonCopyableType(const SILFunction &fn) const {
-    return isBoxedNonCopyableType(&fn);
-  }
-
   bool isBoxedMoveOnlyWrappedType(const SILFunction *fn) const {
     if (!this->is<SILBoxType>())
       return false;

lib/IRGen/GenReflection.cpp

@@ -396,7 +396,7 @@ getTypeRefImpl(IRGenModule &IGM,
     useFlatUnique = true;
     break;
 
-  case MangledTypeRefRole::FieldMetadata:
+  case MangledTypeRefRole::FieldMetadata: {
     // We want to keep fields of noncopyable type from being exposed to
     // in-process runtime reflection libraries in older Swift runtimes, since
     // they more than likely assume they can copy field values, and the language
@@ -405,11 +405,16 @@ getTypeRefImpl(IRGenModule &IGM,
     // noncopyable, use a function to emit the type ref which will look for a
     // signal from future runtimes whether they support noncopyable types before
     // exposing their metadata to them.
-    if (type->isNoncopyable()) {
+    Type contextualTy = type;
+    if (sig)
+      contextualTy = sig.getGenericEnvironment()->mapTypeIntoContext(type);
+
+    if (contextualTy->isNoncopyable()) {
       IGM.IRGen.noteUseOfTypeMetadata(type);
       return getTypeRefByFunction(IGM, sig, type);
     }
-    LLVM_FALLTHROUGH;
+  }
+  LLVM_FALLTHROUGH;
 
   case MangledTypeRefRole::DefaultAssociatedTypeWitness:
   case MangledTypeRefRole::Metadata:

lib/SIL/IR/SILInstructions.cpp

@@ -387,8 +387,9 @@ AllocBoxInst::AllocBoxInst(SILDebugLocation Loc, CanSILBoxType BoxType,
   sharedUInt8().AllocBoxInst.reflection = reflection;
 
   // If we have a noncopyable type, always set uses mvoeable value debug info.
-  usesMoveableValueDebugInfo |=
-      BoxType->getLayout()->getFields()[0].getObjectType().isMoveOnly();
+  auto fieldTy = getSILBoxFieldType(F.getTypeExpansionContext(), BoxType,
+                                    F.getModule().Types, 0);
+  usesMoveableValueDebugInfo |= fieldTy.isMoveOnly();
 
   sharedUInt8().AllocBoxInst.usesMoveableValueDebugInfo =
       usesMoveableValueDebugInfo;

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();
 }
 
 

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -1062,7 +1062,7 @@ specializeApplySite(SILOptFunctionBuilder &FuncBuilder, ApplySite Apply,
     // boxes, convert them from having escaping to having non-escaping
     // semantics.
     for (unsigned index : PromotedCalleeArgIndices) {
-      if (F->getArgument(index)->getType().isBoxedNonCopyableType(*F)) {
+      if (F->getArgument(index)->getType().isBoxedNonCopyableType(F)) {
         auto boxType = F->getArgument(index)->getType().castTo<SILBoxType>();
         bool isMutable = boxType->getLayout()->getFields()[0].isMutable();
         auto checkKind = isMutable ? MarkUnresolvedNonCopyableValueInst::

lib/Sema/TypeCheckDecl.cpp

@@ -944,7 +944,9 @@ bool HasNoncopyableAnnotationRequest::evaluate(Evaluator &evaluator, TypeDecl *d
 
   // Handle the legacy '@_moveOnly' attribute
   if (decl->getAttrs().hasAttribute<MoveOnlyAttr>()) {
-    assert(isa<StructDecl>(decl) || isa<EnumDecl>(decl));
+    assert(isa<StructDecl>(decl) || isa<EnumDecl>(decl)
+               || (ctx.LangOpts.hasFeature(Feature::MoveOnlyClasses)
+                   && isa<ClassDecl>(decl)));
     return true;
   }
 

test/Interpreter/moveonly_generics.swift

@@ -0,0 +1,117 @@
+// RUN: %target-run-simple-swift(-Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics)
+// RUN: %target-run-simple-swift(-O -Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics)
+
+// REQUIRES: executable_test
+// REQUIRES: asserts
+
+// Needed due to limitations of autoclosures and noncopyable types.
+func eagerAssert(_ b: Bool, _ line: Int = #line) {
+  guard b else { fatalError("assertion failure on line \(line)") }
+}
+
+///---------------------
+/// MARK: a Swift x Haskell limited-edition stdlib
+/// ---------------------
+
+
+
+/// MARK: Ord aka 'Comparable'
+protocol Ord: ~Copyable {
+  func compare(_ other: borrowing Self) -> Ordering
+}
+
+enum Ordering {
+  case LT
+  case EQ
+  case GT
+
+  static func compare<T: Comparable>(_ a: borrowing T, _ b: borrowing T) -> Ordering {
+    if (a < b) { return .LT }
+    if (a > b) { return .GT }
+    eagerAssert(a == b)
+    return .EQ
+  }
+}
+
+extension Ord {
+  static func <(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
+    return a.compare(b) == .LT
+  }
+  static func <=(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
+    return !(a > b)
+  }
+  static func >(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
+    return a.compare(b) == .GT
+  }
+  static func >=(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
+    return !(a < b)
+  }
+  static func ==(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
+    a.compare(b) == .EQ
+  }
+  static func !=(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
+    !(a == b)
+  }
+}
+
+/// MARK: Maybe aka 'Optional'
+enum Maybe<Val: ~Copyable>: ~Copyable {
+  case just(Val)
+  case none
+
+  // NOTE: a 'consuming' version of the unfortunately 'borrowing' map from the stdlib.
+  consuming func consumingMap<U: ~Copyable>(_ fn: (consuming Val) throws -> U) rethrows -> Maybe<U> {
+    // rdar://117638878 (MoveOnlyAddressChecker crashes with generic associated value in enum)
+    fatalError("need to fix rdar://117638878")
+//     return switch consume self {
+//       case let .just(val): .just(try fn(val))
+//       case .none: .none
+//     }
+  }
+}
+
+// NOTE: temporary
+extension Maybe: Copyable where Val: Copyable {}
+
+
+/// MARK: beginning of tests
+
+struct FileDescriptor: ~Copyable, Ord {
+  let id: Int
+
+  func compare(_ other: borrowing FileDescriptor) -> Ordering {
+    return .compare(id, other.id)
+  }
+
+  deinit { print("calling deinit!") }
+}
+
+class Shared<T: ~Copyable> {
+  let value: T
+  init(_ val: consuming T) { self.value = val }
+  func borrow<V>(_ f: (borrowing T) throws -> V) rethrows -> V {
+    return try f(value)
+  }
+}
+
+defer { testOrd() }
+func testOrd() {
+  let stderr = Shared(FileDescriptor(id: 1))
+  let stdout = Shared(FileDescriptor(id: 0))
+  stdout.borrow { out in
+    stderr.borrow { err in
+      eagerAssert(err > out)
+      eagerAssert(out < err)
+      eagerAssert(out != err)
+    }
+  }
+}
+
+defer { testMaybe() }
+func testMaybe() {
+  let mayb = Maybe.just(FileDescriptor(id: 0));
+  switch consume mayb {
+    case let .just(fd): eagerAssert(fd.id == 0)
+    case .none: eagerAssert(false)
+  }
+}