Print a hint about using frame variable when self cannot be reconstru…

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp

@@ -693,8 +693,10 @@ static llvm::Optional<llvm::Error> AddVariableInfo(
     // Not realizing self is a fatal error for an expression and the
     // Swift compiler error alone is not particularly useful.
     if (is_self)
-      return make_error<StringError>(inconvertibleErrorCode(),
-                                     "Couldn't realize type of self.");
+      return make_error<StringError>(
+          inconvertibleErrorCode(),
+          "Couldn't realize Swift AST type of self. Hint: using `v` to "
+          "directly inspect variables and fields may still work.");
     return {};
   }
 

lldb/test/API/lang/swift/private_discriminator/Builder.swift

@@ -0,0 +1,11 @@
+import Generic
+
+private class Private{
+  fileprivate typealias MyNumber = Int
+  fileprivate init() { n = MyNumber(23) }
+  let n : MyNumber
+}
+
+public func getObj() -> some P {
+  return S(Private())
+}

lldb/test/API/lang/swift/private_discriminator/Generic.swift

@@ -0,0 +1,25 @@
+public protocol P {
+  func action()
+}
+
+public struct S<T> : P, CustomDebugStringConvertible {
+  let m_t : T
+  public var debugDescription: String { return "S { m_t = \(m_t) }" }
+  public init(_ t : T) { m_t = t }
+  public func action() {
+    // self cannot be resolved in the expression evaluator,
+    // because there is no AST type for it.
+    let visible = Visible()
+    print("break here")
+  }
+}
+
+private struct Visible {
+  let n = 42
+  public init() {}
+}
+
+public func sanity_check() {
+  let visible = Visible()
+  print("break here")
+}

lldb/test/API/lang/swift/private_discriminator/Makefile

@@ -0,0 +1,27 @@
+SWIFT_SOURCES := main.swift
+SWIFTFLAGS_EXTRAS = -I$(BUILDDIR)
+LD_EXTRAS = -L$(BUILDDIR) -lGeneric -lBuilder
+
+all: libBuilder.dylib $(EXE)
+
+include Makefile.rules
+
+libGeneric.dylib: $(SRCDIR)/Generic.swift
+	$(MAKE) -f $(MAKEFILE_RULES) \
+		DYLIB_ONLY=YES \
+		DYLIB_NAME=Generic \
+		DYLIB_SWIFT_SOURCES=Generic.swift \
+		DYLIB_MODULENAME=Generic \
+		SWIFTFLAGS_EXTRAS=-enable-library-evolution
+
+libBuilder.dylib: $(SRCDIR)/Builder.swift libGeneric.dylib
+	$(MAKE) -f $(MAKEFILE_RULES) \
+		DYLIB_ONLY=YES \
+		DYLIB_NAME=Builder \
+		DYLIB_SWIFT_SOURCES=Builder.swift \
+		DYLIB_MODULENAME=Builder \
+		DYLIB_HIDE_SWIFTMODULE=YES \
+		SWIFTFLAGS_EXTRAS="-I$(BUILDDIR)" \
+		LD_EXTRAS="-L$(BUILDDIR) -lGeneric" \
+		MAKE_DSYM=NO
+	rm -f $(BUILDDIR)/Builder.swiftmodule

lldb/test/API/lang/swift/private_discriminator/TestSwiftPrivateDiscriminator.py

@@ -0,0 +1,32 @@
+import lldb
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbtest as lldbtest
+import lldbsuite.test.lldbutil as lldbutil
+import unittest2
+
+
+class TestSwiftPrivateDiscriminator(lldbtest.TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+    mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+    @swiftTest
+    # FIXME: The only reason this doesn't work on Linux is because the
+    # dylib hasn't been loaded when run_to_source_breakpoint wants to
+    # set the breakpoints.
+    @skipUnlessDarwin
+    def test(self):
+        """Test what happens when a private type cannot be reconstructed in the AST."""
+        self.build()
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, 'break here', lldb.SBFileSpec('Generic.swift'),
+            extra_images=['Generic', 'Builder'])
+
+        self.expect("frame var -d run -- self",
+                    substrs=['Builder.Private', 'n', '23'])
+        self.expect("p self", error=True, substrs=["Hint"])
+        process.Continue()
+        # This should work.
+        self.expect("frame var -d run -- visible",
+                    substrs=['Generic.Visible', 'n', '42'])
+        self.expect("p visible", substrs=['Generic.Visible', 'n', '42'])

lldb/test/API/lang/swift/private_discriminator/main.swift

@@ -0,0 +1,5 @@
+import Builder
+import Generic
+
+Builder.getObj().action()
+sanity_check()