stdlib: remove _Reflectable

Author: gribozavr

include/swift/Runtime/Reflection.h

@@ -44,9 +44,8 @@ struct MirrorReturn {
 
 /// func reflect<T>(x: T) -> Mirror
 ///
-/// Produce a mirror for any value. If the value's type conforms to _Reflectable,
-/// invoke its _getMirror() method; otherwise, fall back to an implementation
-/// in the runtime that structurally reflects values of any type.
+/// Produce a mirror for any value.  The runtime produces a mirror that
+/// structurally reflects values of any type.
 SWIFT_RUNTIME_EXPORT
 extern "C" MirrorReturn
 swift_reflectAny(OpaqueValue *value, const Metadata *T);

lib/IDE/CodeCompletion.cpp

@@ -3090,8 +3090,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       return false;
     }
 
-    // Ignore the internal members of Optional, like getLogicValue() and
-    // _getMirror().
+    // Ignore the members of Optional, like getLogicValue(), map(), and
+    // flatMap().
+    //
     // These are not commonly used and cause noise and confusion when showing
     // among the members of the underlying type. If someone really wants to
     // use them they can write them directly.

stdlib/public/core/Reflection.swift

@@ -10,17 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Customizes the result of `_reflect(x)`, where `x` is a conforming
-/// type.
-public protocol _Reflectable {
-  // The runtime has inappropriate knowledge of this protocol and how its
-  // witness tables are laid out. Changing this protocol requires a
-  // corresponding change to Reflection.cpp.
-
-  /// Returns a mirror that reflects `self`.
-  func _getMirror() -> _Mirror
-}
-
 /// A unique identifier for a class instance or metatype.
 ///
 /// In Swift, only class instances and metatypes have unique identities. There
@@ -137,10 +126,8 @@ func _getSummary<T>(_ out: UnsafeMutablePointer<String>, x: T) {
   out.initialize(with: String(reflecting: x))
 }
 
-/// Produce a mirror for any value. If the value's type conforms to
-/// `_Reflectable`, invoke its `_getMirror()` method; otherwise, fall back
-/// to an implementation in the runtime that structurally reflects values
-/// of any type.
+/// Produce a mirror for any value.  The runtime produces a mirror that
+/// structurally reflects values of any type.
 @_silgen_name("swift_reflectAny")
 internal func _reflect<T>(_ x: T) -> _Mirror
 

stdlib/public/core/StaticString.swift

@@ -251,10 +251,6 @@ public struct StaticString
   public var debugDescription: String {
     return self.description.debugDescription
   }
-
-  public func _getMirror() -> _Mirror {
-    return _reflect(self.description)
-  }
 }
 
 extension StaticString {

stdlib/public/runtime/Reflection.mm

@@ -60,12 +60,6 @@ - (id)debugQuickLookObject;
   ~AnyReturn() { }
 };
 
-/// A _Reflectable witness table.
-struct _ReflectableWitnessTable {
-  /// func _getMirror() -> Mirror
-  Mirror (*getMirror)(OpaqueValue *self, const Metadata *Self);
-};
-  
 struct MagicMirrorData;
 
 struct String;
@@ -116,10 +110,7 @@ explicit String(NSString *s)
 
 /// A Mirror witness table for use by MagicMirror.
 struct MirrorWitnessTable;
