Merge pull request #2347 from apple/stdlib-optional-custom-reflectable

Author: swift-ci

stdlib/public/core/Optional.swift

@@ -103,6 +103,20 @@ extension Optional : CustomDebugStringConvertible {
   }
 }
 
+extension Optional : CustomReflectable {
+  public var customMirror: Mirror {
+    switch self {
+    case .some(let value):
+      return Mirror(
+        self,
+        children: [ "some": value ],
+        displayStyle: .optional)
+    case .none:
+      return Mirror(self, children: [:], displayStyle: .optional)
+    }
+  }
+}
+
 @_transparent
 @warn_unused_result
 public // COMPILER_INTRINSIC

test/1_stdlib/Optional.swift

@@ -76,6 +76,50 @@ OptionalTests.test("Equatable") {
   expectEqual([false, true, false, false, true, false], testRelation(<))
 }
 
+OptionalTests.test("CustomReflectable") {
+  // Test with a non-refcountable type.
+  do {
+    let value: OpaqueValue<Int>? = nil
+    var output = ""
+    dump(value, to: &output)
+    expectEqual("- nil\n", output)
+    expectEqual(.optional, Mirror(reflecting: value).displayStyle)
+  }
+  do {
+    let value: OpaqueValue<Int>? = OpaqueValue(1010)
+    var output = ""
+    dump(value, to: &output)
+    let expected =
+      "▿ Optional(StdlibUnittest.OpaqueValue<Swift.Int>(value: 1010, identity: 0))\n" +
+      "  ▿ some: StdlibUnittest.OpaqueValue<Swift.Int>\n" +
+      "    - value: 1010\n" +
+      "    - identity: 0\n"
+    expectEqual(expected, output)
+    expectEqual(.optional, Mirror(reflecting: value).displayStyle)
+  }
+  // Test with a reference type.
+  do {
+    let value: LifetimeTracked? = nil
+    var output = ""
+    dump(value, to: &output)
+    expectEqual("- nil\n", output)
+    expectEqual(.optional, Mirror(reflecting: value).displayStyle)
+  }
+  do {
+    let value: LifetimeTracked? = LifetimeTracked(1010)
+    var output = ""
+    dump(value, to: &output)
+    let expected =
+      "▿ Optional(1010)\n" +
+      "  ▿ some: 1010 #0\n" +
+      "    - value: 1010\n" +
+      "    - identity: 0\n" +
+      "    - serialNumber: 1\n"
+    expectEqual(expected, output)
+    expectEqual(.optional, Mirror(reflecting: value).displayStyle)
+  }
+}
+
 struct X {}
 class C {}
 class D {}

test/1_stdlib/Reflection.swift

@@ -148,13 +148,6 @@ switch true.customPlaygroundQuickLook {
   default: print("wrong quicklook type")
 }
 
-// CHECK-NEXT: Optional("Hello world")
-// CHECK-NEXT:   some: "Hello world"
-dump(Optional<String>("Hello world"))
-// CHECK-NEXT: - nil
-let noneString: String? = nil
-dump(noneString)
-
 let intArray = [1,2,3,4,5]
 // CHECK-NEXT: 5 elements
 // CHECK-NEXT: 1

test/IDE/complete_generic_optional.swift

@@ -11,6 +11,6 @@ struct Foo<T> {
 // SR-642 Code completion does not instantiate generic arguments of a type wrapped in an optional
 let x: Foo<Bar>? = Foo<Bar>()
 x.#^FOO_OPTIONAL_1^#
-// FOO_OPTIONAL_1: Begin completions, 5 items
+// FOO_OPTIONAL_1: Begin completions, 6 items
 // FOO_OPTIONAL_1-DAG: Decl[InstanceMethod]/CurrNominal/Erase[1]: ?.myFunction({#(foobar): Bar#})[#Void#]; name=myFunction(foobar: Bar)
 // FOO_OPTIONAL_1: End completions