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

include/swift/Basic/LangOptions.h

@@ -19,7 +19,6 @@
 #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"
@@ -29,6 +28,7 @@
 #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.
-    FixedBitSet<numFeatures(), Feature> Features;
+    llvm::SmallSet<Feature, 2> Features;
 
     /// Temporary flag to support LLDB's transition to using \c Features.
     bool EnableBareSlashRegexLiterals = false;

include/swift/SIL/SILType.h

@@ -862,6 +862,10 @@ 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,16 +405,11 @@ 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.
-    Type contextualTy = type;
-    if (sig)
-      contextualTy = sig.getGenericEnvironment()->mapTypeIntoContext(type);
-
-    if (contextualTy->isNoncopyable()) {
+    if (type->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,9 +387,8 @@ AllocBoxInst::AllocBoxInst(SILDebugLocation Loc, CanSILBoxType BoxType,
   sharedUInt8().AllocBoxInst.reflection = reflection;
 
   // If we have a noncopyable type, always set uses mvoeable value debug info.
-  auto fieldTy = getSILBoxFieldType(F.getTypeExpansionContext(), BoxType,
-                                    F.getModule().Types, 0);
-  usesMoveableValueDebugInfo |= fieldTy.isMoveOnly();
+  usesMoveableValueDebugInfo |=
+      BoxType->getLayout()->getFields()[0].getObjectType().isMoveOnly();
 
   sharedUInt8().AllocBoxInst.usesMoveableValueDebugInfo =
       usesMoveableValueDebugInfo;

lib/SIL/IR/SILType.cpp

@@ -1044,20 +1044,10 @@ SILType::getSingletonAggregateFieldType(SILModule &M,
 }
 
 bool SILType::isMoveOnly() const {
-  // Legacy check.
-  if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    return getASTType()->isNoncopyable() || isMoveOnlyWrapped();
-  }
-
-  // Anything within the move-only wrapper is move-only.
-  if (isMoveOnlyWrapped())
+  // Nominal types are move-only if declared as such.
+  if (getASTType()->isNoncopyable())
     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
@@ -1070,19 +1060,7 @@ bool SILType::isMoveOnly() const {
     return fnTy->isTrivialNoEscape();
   }
    */
-  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();
+  return isMoveOnlyWrapped();
 }
 
 

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