-  
-/// The protocol descriptor for _Reflectable from the stdlib.
-extern "C" const ProtocolDescriptor _TMps12_Reflectable;
-  
+
 // This structure needs to mirror _MagicMirrorData in the stdlib.
 struct MagicMirrorData {
   /// The owner pointer for the buffer the value lives in. For class values
@@ -313,8 +304,7 @@ void swift_MagicMirrorData_summary(const Metadata *T, String *result) {
   return swift_getObjCClassMetadata(isa);
 }
 
-static std::tuple<const _ReflectableWitnessTable *, const Metadata *,
-                  const OpaqueValue *>
+static std::tuple<const Metadata *, const OpaqueValue *>
 getReflectableConformance(const Metadata *T, const OpaqueValue *Value) {
 recur:
   // If the value is an existential container, look through it to reflect the
@@ -335,24 +325,8 @@ void swift_MagicMirrorData_summary(const Metadata *T, String *result) {
   case MetadataKind::Existential: {
     auto existential
       = static_cast<const ExistentialTypeMetadata *>(T);
-    
-    // If the existential happens to include the _Reflectable protocol, use
-    // the witness table from the container.
-    unsigned wtOffset = 0;
-    for (unsigned i = 0; i < existential->Protocols.NumProtocols; ++i) {
-      if (existential->Protocols[i] == &_TMps12_Reflectable) {
-        return std::make_tuple(
-            reinterpret_cast<const _ReflectableWitnessTable*>(
-              existential->getWitnessTable(Value, wtOffset)),
-            existential->getDynamicType(Value),
-            existential->projectValue(Value));
-      }
-      if (existential->Protocols[i]->Flags.needsWitnessTable())
-        ++wtOffset;
-    }
-    
-    // Otherwise, unwrap the existential container and do a runtime lookup on
-    // its contained value as usual.
+
+    // Unwrap the existential container.
     T = existential->getDynamicType(Value);
     Value = existential->projectValue(Value);
 
@@ -372,12 +346,8 @@ void swift_MagicMirrorData_summary(const Metadata *T, String *result) {
   case MetadataKind::ErrorObject:
     swift::crash("Swift mirror lookup failure");
   }
-  
-  return std::make_tuple(
-      reinterpret_cast<const _ReflectableWitnessTable*>(
-        swift_conformsToProtocol(T, &_TMps12_Reflectable)),
-      T,
-      Value);
+
+  return std::make_tuple(T, Value);
 }
 
 /// Produce a mirror for any value, like swift_reflectAny, but do not consume
@@ -389,20 +359,11 @@ void swift_MagicMirrorData_summary(const Metadata *T, String *result) {
 static Mirror reflect(HeapObject *owner,
                       const OpaqueValue *value,
                       const Metadata *T) {
-  const _ReflectableWitnessTable *witness;
   const Metadata *mirrorType;
   const OpaqueValue *mirrorValue;
-  std::tie(witness, mirrorType, mirrorValue)
-    = getReflectableConformance(T, value);
-  
-  // Use the _Reflectable conformance if the object has one.
-  if (witness) {
-    auto result =
-    witness->getMirror(const_cast<OpaqueValue*>(mirrorValue), mirrorType);
-    swift_release(owner);
-    return MirrorReturn(result);
-  }
-  // Otherwise, fall back to MagicMirror.
+  std::tie(mirrorType, mirrorValue) = getReflectableConformance(T, value);
+
+  // Use MagicMirror.
   // Consumes 'owner'.
   Mirror result;
   ::new (&result) MagicMirror(owner, mirrorValue, mirrorType);
@@ -572,20 +533,15 @@ static void getEnumMirrorInfo(const OpaqueValue *value,
 extern "C"
 const char *swift_EnumCaseName(OpaqueValue *value, const Metadata *type) {
   // Build a magic mirror. Unconditionally destroy the value at the end.
-  const _ReflectableWitnessTable *witness;
   const Metadata *mirrorType;
   const OpaqueValue *cMirrorValue;
-  std::tie(witness, mirrorType, cMirrorValue) = getReflectableConformance(type, value);
-  
+  std::tie(mirrorType, cMirrorValue) = getReflectableConformance(type, value);
+
   OpaqueValue *mirrorValue = const_cast<OpaqueValue*>(cMirrorValue);
   Mirror mirror;
 
-  if (witness) {
-    mirror = witness->getMirror(mirrorValue, mirrorType);
-  } else {
-    bool take = mirrorValue == value;
-    ::new (&mirror) MagicMirror(mirrorValue, mirrorType, take);
-  }
+  bool take = mirrorValue == value;
+  ::new (&mirror) MagicMirror(mirrorValue, mirrorType, take);
 
   MagicMirror *theMirror = reinterpret_cast<MagicMirror *>(&mirror);
   MagicMirrorData data = theMirror->Data;
@@ -1158,31 +1114,19 @@ static Mirror ObjC_getMirrorForSuperclass(Class sup,
 
 /// func reflect<T>(x: T) -> Mirror
 ///
-/// Produce a mirror for any value. If the value's type conforms to _Reflectable,
-/// invoke its _getMirror() method; otherwise, fall back to an implementation
-/// in the runtime that structurally reflects values of any type.
+/// Produce a mirror for any value.  The runtime produces a mirror that
+/// structurally reflects values of any type.
 ///
 /// This function consumes 'value', following Swift's +1 convention for "in"
 /// arguments.
 MirrorReturn swift::swift_reflectAny(OpaqueValue *value, const Metadata *T) {
-  const _ReflectableWitnessTable *witness;
   const Metadata *mirrorType;
   const OpaqueValue *cMirrorValue;
-  std::tie(witness, mirrorType, cMirrorValue)
-    = getReflectableConformance(T, value);
-  
+  std::tie(mirrorType, cMirrorValue) = getReflectableConformance(T, value);
+
   OpaqueValue *mirrorValue = const_cast<OpaqueValue*>(cMirrorValue);
-  
-  // Use the _Reflectable conformance if the object has one.
-  if (witness) {
-    auto result = witness->getMirror(mirrorValue, mirrorType);
-    // 'self' of witnesses is passed at +0, so we still need to consume the
-    // value.
-    T->vw_destroy(value);
-    return MirrorReturn(result);
-  }
-  
-  // Otherwise, fall back to MagicMirror.
+
+  // Use MagicMirror.
   Mirror result;
   // Take the value, unless we projected a subvalue from it. We don't want to
   // deal with partial value deinitialization.