[lldb] add TemplateRange and NameQualifiersRange to DemangledNameInfo (#150999)

This patch adds 2 new attributes to `DemangledNameInfo`: `TemplateRange`
and `NameQualifiersRange`. It also introduces the
`function.name-qualifiers` entity formatter which allows tracking
qualifiers between the name of a function and its arguments/template.

This will be used downstream in Swift but may have applications in C++:
swiftlang#11068.

Author: charles-zablit

lldb/docs/use/formatting.rst

@@ -89,6 +89,8 @@ A complete list of currently supported format string variables is listed below:
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.name-without-args``                    | The name of the current function without arguments and values (used to include a function name in-line in the ``disassembly-format``)                                                                                                                                                       |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``function.name-qualifiers``                      | Any qualifiers added after the name of a function and before its arguments or template arguments. E.g., for Swift the name qualifier for ``closure #1 in A.foo<Int>()`` is `` in A.foo``.                                                                                                   |
++---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.basename``                             | The basename of the current function depending on the frame's language. E.g., for C++ the basename for ``void ns::foo<float>::bar<int>(int) const`` is ``bar``.                                                                                                                             |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``function.prefix``                               | Any prefix added to the demangled function name of the current function. This depends on the frame's language. E.g., for C++ the prefix will always be empty.                                                                                                                               |
@@ -332,6 +334,7 @@ The function names displayed in backtraces/``frame info``/``thread info`` are th
 - ``${function.prefix}``
 - ``${function.scope}``
 - ``${function.basename}``
+- ``${function.name-qualifiers}``
 - ``${function.template-arguments}``
 - ``${function.formatted-arguments}``
 - ``${function.qualifiers}``

lldb/include/lldb/Core/DemangledNameInfo.h

@@ -22,16 +22,29 @@ namespace lldb_private {
 struct DemangledNameInfo {
   /// A [start, end) pair for the function basename.
   /// The basename is the name without scope qualifiers
-  /// and without template parameters. E.g.,
+  /// and without template parameters.
+  ///
+  /// E.g.,
   /// \code{.cpp}
   ///    void foo::bar<int>::someFunc<float>(int) const &&
   ///                        ^       ^
   ///                      start    end
   /// \endcode
   std::pair<size_t, size_t> BasenameRange;
 
+  /// A [start, end) pair for the function template arguments.
+  ///
+  /// E.g.,
+  /// \code{.cpp}
+  ///    void foo::bar<int>::someFunc<float>(int) const &&
+  ///                                ^      ^
+  ///                              start   end
+  /// \endcode
+  std::pair<size_t, size_t> TemplateArgumentsRange;
+
   /// A [start, end) pair for the function scope qualifiers.
-  /// E.g., for
+  ///
+  /// E.g.,
   /// \code{.cpp}
   ///    void foo::bar<int>::qux<float>(int) const &&
   ///         ^              ^
@@ -40,6 +53,7 @@ struct DemangledNameInfo {
   std::pair<size_t, size_t> ScopeRange;
 
   /// Indicates the [start, end) of the function argument list.
+  ///
   /// E.g.,
   /// \code{.cpp}
   ///    int (*getFunc<float>(float, double))(int, int)
@@ -59,6 +73,19 @@ struct DemangledNameInfo {
   /// \endcode
   std::pair<size_t, size_t> QualifiersRange;
 
+  /// Indicates the [start, end) of the function's name qualifiers. This is a
+  /// catch-all range for anything in between the basename and the function's
+  /// arguments or template arguments, that is not tracked by the rest of the
+  /// pairs.
+  ///
+  /// E.g.,
+  /// \code{.swift}
+  ///    closure #1 in A.foo<Int>()
+  ///              ^        ^
+  ///            start     end
+  /// \endcode
+  std::pair<size_t, size_t> NameQualifiersRange;
+
   /// Indicates the [start, end) of the function's prefix. This is a
   /// catch-all range for anything that is not tracked by the rest of
   /// the pairs.
@@ -75,6 +102,11 @@ struct DemangledNameInfo {
     return BasenameRange.second > BasenameRange.first;
   }
 
+  /// Returns \c true if this object holds a valid template arguments range.
+  bool hasTemplateArguments() const {
+    return TemplateArgumentsRange.second >= TemplateArgumentsRange.first;
+  }
+
   /// Returns \c true if this object holds a valid scope range.
   bool hasScope() const { return ScopeRange.second >= ScopeRange.first; }
 
@@ -88,6 +120,11 @@ struct DemangledNameInfo {
     return QualifiersRange.second >= QualifiersRange.first;
   }
 
+  /// Returns \c true if this object holds a valid name qualifiers range.
+  bool hasNameQualifiers() const {
+    return NameQualifiersRange.second >= NameQualifiersRange.first;
+  }
+
   /// Returns \c true if this object holds a valid prefix range.
   bool hasPrefix() const { return PrefixRange.second >= PrefixRange.first; }
 

lldb/include/lldb/Core/FormatEntity.h

@@ -91,6 +91,7 @@ struct Entry {
     FunctionPrefix,
     FunctionScope,
     FunctionBasename,
+    FunctionNameQualifiers,
     FunctionTemplateArguments,
     FunctionFormattedArguments,
     FunctionReturnLeft,

lldb/source/Core/DemangledNameInfo.cpp

@@ -92,6 +92,14 @@ void TrackingOutputBuffer::finalizeStart() {
   if (NameInfo.BasenameRange.second == 0)
     NameInfo.BasenameRange.second = getCurrentPosition();
 
+  // There is something between the basename and the start of the function
+  // arguments. Assume those are template arguments (which *should* be true for
+  // C++ demangled names, but this assumption may change in the future, in
+  // which case this needs to be adjusted).
+  if (NameInfo.BasenameRange.second != NameInfo.ArgumentsRange.first)
+    NameInfo.TemplateArgumentsRange = {NameInfo.BasenameRange.second,
+                                       NameInfo.ArgumentsRange.first};
+
   assert(!shouldTrack());
   assert(canFinalize());
 }

lldb/source/Core/FormatEntity.cpp

@@ -128,6 +128,7 @@ constexpr Definition g_function_child_entries[] = {
     Definition("prefix", EntryType::FunctionPrefix),
     Definition("scope", EntryType::FunctionScope),
     Definition("basename", EntryType::FunctionBasename),
+    Definition("name-qualifiers", EntryType::FunctionNameQualifiers),
     Definition("template-arguments", EntryType::FunctionTemplateArguments),
     Definition("formatted-arguments", EntryType::FunctionFormattedArguments),
     Definition("return-left", EntryType::FunctionReturnLeft),
@@ -390,6 +391,7 @@ const char *FormatEntity::Entry::TypeToCString(Type t) {
     ENUM_TO_CSTR(FunctionPrefix);
     ENUM_TO_CSTR(FunctionScope);
     ENUM_TO_CSTR(FunctionBasename);
+    ENUM_TO_CSTR(FunctionNameQualifiers);
     ENUM_TO_CSTR(FunctionTemplateArguments);
     ENUM_TO_CSTR(FunctionFormattedArguments);
     ENUM_TO_CSTR(FunctionReturnLeft);
@@ -1842,6 +1844,7 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
   case Entry::Type::FunctionPrefix:
   case Entry::Type::FunctionScope:
   case Entry::Type::FunctionBasename:
+  case Entry::Type::FunctionNameQualifiers:
   case Entry::Type::FunctionTemplateArguments:
   case Entry::Type::FunctionFormattedArguments:
   case Entry::Type::FunctionReturnRight:

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

@@ -283,12 +283,12 @@ GetDemangledTemplateArguments(const SymbolContext &sc) {
 
   auto [demangled_name, info] = *info_or_err;
 
-  if (info.ArgumentsRange.first < info.BasenameRange.second)
-    return llvm::createStringError("Arguments range for '%s' is invalid.",
-                                   demangled_name.data());
+  if (!info.hasTemplateArguments())
+    return llvm::createStringError(
+        "Template arguments range for '%s' is invalid.", demangled_name.data());
 
-  return demangled_name.slice(info.BasenameRange.second,
-                              info.ArgumentsRange.first);
+  return demangled_name.slice(info.TemplateArgumentsRange.first,
+                              info.TemplateArgumentsRange.second);
 }
 
 static llvm::Expected<llvm::StringRef>