[lldb][Format] Add new function basename highlight option to FormatEntity

Author: Michael137

lldb/include/lldb/Core/FormatEntity.h

@@ -197,13 +197,29 @@ struct Entry {
     return true;
   }
 
+  struct HighlightSettings {
+    std::string prefix;
+    std::string suffix;
+
+    enum class Kind : uint8_t {
+      ///< Don't highlight.
+      None,
+
+      ///< Highlight function basename
+      ///< (i.e., name without Scope and
+      ///< without template arguments).
+      Basename,
+    } kind = Kind::None;
+  };
+
   std::string string;
   std::string printf_format;
   std::vector<Entry> children;
   Type type;
   lldb::Format fmt = lldb::eFormatDefault;
   lldb::addr_t number = 0;
   bool deref = false;
+  HighlightSettings highlight;
 };
 
 bool Format(const Entry &entry, Stream &s, const SymbolContext *sc,

lldb/include/lldb/Target/Language.h

@@ -268,10 +268,11 @@ class Language : public PluginInterface {
   // the reference has never been assigned
   virtual bool IsUninitializedReference(ValueObject &valobj);
 
-  virtual bool GetFunctionDisplayName(const SymbolContext *sc,
-                                      const ExecutionContext *exe_ctx,
-                                      FunctionNameRepresentation representation,
-                                      Stream &s);
+  virtual bool
+  GetFunctionDisplayName(const SymbolContext *sc,
+                         const ExecutionContext *exe_ctx,
+                         FunctionNameRepresentation representation, Stream &s,
+                         const FormatEntity::Entry::HighlightSettings &);
 
   virtual ConstString
   GetDemangledFunctionNameWithoutArguments(Mangled mangled) const {

lldb/source/Core/FormatEntity.cpp

@@ -1654,7 +1654,8 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
 
     if (language_plugin)
       language_plugin_handled = language_plugin->GetFunctionDisplayName(
-          sc, exe_ctx, Language::FunctionNameRepresentation::eName, ss);
+          sc, exe_ctx, Language::FunctionNameRepresentation::eName, ss,
+          entry.highlight);
 
     if (language_plugin_handled) {
       s << ss.GetString();
@@ -1690,7 +1691,7 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
     if (language_plugin)
       language_plugin_handled = language_plugin->GetFunctionDisplayName(
           sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithNoArgs,
-          ss);
+          ss, entry.highlight);
 
     if (language_plugin_handled) {
       s << ss.GetString();
@@ -1724,7 +1725,8 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
 
     if (language_plugin)
       language_plugin_handled = language_plugin->GetFunctionDisplayName(
-          sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithArgs, ss);
+          sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithArgs, ss,
+          entry.highlight);
 
     if (language_plugin_handled) {
       s << ss.GetString();
@@ -2046,6 +2048,54 @@ static const Definition *FindEntry(const llvm::StringRef &format_str,
   return parent;
 }
 
+static llvm::Expected<Entry::HighlightSettings>
+ParseHighlightSettings(const Entry &entry) {
+  // FIXME: support other function.name-XXX types as well
+  if (entry.type != Entry::Type::FunctionNameWithArgs)
+    return llvm::createStringError(
+        "The 'highlight_basename' format can only be used on "
+        "${function.name-with-args}");
+
+  llvm::StringRef format = entry.printf_format;
+  if (!format.consume_front("highlight_"))
+    return llvm::createStringError(
+        "Expected 'highlight_' prefix not found in: %s.",
+        entry.printf_format.c_str());
+
+  Entry::HighlightSettings settings;
+  if (format.consume_front("basename")) {
+    settings.kind = Entry::HighlightSettings::Kind::Basename;
+  } else {
+    return llvm::createStringError(
+        "Unsupported highlight kind detected in: %s. "
+        "Currently supported: basename",
+        entry.printf_format.c_str());
+  }
+
+  llvm::SmallVector<llvm::StringRef, 1> matches;
+  // TODO: support ${ansi.XXX} syntax. ExtractVariableInfo needs
+  // to be adjusted to support nested '{}'.
+  llvm::Regex color_pattern{R"(^\(([a-z\.]+)\)$)"};
+  if (!color_pattern.match(format, &matches))
+    return llvm::createStringError("Couldn't find valid color variable in: %s. "
+                                   "Expected format: (ansi.some-color)",
+                                   entry.printf_format.c_str());
+
+  assert(matches.size() == 2);
+
+  std::string color_format = ("${" + matches[1] + "}").str();
+  std::string terminal_code = ansi::FormatAnsiTerminalCodes(color_format);
+  if (terminal_code.empty())
+    return llvm::createStringError("Invalid color variable '%s' found in: %s",
+                                   color_format.c_str(),
+                                   entry.printf_format.c_str());
+
+  settings.prefix = std::move(terminal_code);
+  settings.suffix = ansi::FormatAnsiTerminalCodes("${ansi.normal}");
+
+  return settings;
+}
+
 static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,
                             uint32_t depth) {
   Status error;
@@ -2201,6 +2251,7 @@ static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,
         if (error.Fail())
           return error;
         bool verify_is_thread_id = false;
+        bool parse_highlight_settings = false;
         Entry entry;
         if (!variable_format.empty()) {
           entry.printf_format = variable_format.str();
@@ -2266,6 +2317,8 @@ static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,
                 clear_printf = true;
               } else if (entry.printf_format == "tid") {
                 verify_is_thread_id = true;
+              } else if (entry.printf_format.find("highlight_") == 0) {
+                parse_highlight_settings = true;
               } else {
                 error = Status::FromErrorStringWithFormat(
                     "invalid format: '%s'", entry.printf_format.c_str());
@@ -2307,6 +2360,14 @@ static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,
                 "the 'tid' format can only be used on "
                 "${thread.id} and ${thread.protocol_id}");
           }
+        } else if (parse_highlight_settings) {
+          auto highlight_or_err = ParseHighlightSettings(entry);
+          if (highlight_or_err) {
+            entry.highlight = std::move(*highlight_or_err);
+            entry.printf_format.clear();
+          } else {
+            error = Status::FromError(highlight_or_err.takeError());
+          }
         }
 
         switch (entry.type) {

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

@@ -19,6 +19,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/ItaniumDemangle.h"
 
+#include "lldb/Core/Demangle.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
@@ -178,7 +179,7 @@ static bool IsTrivialBasename(const llvm::StringRef &basename) {
 /// but replaces each argument type with the variable name
 /// and the corresponding pretty-printed value
 static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream,
-                                            char const *full_name,
+                                            llvm::StringRef full_name,
                                             ExecutionContextScope *exe_scope,
                                             VariableList const &args) {
   CPlusPlusLanguage::MethodName cpp_method{ConstString(full_name)};
@@ -208,6 +209,42 @@ static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream,
   return true;
 }
 
+static bool PrettyPrintFunctionNameWithArgs(
+    Stream &out_stream, llvm::StringRef full_name,
+    ExecutionContextScope *exe_scope, VariableList const &args,
+    const std::optional<FunctionNameInfo> &demangled_info,
+    const FormatEntity::Entry::HighlightSettings &settings) {
+  if (settings.kind == FormatEntity::Entry::HighlightSettings::Kind::None ||
+      !demangled_info || !demangled_info->hasBasename())
+    return PrettyPrintFunctionNameWithArgs(out_stream, full_name, exe_scope,
+                                           args);
+
+  auto [base_start, base_end] = demangled_info->BasenameLocs;
+
+  // Dump anything before the basename.
+  out_stream.PutCString(full_name.substr(0, base_start));
+
+  // Highlight the basename.
+  out_stream.PutCString(settings.prefix);
+  out_stream.PutCString(full_name.substr(base_start, base_end - base_start));
+  out_stream.PutCString(settings.suffix);
+
+  // Dump anything between the basename and the argument list.
+  if (demangled_info->ArgumentLocs.first > base_end)
+    out_stream.PutCString(full_name.substr(
+        base_end, demangled_info->ArgumentLocs.first - base_end));
+
+  // Dump arguments.
+  out_stream.PutChar('(');
+  FormatEntity::PrettyPrintFunctionArguments(out_stream, args, exe_scope);
+  out_stream.PutChar(')');
+
+  // Dump anything after the argument list.
+  out_stream.PutCString(full_name.substr(demangled_info->ArgumentLocs.second));
+
+  return true;
+}
+
 bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
   // This method tries to parse simple method definitions which are presumably
   // most comman in user programs. Definitions that can be parsed by this
@@ -1699,7 +1736,8 @@ bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
 
 bool CPlusPlusLanguage::GetFunctionDisplayName(
     const SymbolContext *sc, const ExecutionContext *exe_ctx,
-    FunctionNameRepresentation representation, Stream &s) {
+    FunctionNameRepresentation representation, Stream &s,
+    const FormatEntity::Entry::HighlightSettings &settings) {
   switch (representation) {
   case FunctionNameRepresentation::eNameWithArgs: {
     // Print the function name with arguments in it
@@ -1737,13 +1775,10 @@ bool CPlusPlusLanguage::GetFunctionDisplayName(
         if (variable_list_sp)
           variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
                                                      args);
-        if (args.GetSize() > 0) {
-          if (!PrettyPrintFunctionNameWithArgs(s, cstr, exe_scope, args))
-            return false;
-        } else {
-          s.PutCString(cstr);
-        }
-        return true;
+
+        return PrettyPrintFunctionNameWithArgs(s, cstr, exe_scope, args,
+                                               sc->function->GetDemangledInfo(),
+                                               settings);
       }
     } else if (sc->symbol) {
       const char *cstr = sc->symbol->GetName().AsCString(nullptr);

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

@@ -15,6 +15,7 @@
 #include "llvm/ADT/StringRef.h"
 
 #include "Plugins/Language/ClangCommon/ClangHighlighter.h"
+#include "lldb/Core/FormatEntity.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
@@ -138,10 +139,10 @@ class CPlusPlusLanguage : public Language {
   ConstString
   GetDemangledFunctionNameWithoutArguments(Mangled mangled) const override;
 
-  bool GetFunctionDisplayName(const SymbolContext *sc,
-                              const ExecutionContext *exe_ctx,
-                              FunctionNameRepresentation representation,
-                              Stream &s) override;
+  bool GetFunctionDisplayName(
+      const SymbolContext *sc, const ExecutionContext *exe_ctx,
+      FunctionNameRepresentation representation, Stream &s,
+      const FormatEntity::Entry::HighlightSettings &) override;
 
   static bool IsCPPMangledName(llvm::StringRef name);
 

lldb/source/Target/Language.cpp

@@ -510,10 +510,10 @@ bool Language::IsNilReference(ValueObject &valobj) { return false; }
 
 bool Language::IsUninitializedReference(ValueObject &valobj) { return false; }
 
-bool Language::GetFunctionDisplayName(const SymbolContext *sc,
-                                      const ExecutionContext *exe_ctx,
-                                      FunctionNameRepresentation representation,
-                                      Stream &s) {
+bool Language::GetFunctionDisplayName(
+    const SymbolContext *sc, const ExecutionContext *exe_ctx,
+    FunctionNameRepresentation representation, Stream &s,
+    const FormatEntity::Entry::HighlightSettings &) {
   return false;
 }
 

lldb/test/Shell/Settings/TestFrameFormatHighlight.test

@@ -0,0 +1,55 @@
+# UNSUPPORTED: system-windows
+# Test highlighting of function basenames.
+
+# RUN: split-file %s %t
+# RUN: %build %t/main.cpp -o %t.out
+# RUN: %lldb -x -b -s %t/commands.input %t.out -o exit 2>&1 | FileCheck %s --check-prefix=CHECK-COLOR
+
+#--- main.cpp
+namespace ns {
+template<typename T>
+struct Bar {
+  template<typename K>
+  T bar(K k) const & { return 1.0f; }
+};
+
+template<typename T>
+struct Foo {
+  template<typename K>
+  void foo() const volatile && {
+    Bar<float> b;
+    b.bar(b);
+  }
+};
+
+template<typename T>
+T func() {
+  ns::Foo<int>{}.foo<int>();
+  return T{};
+}
+} // namespace ns
+
+int main() {
+  ns::func<ns::Foo<int>>();
+  return 0;
+}
+
+#--- commands.input
+settings set use-color true
+settings set -f frame-format "frame ${function.name-with-args:%highlight_basename(ansi.fg.cyan)}\n"
+break set -n bar
+
+run
+bt
+# CHECK-COLOR: frame float ns::Bar<float>::bar<ns::Bar<float>>(this={{.*}}, k=Bar<float> @ {{.*}}) const &
+# CHECK-COLOR: frame void ns::Foo<int>::foo<int>(this={{.*}}) const volatile &&
+# CHECK-COLOR: frame ns::Foo<int> ns::func<ns::Foo<int>>()
+# CHECK-COLOR: frame main
+
+settings set -f frame-format "frame ${function.name-with-args:%highlight_basename(ansi.bg.green)}\n"
+bt
+
+# CHECK-COLOR: frame float ns::Bar<float>::bar<ns::Bar<float>>(this={{.*}}, k=Bar<float> @ {{.*}}) const &
+# CHECK-COLOR: frame void ns::Foo<int>::foo<int>(this={{.*}}) const volatile &&
+# CHECK-COLOR: frame ns::Foo<int> ns::func<ns::Foo<int>>()
+# CHECK-COLOR: frame main