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

Author: Michael137

lldb/include/lldb/Core/FormatEntity.h

@@ -199,13 +199,41 @@ struct Entry {
     return true;
   }
 
+  /// Describes how a function name should be highlighted.
+  struct HighlightSettings {
+    /// ANSI prefix that will be printed before the function name.
+    std::string prefix;
+
+    /// ANSI suffix that will be printed after the function name.
+    std::string suffix;
+
+    /// What kind of highlighting the user asked to perform.
+    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;
+
+  /// Set using the highlighting format specifiers to a
+  /// frame-format variable.
+  /// E.g.,
+  /// \code
+  /// ${function.name-with-args:%highlight_basename(ansi.fg.green)}
+  /// \endcode
+  HighlightSettings highlight;
 };
 
 bool Format(const Entry &entry, Stream &s, const SymbolContext *sc,

lldb/include/lldb/Symbol/Function.h

@@ -11,6 +11,7 @@
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Declaration.h"
+#include "lldb/Core/DemangledNameInfo.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Symbol/Block.h"
@@ -531,6 +532,9 @@ class Function : public UserID, public SymbolContextScope {
 
   ConstString GetDisplayName() const;
 
+  /// Retrieve \c DemangledNameInfo of the demangled name held by this object.
+  const std::optional<DemangledNameInfo> &GetDemangledInfo() const;
+
   const Mangled &GetMangled() const { return m_mangled; }
 
   /// Get the DeclContext for this function, if available.

lldb/include/lldb/Target/Language.h

@@ -268,10 +268,10 @@ 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,
+      const FormatEntity::Entry::HighlightSettings &, Stream &s);
 
   virtual ConstString
   GetDemangledFunctionNameWithoutArguments(Mangled mangled) const {

lldb/source/Core/FormatEntity.cpp

@@ -1661,7 +1661,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,
+          entry.highlight, ss);
 
     if (language_plugin_handled) {
       s << ss.GetString();
@@ -1697,7 +1698,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);
+          entry.highlight, ss);
 
     if (language_plugin_handled) {
       s << ss.GetString();
@@ -1731,7 +1732,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,
+          entry.highlight, ss);
 
     if (language_plugin_handled) {
       s << ss.GetString();
@@ -2074,6 +2076,64 @@ static const Definition *FindEntry(const llvm::StringRef &format_str,
   return parent;
 }
 
+/// Parses a single highlighting format specifier.
+///
+/// Example syntax for such specifier:
+/// \code
+/// ${function.name-with-args:%highlight_basename(ansi.fg.green)}
+/// \endcode
+///
+/// In the above snippet, the `function.name-with-args` frame-format
+/// variable will have its basename highlighted in green.
+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: %%highlight_basename(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() || terminal_code == color_format)
+    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;
@@ -2229,6 +2289,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();
@@ -2294,6 +2355,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());
@@ -2335,6 +2398,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,9 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/ItaniumDemangle.h"
 
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/DemangledNameInfo.h"
+#include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
@@ -178,7 +181,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 +211,71 @@ static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream,
   return true;
 }
 
+static bool GetUseColor(ExecutionContextScope *exe_scope) {
+  if (!exe_scope)
+    return false;
+
+  auto target_sp = exe_scope->CalculateTarget();
+  if (!target_sp)
+    return false;
+
+  return target_sp->GetDebugger().GetUseColor();
+}
+
+static bool ShouldHighlightBasename(
+    ExecutionContextScope *exe_scope,
+    const FormatEntity::Entry::HighlightSettings &settings) {
+  if (!GetUseColor(exe_scope))
+    return false;
+
+  return settings.kind ==
+         FormatEntity::Entry::HighlightSettings::Kind::Basename;
+}
+
+/// If \c DemangledNameInfo is valid, we use it to print a function function
+/// name into \c out_stream (and if requested, highlight the basename).
+static bool PrettyPrintHighlightedBasenameWithArgs(
+    Stream &out_stream, llvm::StringRef full_name,
+    ExecutionContextScope *exe_scope, VariableList const &args,
+    const std::optional<DemangledNameInfo> &demangled_info,
+    const FormatEntity::Entry::HighlightSettings &settings) {
+  // If we didn't get sufficient information from the demangler, we fall back to
+  // parsing the and printing parts of the demangled name ourselves.
+  if (!demangled_info || !demangled_info->hasBasename())
+    return PrettyPrintFunctionNameWithArgs(out_stream, full_name, exe_scope,
+                                           args);
+
+  auto [base_start, base_end] = demangled_info->BasenameRange;
+
+  // Dump anything before the basename.
+  out_stream.PutCString(full_name.substr(0, base_start));
+
+  // Highlight the basename.
+  if (ShouldHighlightBasename(exe_scope, settings))
+    out_stream.PutCString(settings.prefix);
+
+  out_stream.PutCString(full_name.substr(base_start, base_end - base_start));
+
+  if (ShouldHighlightBasename(exe_scope, settings))
+    out_stream.PutCString(settings.suffix);
+
+  // Dump anything between the basename and the argument list.
+  if (demangled_info->ArgumentsRange.first > base_end)
+    out_stream.PutCString(full_name.substr(
+        base_end, demangled_info->ArgumentsRange.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->ArgumentsRange.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 +1767,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 +1806,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 PrettyPrintHighlightedBasenameWithArgs(
+            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"
@@ -141,6 +142,7 @@ class CPlusPlusLanguage : public Language {
   bool GetFunctionDisplayName(const SymbolContext *sc,
                               const ExecutionContext *exe_ctx,
                               FunctionNameRepresentation representation,
+                              const FormatEntity::Entry::HighlightSettings &,
                               Stream &s) override;
 
   static bool IsCPPMangledName(llvm::StringRef name);

lldb/source/Symbol/Function.cpp

@@ -712,3 +712,7 @@ ConstString Function::GetName() const {
 ConstString Function::GetNameNoArguments() const {
   return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);
 }
+
+const std::optional<DemangledNameInfo> &Function::GetDemangledInfo() const {
+  return m_mangled.GetDemangledInfo();
+}

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;
 }