Don't let reflection handle noncopyable types yet.

We don't have any language or runtime support for noncopyable types as generic
or dynamic types yet, and existing reflection code almost certainly assumes it
can copy the values it's working with, and will trap or corrupt state if it does
so with noncopyable types. But a class can have noncopyable fields while the
type itself is copyable, and existing code assumes that it can use `Mirror` or
other reflection mechanisms to safely traverse the contents of an arbitrary
class.

Allow this sort of code to continue working, while still preparing for forward
compatibility with future runtimes that do support noncopyable generics, by
emitting the type references for fields using a function that probes the
address of a new symbol in the Swift runtime. The symbol will either be missing
or defined with an absolute address of zero in current or previous runtime
versions, but can be changed to a non-null address in the future.

Author: jckarter

lib/IRGen/GenReflection.cpp

@@ -264,6 +264,54 @@ getTypeRefByFunction(IRGenModule &IGM,
           ? genericEnv->mapTypeIntoContext(t)->getCanonicalType()
           : t;
 
+        // If a type is noncopyable, lie about the resolved type unless the
+        // runtime is sufficiently aware of noncopyable types.
+        if (substT->isPureMoveOnly()) {
+          // Darwin-based platforms have ABI stability, and we want binaries
+          // that use noncopyable types nongenerically today to be forward
+          // compatible with a future OS runtime that supports noncopyable
+          // generics. On other platforms, a new Swift compiler and runtime
+          // require recompilation anyway, so this dance is unnecessary, and
+          // for now, we can unconditionally lie.
+          bool useForwardCompatibility =
+            IGM.Context.LangOpts.Target.isOSDarwin();
+          
+          llvm::Instruction *br = nullptr;
+          llvm::BasicBlock *supportedBB = nullptr;
+          if (useForwardCompatibility) {
+            auto runtimeSupportsNoncopyableTypesSymbol
+              = IGM.Module.getOrInsertGlobal("swift_runtimeSupportsNoncopyableTypes",
+                                             IGM.Int8Ty);
+            cast<llvm::GlobalVariable>(runtimeSupportsNoncopyableTypesSymbol)
+              ->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
+              
+            auto runtimeSupportsNoncopyableTypes
+              = IGF.Builder.CreateIsNotNull(runtimeSupportsNoncopyableTypesSymbol,
+                                            "supports.noncopyable");
+            supportedBB = IGF.createBasicBlock("does.support.noncopyable");
+            auto unsupportedBB = IGF.createBasicBlock("does.not.support.noncopyable");
+            br = IGF.Builder.CreateCondBr(runtimeSupportsNoncopyableTypes,
+                                     supportedBB,
+                                     unsupportedBB);
+                                     
+            IGF.Builder.emitBlock(unsupportedBB);
+          }
+          
+          // If the runtime does not yet support noncopyable types, lie that the
+          // field is an empty tuple, so the runtime doesn't try to do anything
+          // with the actual value.
+          auto phonyRet = IGF.emitTypeMetadataRef(IGM.Context.TheEmptyTupleType);
+          IGF.Builder.CreateRet(phonyRet);
+
+          if (!useForwardCompatibility) {
+            goto done_building_function;
+          }
+          
+          // Emit the type metadata normally otherwise.
+          IGF.Builder.SetInsertPoint(br);
+          IGF.Builder.emitBlock(supportedBB);
+        }
+
         bindFromGenericRequirementsBuffer(
             IGF, requirements,
             Address(bindingsBufPtr, IGM.Int8Ty, IGM.getPointerAlignment()),
@@ -276,6 +324,7 @@ getTypeRefByFunction(IRGenModule &IGM,
         auto ret = IGF.emitTypeMetadataRef(substT);
         IGF.Builder.CreateRet(ret);
       }
+    done_building_function:
       // Form the mangled name with its relative reference.
       auto S = B.beginStruct();
       S.setPacked(true);
@@ -315,6 +364,21 @@ getTypeRefImpl(IRGenModule &IGM,
   case MangledTypeRefRole::FlatUnique:
     useFlatUnique = true;
     break;
+    
+  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
+    // support for noncopyable types as dynamic or generic types isn't yet
+    // implemented as of the writing of this comment. If the type is
+    // 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->isPureMoveOnly()) {
+      IGM.IRGen.noteUseOfTypeMetadata(type);
+      return getTypeRefByFunction(IGM, sig, type);
+    }
+    LLVM_FALLTHROUGH;
 
   case MangledTypeRefRole::DefaultAssociatedTypeWitness:
   case MangledTypeRefRole::Metadata:
@@ -724,14 +788,14 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
       if (type->isForeignReferenceType()) {
         auto opaqueType = type->getASTContext().getOpaquePointerType();
         // The standard library's Mirror demangles metadata from field
-        // descriptors, so use MangledTypeRefRole::Metadata to ensure
+        // descriptors, so use MangledTypeRefRole::FieldMetadata to ensure
         // runtime metadata is available.
-        addTypeRef(opaqueType, genericSig, MangledTypeRefRole::Metadata);
+        addTypeRef(opaqueType, genericSig, MangledTypeRefRole::FieldMetadata);
       } else {
         // The standard library's Mirror demangles metadata from field
-        // descriptors, so use MangledTypeRefRole::Metadata to ensure
+        // descriptors, so use MangledTypeRefRole::FieldMetadata to ensure
         // runtime metadata is available.
-        addTypeRef(type, genericSig, MangledTypeRefRole::Metadata);
+        addTypeRef(type, genericSig, MangledTypeRefRole::FieldMetadata);
       }
     }
 

lib/IRGen/IRGenMangler.cpp

@@ -300,6 +300,7 @@ mangleSymbolNameForSymbolicMangling(const SymbolicMangling &mangling,
     prefix = "default assoc type ";
     break;
 
+  case MangledTypeRefRole::FieldMetadata:
   case MangledTypeRefRole::Metadata:
   case MangledTypeRefRole::Reflection:
     prefix = "symbolic ";

lib/IRGen/IRGenModule.h

@@ -575,6 +575,10 @@ class TypeEntityReference {
 
 /// Describes the role of a mangled type reference string.
 enum class MangledTypeRefRole {
+  /// The mangled type reference is used for field metadata, which is used
+  /// by both in-process and out-of-process reflection, so still requires
+  /// referenced types' metadata to be fully emitted.
+  FieldMetadata,
   /// The mangled type reference is used for normal metadata.
   Metadata,
   /// The mangled type reference is used for reflection metadata.

lib/IRGen/MetadataRequest.cpp

@@ -377,6 +377,7 @@ llvm::Constant *IRGenModule::getAddrOfStringForTypeRef(
 
   case MangledTypeRefRole::Metadata:
   case MangledTypeRefRole::Reflection:
+  case MangledTypeRefRole::FieldMetadata:
     break;
   }
 

stdlib/public/runtime/Metadata.cpp

@@ -75,6 +75,19 @@ extern "C" void _objc_setClassCopyFixupHandler(void (* _Nonnull newFixupHandler)
 using namespace swift;
 using namespace metadataimpl;
 
+#if defined(__APPLE__)
+// Binaries using noncopyable types check the address of the symbol
+// `swift_runtimeSupportsNoncopyableTypes` before exposing any noncopyable
+// type metadata through in-process reflection, to prevent existing code
+// that expects all types to be copyable from crashing or causing bad behavior
+// by copying noncopyable types. The runtime does not yet support noncopyable
+// types, so we explicitly define this symbol to be zero for now. Binaries
+// weak-import this symbol so they will resolve it to a zero address on older
+// runtimes as well.
+__asm__("  .globl _swift_runtimeSupportsNoncopyableTypes\n");
+__asm__(".set _swift_runtimeSupportsNoncopyableTypes, 0\n");
+#endif
+
 // GenericParamDescriptor is a single byte, so while it's difficult to
 // imagine needing even a quarter this many generic params, there's very
 // little harm in doing it.

test/Interpreter/moveonly_field_in_class_reflection.swift

@@ -0,0 +1,44 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-move-only)
+// REQUIRES: executable_test
+
+// Verify that iterating through the fields of an object whose class has
+// a move-only field does not trap from trying to reflect and copy those
+// move-only fields.
+
+@_moveOnly
+public struct MO {
+    var x: Int8 = 0
+    var y: Int8 = 0
+    var z: Int8 = 0
+
+    deinit { print("destroyed MO") }
+}
+
+public class MOHaver {
+    var s: String = "hello"
+    var mo: MO = MO()
+    var b: Int8 = 42
+    var c: Any.Type = MOHaver.self
+}
+
+// CHECK-LABEL: doing nongeneric
+print("doing nongeneric")
+do {
+    let k = MOHaver()
+
+    let mirror = Mirror(reflecting: k)
+    // CHECK-NEXT: s: hello
+    // Whether this actually prints the value of `k.mo` or not is irrelevant
+    // to the test; we care that attempting to reflect the field does not trap
+    // copying a noncopyable field.
+    // CHECK-NEXT: mo:
+    // CHECK-NEXT: b: 42
+    // CHECK-NEXT: c: {{.*}}.MOHaver
+    for c in mirror.children {
+        print("\(c.label!): \(c.value)")
+    }
+    // CHECK-NEXT: destroyed MO
+}
+// CHECK-NEXT: done with nongeneric
+print("done with nongeneric")
+