Display generic function type parameters in backtraces.

This patch changes the behavior of SwiftLanguage::GetFunctionDisplayName()
so it now:
- (if exe_ctx && sc available) does generic parameter binding
- (if only sc availble) shows the archetype name
- the letter τ will now only appear if neither no context whatsover is available
- (drive by) omits self

rdar://126883922

Author: adrian-prantl

lldb/include/lldb/Symbol/Function.h

@@ -537,7 +537,7 @@ class Function : public UserID, public SymbolContextScope {
 
   ConstString GetNameNoArguments(const SymbolContext *sc = nullptr) const;
 
-  ConstString GetDisplayName(const SymbolContext *sc = nullptr) const;
+  ConstString GetDisplayName() const;
 
   const Mangled &GetMangled() const { return m_mangled; }
 

lldb/source/Plugins/Language/Swift/SwiftLanguage.cpp

@@ -1207,7 +1207,8 @@ bool SwiftLanguage::IsSourceFile(llvm::StringRef file_path) const {
   return file_path.endswith(".swift");
 }
 
-std::vector<FormattersMatchCandidate> SwiftLanguage::GetPossibleFormattersMatches(
+std::vector<FormattersMatchCandidate>
+SwiftLanguage::GetPossibleFormattersMatches(
     ValueObject &valobj, lldb::DynamicValueType use_dynamic) {
   std::vector<FormattersMatchCandidate> result;
 
@@ -1643,21 +1644,24 @@ bool SwiftLanguage::GetFunctionDisplayName(
       return false;
     if (sc->function->GetLanguage() != eLanguageTypeSwift)
       return false;
-    ConstString cs = sc->function->GetDisplayName(sc);
-    if (!cs)
+    std::string display_name = SwiftLanguageRuntime::DemangleSymbolAsString(
+        sc->function->GetMangled().GetMangledName().GetStringRef(),
+        SwiftLanguageRuntime::eSimplified, sc, exe_ctx);
+    if (display_name.empty())
       return false;
-    s.Printf("%s", cs.AsCString());
+    s << display_name;
     return true;
   }
   case Language::FunctionNameRepresentation::eNameWithArgs: {
     if (!sc->function)
       return false;
     if (sc->function->GetLanguage() != eLanguageTypeSwift)
       return false;
-    ConstString cs = sc->function->GetDisplayName(sc);
-    if (!cs)
+    std::string display_name = SwiftLanguageRuntime::DemangleSymbolAsString(
+        sc->function->GetMangled().GetMangledName().GetStringRef(),
+        SwiftLanguageRuntime::eSimplified, sc, exe_ctx);
+    if (display_name.empty())
       return false;
-    const char *cstr = cs.AsCString();
     ExecutionContextScope *exe_scope =
         exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL;
     const InlineFunctionInfo *inline_info = NULL;
@@ -1680,25 +1684,26 @@ bool SwiftLanguage::GetFunctionDisplayName(
     }
 
     if (inline_info) {
-      s.PutCString(cstr);
+      s << display_name;
       s.PutCString(" [inlined] ");
-      cstr = inline_info->GetName().GetCString();
+      display_name = inline_info->GetName();
     }
 
     VariableList args;
     if (variable_list_sp)
       variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
                                                  args);
     if (args.GetSize() == 0) {
-      s.PutCString(cstr);
+      s << display_name;
       return true;
     }
+    const char *cstr = display_name.data();
     const char *open_paren = strchr(cstr, '(');
     const char *close_paren = nullptr;
     const char *generic = strchr(cstr, '<');
-    // if before the arguments list begins there is a template sign
+    // If before the arguments list begins there is a template sign
     // then scan to the end of the generic args before you try to find
-    // the arguments list
+    // the arguments list.
     if (generic && open_paren && generic < open_paren) {
       int generic_depth = 1;
       ++generic;
@@ -1720,7 +1725,7 @@ bool SwiftLanguage::GetFunctionDisplayName(
     if (open_paren)
       s.Write(cstr, open_paren - cstr + 1);
     else {
-      s.PutCString(cstr);
+      s << display_name;
       s.PutChar('(');
     }
     const size_t num_args = args.GetSize();
@@ -1730,6 +1735,8 @@ bool SwiftLanguage::GetFunctionDisplayName(
       VariableSP var_sp(args.GetVariableAtIndex(arg_idx));
       ValueObjectSP var_value_sp(
           ValueObjectVariable::Create(exe_scope, var_sp));
+      if (!var_sp || !var_value_sp || var_sp->IsArtificial())
+        continue;
       StreamString ss;
       const char *var_representation = nullptr;
       const char *var_name = var_value_sp->GetName().GetCString();

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h

@@ -141,9 +141,10 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   IsSwiftAsyncAwaitResumePartialFunctionSymbol(llvm::StringRef name);
 
   enum DemangleMode { eSimplified, eTypeName, eDisplayTypeName };
-  static std::string DemangleSymbolAsString(llvm::StringRef symbol,
-                                            DemangleMode mode,
-                                            const SymbolContext *sc = nullptr);
+  static std::string
+  DemangleSymbolAsString(llvm::StringRef symbol, DemangleMode mode,
+                         const SymbolContext *sc = nullptr,
+                         const ExecutionContext *exe_ctx = nullptr);
 
   /// Demangle a symbol to a swift::Demangle node tree.
   ///
@@ -246,7 +247,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   /// Populate a map with the names of all archetypes in a function's generic
   /// context.
   static void GetGenericParameterNamesForFunction(
-      const SymbolContext &sc,
+      const SymbolContext &sc, const ExecutionContext *exe_ctx,
       llvm::DenseMap<ArchetypePath, llvm::StringRef> &dict);
 
   /// Invoke callback for each DependentGenericParamType.

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeNames.cpp

@@ -642,7 +642,7 @@ bool SwiftLanguageRuntime::IsSwiftMangledName(llvm::StringRef name) {
 }
 
 void SwiftLanguageRuntime::GetGenericParameterNamesForFunction(
-    const SymbolContext &const_sc,
+    const SymbolContext &const_sc, const ExecutionContext *exe_ctx,
     llvm::DenseMap<SwiftLanguageRuntime::ArchetypePath, StringRef> &dict) {
   // This terrifying cast avoids having too many differences with llvm.org.
   SymbolContext &sc = const_cast<SymbolContext &>(const_sc);
@@ -682,16 +682,47 @@ void SwiftLanguageRuntime::GetGenericParameterNamesForFunction(
     if (!name.empty())
       continue;
 
-    Type *archetype = var_sp->GetType();
-    if (!archetype)
-      continue;
+    ConstString type_name;
 
-    dict.insert({{depth, index}, archetype->GetName().GetStringRef()});
+    // Try to get bind the dynamic type from the exe_ctx.
+    while (exe_ctx) {
+      auto *frame = exe_ctx->GetFramePtr();
+      auto *target = exe_ctx->GetTargetPtr();
+      auto *process = exe_ctx->GetProcessPtr();
+      auto *runtime = SwiftLanguageRuntime::Get(process);
+      if (!frame || !target || !process || !runtime)
+        break;
+      auto type_system_or_err =
+        target->GetScratchTypeSystemForLanguage(eLanguageTypeSwift);
+      if (!type_system_or_err) {
+        llvm::consumeError(type_system_or_err.takeError());
+        break;
+      }
+      auto ts =
+          llvm::dyn_cast_or_null<TypeSystemSwift>(type_system_or_err->get());
+      if (!ts)
+        break;
+      CompilerType generic_type = ts->CreateGenericTypeParamType(depth, index);
+      CompilerType bound_type =
+          runtime->BindGenericTypeParameters(*frame, generic_type);
+      type_name = bound_type.GetDisplayTypeName();
+      break;
+    }
+
+    // Otherwise return the static archetype name from the debug info.
+    if (!type_name) {
+      Type *archetype = var_sp->GetType();
+      if (!archetype)
+        continue;
+      type_name = archetype->GetName();
+    }
+    dict.insert({{depth, index}, type_name.GetStringRef()});
   }
 }
 
 std::string SwiftLanguageRuntime::DemangleSymbolAsString(
-    StringRef symbol, DemangleMode mode, const SymbolContext *sc) {
+    StringRef symbol, DemangleMode mode, const SymbolContext *sc,
+    const ExecutionContext *exe_ctx) {
   bool did_init = false;
   llvm::DenseMap<ArchetypePath, StringRef> dict;
   swift::Demangle::DemangleOptions options;
@@ -723,7 +754,7 @@ std::string SwiftLanguageRuntime::DemangleSymbolAsString(
     // Resolve generic parameters in the current function.
     options.GenericParameterName = [&](uint64_t depth, uint64_t index) {
       if (!did_init) {
-        GetGenericParameterNamesForFunction(*sc, dict);
+        GetGenericParameterNamesForFunction(*sc, exe_ctx, dict);
         did_init = true;
       }
       auto it = dict.find({depth, index});

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -6004,7 +6004,8 @@ GetArchetypeNames(swift::Type swift_type, swift::ASTContext &ast_ctx,
     return dict;
 
   llvm::DenseMap<std::pair<uint64_t, uint64_t>, StringRef> names;
-  SwiftLanguageRuntime::GetGenericParameterNamesForFunction(*sc, names);
+  SwiftLanguageRuntime::GetGenericParameterNamesForFunction(*sc, nullptr,
+                                                            names);
   swift_type.visit([&](swift::Type type) {
     if (!type->isTypeParameter() || dict.count(type->getCanonicalType()))
       return;

lldb/source/Symbol/Function.cpp

@@ -498,10 +498,10 @@ bool Function::IsTopLevelFunction() {
   return result;
 }
 
-ConstString Function::GetDisplayName(const SymbolContext *sc) const {
+ConstString Function::GetDisplayName() const {
   if (!m_mangled)
     return GetName();
-  return m_mangled.GetDisplayDemangledName(sc);
+  return m_mangled.GetDisplayDemangledName();
 }
 
 CompilerDeclContext Function::GetDeclContext() {

lldb/test/API/lang/swift/bt_printing/TestSwiftBacktracePrinting.py

@@ -24,35 +24,11 @@ class TestSwiftBacktracePrinting(TestBase):
     def test_swift_backtrace_printing(self):
         """Test printing Swift backtrace"""
         self.build()
-        self.do_test()
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, 'break here', lldb.SBFileSpec('main.swift'))
 
-    def setUp(self):
-        TestBase.setUp(self)
-        self.main_source = "main.swift"
-        self.main_source_spec = lldb.SBFileSpec(self.main_source)
-
-    def do_test(self):
-        """Test printing Swift backtrace"""
-        exe_name = "a.out"
-        exe = self.getBuildArtifact(exe_name)
-
-        # Create the target
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
-
-        # Set the breakpoints
-        breakpoint = target.BreakpointCreateBySourceRegex(
-            'break here', self.main_source_spec)
-        self.assertTrue(breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT)
-
-        # Launch the process, and do not stop at the entry point.
-        process = target.LaunchSimple(None, None, os.getcwd())
-
-        self.assertTrue(process, PROCESS_IS_VALID)
-
-        self.expect("bt", substrs=['h<T>',
-                                   # FIXME: rdar://65956239 U and T are not resolved!
-                                   'g<U, T>', 'pair', # '12', "Hello world",
+        self.expect("bt", substrs=['h<Int>',
+                                   'g<String, Int>', 'pair', # FIXME: values are still wrong!
                                    'arg1=12', 'arg2="Hello world"'])
         self.expect("breakpoint set -p other", substrs=['g<U, T>'])
 

lldb/test/API/lang/swift/expression/generic_function_name/Makefile

@@ -0,0 +1,3 @@
+SWIFT_SOURCES := main.swift
+
+include Makefile.rules

lldb/test/API/lang/swift/expression/generic_function_name/TestSwiftGenericFunctionName.py

@@ -0,0 +1,35 @@
+import lldb
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbtest as lldbtest
+import lldbsuite.test.lldbutil as lldbutil
+import unittest2
+
+
+class TestSwiftGenericFunction(lldbtest.TestBase):
+    @swiftTest
+    def test(self):
+        """Test display of generic function names"""
+        self.build()
+        target, process, thread, bkpt = lldbutil.run_to_name_breakpoint(
+            self, 'f')
+
+        # Live process:
+        stream = lldb.SBStream()
+        self.frame().GetDescription(stream)
+        desc = stream.GetData()
+        # It's debatable whether C's generic parameter should be displayed here.
+        self.assertIn("C.f<Int>(t=1, u=2)", desc)
+
+        # Dead process + debug info:
+        process.Kill()
+        stream = lldb.SBStream()
+        bkpt.GetLocationAtIndex(0).GetDescription(stream, 1)
+        desc = stream.GetData()
+        self.assertIn("C.f<T>(T, U) -> ()", desc)
+
+        # Demangling only:
+        fs = target.FindFunctions("f")
+        self.assertTrue(fs)
+        desc = fs[0].GetFunction().GetDisplayName()
+        self.assertIn("C.f<τ_0_0>(_:_:)", desc)
+

lldb/test/API/lang/swift/expression/generic_function_name/main.swift

@@ -0,0 +1,8 @@
+class C<T>
+{
+  func f<U> (_ t: T, _ u: U) {
+    print("break here")
+  }
+}
+
+C<Int>().f(1, 2 as Float)