[lldb][CPlusPlus] Introduce CPlusPlusLanguage::MethodName::GetReturnType

[Michael137]

Summary

This patch adds a way to extract the return type out
of the CPlusPlusNameParser. This will be useful
for cases where we want a function's basename *and* the
return type but not the function arguments; this is
currently not possible (the parser either gives us the
full name or just the basename). Since the parser knows
how to handle return types already we should just expose
this to users that need it.

Testing

• Added unit-tests

[Michael137]

• Fix unit-tests
• Handle function pointer types

[labath]

The return type handling for function pointers is not correct. If it's hard to do, then maybe we could skip it (i suspect the original code didn't handle that either), but I have a feeling it might not be that hard, given that we're already able correctly extract the innermost argument types.

lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp

85–88

I believe the return type here should be something like string (*)(float) (a pointer to a function that takes a float and returns a string).

[Michael137]

In D136935#3892082, @labath wrote:

The return type handling for function pointers is not correct. If it's hard to do, then maybe we could skip it (i suspect the original code didn't handle that either), but I have a feeling it might not be that hard, given that we're already able correctly extract the innermost argument types.

Ah good catch, yes the original code just seems to skip the first typename (which need not be the actual return type if we're returning function pointers) since it only cares about the base name and arguments. Will see how easy this is to handle

[Michael137]

In D136935#3892082, @labath wrote:

The return type handling for function pointers is not correct. If it's hard to do, then maybe we could skip it (i suspect the original code didn't handle that either), but I have a feeling it might not be that hard, given that we're already able correctly extract the innermost argument types.

The slightly unfortunate bit is that if we wanted to collect all but the inner function name into m_return_type we'd have to allocate a new string and do some concatenation (or create some sort of struct ReturnType { llvm::StringRef LHS, RHS }). Not too difficult to implement AFAICT but not sure we need to support this at the moment. Functions that have a function return type encoded in the mangled name currently don't format correctly, so not supporting it wouldn't regress that. Wdyt?

Either way a great test-case to add

[hawkinsw]

lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp

85–88

I read this "nice" function pointer declaration as:

declare f as a function that takes a vector<int> by r-value reference that, in turn, returns a pointer to a function taking a float by value that returns a string.

Upon writing that out, I realize that I am basically saying the same thing as @labath. Sorry!

[Michael137]

• Don't handle function-pointer return types for now
• Add more documentation

[labath]

In D136935#3892336, @Michael137 wrote:

In D136935#3892082, @labath wrote:

The return type handling for function pointers is not correct. If it's hard to do, then maybe we could skip it (i suspect the original code didn't handle that either), but I have a feeling it might not be that hard, given that we're already able correctly extract the innermost argument types.

The slightly unfortunate bit is that if we wanted to collect all but the inner function name into m_return_type we'd have to allocate a new string and do some concatenation (or create some sort of struct ReturnType { llvm::StringRef LHS, RHS }). Not too difficult to implement AFAICT but not sure we need to support this at the moment. Functions that have a function return type encoded in the mangled name currently don't format correctly, so not supporting it wouldn't regress that. Wdyt?

Sounds good. Ship it.

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

public:
 
     llvm::StringRef GetBasename();
 
     llvm::StringRef GetContext();
 
     llvm::StringRef GetArguments();
 
     llvm::StringRef GetQualifiers();
-    
+    /// Returns the methods return-type.
+    ///
+    /// Currently returns an empty llvm::StringRef
+    /// if the return-type is a function pointer.
+    llvm::StringRef GetReturnType();
+
     bool ContainsPath(llvm::StringRef path);
 
   private:
     /// Returns the Basename of this method without a template parameter
     /// list, if any.
     ///
     // Examples:
     //
     //   +--------------------------------+---------+
     //   | MethodName                     | Returns |
     //   +--------------------------------+---------+
     //   | void func()                    | func    |
     //   | void func<int>()               | func    |
     //   | void func<std::vector<int>>()  | func    |
     //   +--------------------------------+---------+
     llvm::StringRef GetBasenameNoTemplateParameters();
 
   protected:
     void Parse();
     bool TrySimplifiedParse();
 
     ConstString m_full; // Full name:
-                        // "lldb::SBTarget::GetBreakpointAtIndex(unsigned int)
-                        // const"
-    llvm::StringRef m_basename;   // Basename:     "GetBreakpointAtIndex"
-    llvm::StringRef m_context;    // Decl context: "lldb::SBTarget"
-    llvm::StringRef m_arguments;  // Arguments:    "(unsigned int)"
-    llvm::StringRef m_qualifiers; // Qualifiers:   "const"
+                        // "size_t lldb::SBTarget::GetBreakpointAtIndex(unsigned
+                        // int) const"
+    llvm::StringRef m_basename;    // Basename:     "GetBreakpointAtIndex"
+    llvm::StringRef m_context;     // Decl context: "lldb::SBTarget"
+    llvm::StringRef m_arguments;   // Arguments:    "(unsigned int)"
+    llvm::StringRef m_qualifiers;  // Qualifiers:   "const"
+    llvm::StringRef m_return_type; // Return type:  "size_t"
     bool m_parsed = false;
     bool m_parse_error = false;
   };
 
   CPlusPlusLanguage() = default;
 
   ~CPlusPlusLanguage() override = default;
 

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

 }
 
 void CPlusPlusLanguage::MethodName::Clear() {
   m_full.Clear();
   m_basename = llvm::StringRef();
   m_context = llvm::StringRef();
   m_arguments = llvm::StringRef();
   m_qualifiers = llvm::StringRef();
+  m_return_type = llvm::StringRef();
   m_parsed = false;
   m_parse_error = false;
 }
 
 static bool ReverseFindMatchingChars(const llvm::StringRef &s,
                                      const llvm::StringRef &left_right_chars,
                                      size_t &left_pos, size_t &right_pos,
                                      size_t pos = llvm::StringRef::npos) {
if (IsTrivialBasename(m_basename)) {
       return true;
     } else {
       // The C++ basename doesn't match our regular expressions so this can't
       // be a valid C++ method, clear everything out and indicate an error
       m_context = llvm::StringRef();
       m_basename = llvm::StringRef();
       m_arguments = llvm::StringRef();
       m_qualifiers = llvm::StringRef();
+      m_return_type = llvm::StringRef();
       return false;
     }
   }
   return false;
 }
 
 void CPlusPlusLanguage::MethodName::Parse() {
   if (!m_parsed && m_full) {
     if (TrySimplifiedParse()) {
       m_parse_error = false;
     } else {
       CPlusPlusNameParser parser(m_full.GetStringRef());
       if (auto function = parser.ParseAsFunctionDefinition()) {
         m_basename = function.value().name.basename;
         m_context = function.value().name.context;
         m_arguments = function.value().arguments;
         m_qualifiers = function.value().qualifiers;
+        m_return_type = function.value().return_type;
         m_parse_error = false;
       } else {
         m_parse_error = true;
       }
     }
     m_parsed = true;
   }
 }

 }
 
 llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() {
   if (!m_parsed)
     Parse();
   return m_qualifiers;
 }
 
+llvm::StringRef CPlusPlusLanguage::MethodName::GetReturnType() {
+  if (!m_parsed)
+    Parse();
+  return m_return_type;
+}
+
 std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
   if (!m_parsed)
     Parse();
   if (m_context.empty())
     return std::string(m_basename);
 
   std::string res;
   res += m_context;

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

struct ParsedName {
     llvm::StringRef basename;
     llvm::StringRef context;
   };
 
   struct ParsedFunction {
     ParsedName name;
     llvm::StringRef arguments;
     llvm::StringRef qualifiers;
+    llvm::StringRef return_type;
   };
 
   // Treats given text as a function definition and parses it.
   // Function definition might or might not have a return type and this should
   // change parsing result.
   // Examples:
   //    main(int, chat const*)
   //    T fun(int, bool)

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

 clang::Token &CPlusPlusNameParser::Peek() {
   assert(HasMoreTokens());
   return m_tokens[m_next_token_index];
 }
 
 Optional<ParsedFunction>
 CPlusPlusNameParser::ParseFunctionImpl(bool expect_return_type) {
   Bookmark start_position = SetBookmark();
+
+  ParsedFunction result;
   if (expect_return_type) {
+    size_t return_start = GetCurrentPosition();
     // Consume return type if it's expected.
     if (!ConsumeToken(tok::kw_auto) && !ConsumeTypename())
       return None;
+
+    size_t return_end = GetCurrentPosition();
+    result.return_type = GetTextForRange(Range(return_start, return_end));
   }
 
   auto maybe_name = ParseFullNameImpl();
   if (!maybe_name) {
     return None;
   }
 
   size_t argument_start = GetCurrentPosition();
   if (!ConsumeArguments()) {
     return None;
   }
 
   size_t qualifiers_start = GetCurrentPosition();
   SkipFunctionQualifiers();
   size_t end_position = GetCurrentPosition();
 
-  ParsedFunction result;
   result.name.basename = GetTextForRange(maybe_name.value().basename_range);
   result.name.context = GetTextForRange(maybe_name.value().context_range);
   result.arguments = GetTextForRange(Range(argument_start, qualifiers_start));
   result.qualifiers = GetTextForRange(Range(qualifiers_start, end_position));
   start_position.Remove();
   return result;
 }
 
 Optional<ParsedFunction>
 CPlusPlusNameParser::ParseFuncPtr(bool expect_return_type) {
+  // This function parses a function definition
+  // that returns a pointer type.
+  // E.g., double (*(*func(long))(int))(float)
+
+  // Step 1:
+  // Remove the return type of the innermost
+  // function pointer type.
+  //
+  // Leaves us with:
+  //   (*(*func(long))(int))(float)
   Bookmark start_position = SetBookmark();
   if (expect_return_type) {
     // Consume return type.
     if (!ConsumeTypename())
       return None;
   }
 
+  // Step 2:
+  //
+  // Skip a pointer and parenthesis pair.
+  //
+  // Leaves us with:
+  //   (*func(long))(int))(float)
   if (!ConsumeToken(tok::l_paren))
     return None;
   if (!ConsumePtrsAndRefs())
     return None;
 
+  // Step 3:
+  //
+  // Consume inner function name. This will fail unless
+  // we stripped all the pointers on the left hand side
+  // of the funciton name.
   {
     Bookmark before_inner_function_pos = SetBookmark();
     auto maybe_inner_function_name = ParseFunctionImpl(false);
     if (maybe_inner_function_name)
       if (ConsumeToken(tok::r_paren))
         if (ConsumeArguments()) {
           SkipFunctionQualifiers();
           start_position.Remove();
           before_inner_function_pos.Remove();
           return maybe_inner_function_name;
         }
   }
 
+  // Step 4:
+  //
+  // Parse the remaining string as a function pointer again.
+  // This time don't consume the inner-most typename since
+  // we're left with pointers only. This will strip another
+  // layer of pointers until we're left with the innermost
+  // function name/argument. I.e., func(long))(int))(float)
+  //
+  // Once we successfully stripped all pointers and gotten
+  // the innermost function name from ParseFunctionImpl above,
+  // we consume a single ')' and the arguments '(...)' that follows.
+  //
+  // Leaves us with:
+  //   )(float)
+  //
+  // This is the remnant of the outer function pointers' arguments.
+  // Unwinding the recursive calls will remove the remaining
+  // arguments.
   auto maybe_inner_function_ptr_name = ParseFuncPtr(false);
   if (maybe_inner_function_ptr_name)
     if (ConsumeToken(tok::r_paren))
       if (ConsumeArguments()) {
         SkipFunctionQualifiers();
         start_position.Remove();
         return maybe_inner_function_ptr_name;
       }
+
   return None;
 }
 
 bool CPlusPlusNameParser::ConsumeArguments() {
   return ConsumeBrackets(tok::l_paren, tok::r_paren);
 }
 
 bool CPlusPlusNameParser::ConsumeTemplateArgs() {

lldb/unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp

 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 TEST(CPlusPlusLanguage, MethodNameParsing) {
   struct TestCase {
     std::string input;
-    std::string context, basename, arguments, qualifiers, scope_qualified_name;
+    std::string return_type, context, basename, arguments, qualifiers,
+        scope_qualified_name;
   };
 
   TestCase test_cases[] = {
-      {"main(int, char *[]) ", "", "main", "(int, char *[])", "", "main"},
-      {"foo::bar(baz) const", "foo", "bar", "(baz)", "const", "foo::bar"},
-      {"foo::~bar(baz)", "foo", "~bar", "(baz)", "", "foo::~bar"},
-      {"a::b::c::d(e,f)", "a::b::c", "d", "(e,f)", "", "a::b::c::d"},
-      {"void f(int)", "", "f", "(int)", "", "f"},
+      {"main(int, char *[]) ", "", "", "main", "(int, char *[])", "", "main"},
+      {"foo::bar(baz) const", "", "foo", "bar", "(baz)", "const", "foo::bar"},
+      {"foo::~bar(baz)", "", "foo", "~bar", "(baz)", "", "foo::~bar"},
+      {"a::b::c::d(e,f)", "", "a::b::c", "d", "(e,f)", "", "a::b::c::d"},
+      {"void f(int)", "void", "", "f", "(int)", "", "f"},
 
       // Operators
       {"std::basic_ostream<char, std::char_traits<char> >& "
-       "std::operator<<<std::char_traits<char> >"
-       "(std::basic_ostream<char, std::char_traits<char> >&, char const*)",
-       "std", "operator<<<std::char_traits<char> >",
+       "std::operator<<<std::char_traits<char> >(std::basic_ostream<char, "
+       "std::char_traits<char> >&, char const*)",
+       "std::basic_ostream<char, std::char_traits<char> >&", "std",
+       "operator<<<std::char_traits<char> >",
        "(std::basic_ostream<char, std::char_traits<char> >&, char const*)", "",
        "std::operator<<<std::char_traits<char> >"},
       {"operator delete[](void*, clang::ASTContext const&, unsigned long)", "",
-       "operator delete[]", "(void*, clang::ASTContext const&, unsigned long)",
-       "", "operator delete[]"},
-      {"llvm::Optional<clang::PostInitializer>::operator bool() const",
+       "", "operator delete[]",
+       "(void*, clang::ASTContext const&, unsigned long)", "",
+       "operator delete[]"},
+      {"llvm::Optional<clang::PostInitializer>::operator bool() const", "",
        "llvm::Optional<clang::PostInitializer>", "operator bool", "()", "const",
        "llvm::Optional<clang::PostInitializer>::operator bool"},
-      {"(anonymous namespace)::FactManager::operator[](unsigned short)",
+      {"(anonymous namespace)::FactManager::operator[](unsigned short)", "",
        "(anonymous namespace)::FactManager", "operator[]", "(unsigned short)",
        "", "(anonymous namespace)::FactManager::operator[]"},
       {"const int& std::map<int, pair<short, int>>::operator[](short) const",
-       "std::map<int, pair<short, int>>", "operator[]", "(short)", "const",
-       "std::map<int, pair<short, int>>::operator[]"},
-      {"CompareInsn::operator()(llvm::StringRef, InsnMatchEntry const&)",
+       "const int&", "std::map<int, pair<short, int>>", "operator[]", "(short)",
+       "const", "std::map<int, pair<short, int>>::operator[]"},
+      {"CompareInsn::operator()(llvm::StringRef, InsnMatchEntry const&)", "",
        "CompareInsn", "operator()", "(llvm::StringRef, InsnMatchEntry const&)",
        "", "CompareInsn::operator()"},
-      {"llvm::Optional<llvm::MCFixupKind>::operator*() const &",
+      {"llvm::Optional<llvm::MCFixupKind>::operator*() const &", "",
        "llvm::Optional<llvm::MCFixupKind>", "operator*", "()", "const &",
        "llvm::Optional<llvm::MCFixupKind>::operator*"},
       {"auto std::__1::ranges::__begin::__fn::operator()[abi:v160000]<char "
        "const, 18ul>(char const (&) [18ul]) const",
-       "std::__1::ranges::__begin::__fn",
+       "auto", "std::__1::ranges::__begin::__fn",
        "operator()[abi:v160000]<char const, 18ul>", "(char const (&) [18ul])",
        "const",
        "std::__1::ranges::__begin::__fn::operator()[abi:v160000]<char const, "
        "18ul>"},
       // Internal classes
-      {"operator<<(Cls, Cls)::Subclass::function()",
+      {"operator<<(Cls, Cls)::Subclass::function()", "",
        "operator<<(Cls, Cls)::Subclass", "function", "()", "",
        "operator<<(Cls, Cls)::Subclass::function"},
-      {"SAEC::checkFunction(context&) const::CallBack::CallBack(int)",
+      {"SAEC::checkFunction(context&) const::CallBack::CallBack(int)", "",
        "SAEC::checkFunction(context&) const::CallBack", "CallBack", "(int)", "",
        "SAEC::checkFunction(context&) const::CallBack::CallBack"},
       // Anonymous namespace
-      {"XX::(anonymous namespace)::anon_class::anon_func() const",
+      {"XX::(anonymous namespace)::anon_class::anon_func() const", "",
        "XX::(anonymous namespace)::anon_class", "anon_func", "()", "const",
        "XX::(anonymous namespace)::anon_class::anon_func"},
 
       // Lambda
       {"main::{lambda()#1}::operator()() const::{lambda()#1}::operator()() "
        "const",
-       "main::{lambda()#1}::operator()() const::{lambda()#1}", "operator()",
+       "", "main::{lambda()#1}::operator()() const::{lambda()#1}", "operator()",
        "()", "const",
        "main::{lambda()#1}::operator()() const::{lambda()#1}::operator()"},
 
       // Function pointers
-      {"string (*f(vector<int>&&))(float)", "", "f", "(vector<int>&&)", "",
-       "f"},
-      {"void (*&std::_Any_data::_M_access<void (*)()>())()", "std::_Any_data",
-       "_M_access<void (*)()>", "()", "",
+      {"string (*f(vector<int>&&))(float)", "", "", "f",
+       "(vector<int>&&)", "", "f"},
+      {"void (*&std::_Any_data::_M_access<void (*)()>())()", "",
+       "std::_Any_data", "_M_access<void (*)()>", "()", "",
        "std::_Any_data::_M_access<void (*)()>"},
       {"void (*(*(*(*(*(*(*(* const&func1(int))())())())())())())())()", "",
-       "func1", "(int)", "", "func1"},
+       "", "func1", "(int)", "", "func1"},
 
       // Decltype
       {"decltype(nullptr)&& std::forward<decltype(nullptr)>"
        "(std::remove_reference<decltype(nullptr)>::type&)",
-       "std", "forward<decltype(nullptr)>",
+       "decltype(nullptr)&&", "std", "forward<decltype(nullptr)>",
        "(std::remove_reference<decltype(nullptr)>::type&)", "",
        "std::forward<decltype(nullptr)>"},
 
       // Templates
       {"void llvm::PM<llvm::Module, llvm::AM<llvm::Module>>::"
        "addPass<llvm::VP>(llvm::VP)",
-       "llvm::PM<llvm::Module, llvm::AM<llvm::Module>>", "addPass<llvm::VP>",
-       "(llvm::VP)", "",
+       "void", "llvm::PM<llvm::Module, llvm::AM<llvm::Module>>",
+       "addPass<llvm::VP>", "(llvm::VP)", "",
        "llvm::PM<llvm::Module, llvm::AM<llvm::Module>>::"
        "addPass<llvm::VP>"},
       {"void std::vector<Class, std::allocator<Class> >"
        "::_M_emplace_back_aux<Class const&>(Class const&)",
-       "std::vector<Class, std::allocator<Class> >",
+       "void", "std::vector<Class, std::allocator<Class> >",
        "_M_emplace_back_aux<Class const&>", "(Class const&)", "",
        "std::vector<Class, std::allocator<Class> >::"
        "_M_emplace_back_aux<Class const&>"},
       {"unsigned long llvm::countTrailingOnes<unsigned int>"
        "(unsigned int, llvm::ZeroBehavior)",
-       "llvm", "countTrailingOnes<unsigned int>",
+       "unsigned long", "llvm", "countTrailingOnes<unsigned int>",
        "(unsigned int, llvm::ZeroBehavior)", "",
        "llvm::countTrailingOnes<unsigned int>"},
       {"std::enable_if<(10u)<(64), bool>::type llvm::isUInt<10u>(unsigned "
        "long)",
-       "llvm", "isUInt<10u>", "(unsigned long)", "", "llvm::isUInt<10u>"},
-      {"f<A<operator<(X,Y)::Subclass>, sizeof(B)<sizeof(C)>()", "",
+       "std::enable_if<(10u)<(64), bool>::type", "llvm", "isUInt<10u>",
+       "(unsigned long)", "", "llvm::isUInt<10u>"},
+      {"f<A<operator<(X,Y)::Subclass>, sizeof(B)<sizeof(C)>()", "", "",
        "f<A<operator<(X,Y)::Subclass>, sizeof(B)<sizeof(C)>", "()", "",
        "f<A<operator<(X,Y)::Subclass>, sizeof(B)<sizeof(C)>"},
-      {"llvm::Optional<llvm::MCFixupKind>::operator*() const volatile &&",
+      {"llvm::Optional<llvm::MCFixupKind>::operator*() const volatile &&", "",
        "llvm::Optional<llvm::MCFixupKind>", "operator*", "()",
        "const volatile &&", "llvm::Optional<llvm::MCFixupKind>::operator*"},
-      {"void foo<Dummy<char [10]>>()", "", "foo<Dummy<char [10]>>", "()", "",
-       "foo<Dummy<char [10]>>"},
-      {"void foo<Bar<Bar<int>[10]>>()", "", "foo<Bar<Bar<int>[10]>>", "()", "",
-       "foo<Bar<Bar<int>[10]>>"},
-      {"void foo<Bar[10]>()", "", "foo<Bar[10]>", "()", "",
+      {"void foo<Dummy<char [10]>>()", "void", "", "foo<Dummy<char [10]>>",
+       "()", "", "foo<Dummy<char [10]>>"},
+      {"void foo<Bar<Bar<int>[10]>>()", "void", "", "foo<Bar<Bar<int>[10]>>",
+       "()", "", "foo<Bar<Bar<int>[10]>>"},
+      {"void foo<Bar[10]>()", "void", "", "foo<Bar[10]>", "()", "",
        "foo<Bar[10]>"},
-      {"void foo<Bar[]>()", "", "foo<Bar[]>", "()", "",
-       "foo<Bar[]>"},
+      {"void foo<Bar[]>()", "void", "", "foo<Bar[]>", "()", "", "foo<Bar[]>"},
 
       // auto return type
-      {"auto std::test_return_auto<int>() const", "std",
+      {"auto std::test_return_auto<int>() const", "auto", "std",
        "test_return_auto<int>", "()", "const", "std::test_return_auto<int>"},
-      {"decltype(auto) std::test_return_auto<int>(int) const", "std",
-       "test_return_auto<int>", "(int)", "const", "std::test_return_auto<int>"},
+      {"decltype(auto) std::test_return_auto<int>(int) const", "decltype(auto)",
+       "std", "test_return_auto<int>", "(int)", "const",
+       "std::test_return_auto<int>"},
 
       // abi_tag on class method
       {"v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<int>> "
        "v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<int>>"
        "::method2<v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<"
        "int>>>(int, v1::v2::Dummy<int>) const &&",
+       // Return type
+       "v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<int>>",
        // Context
        "v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<int>>",
        // Basename
        "method2<v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<"
        "int>>>",
        // Args, qualifiers
        "(int, v1::v2::Dummy<int>)", "const &&",
        // Full scope-qualified name without args
        "v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<int>>"
        "::method2<v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<"
        "int>>>"},
 
       // abi_tag on free function and template argument
       {"v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<int>> "
        "v1::v2::with_tag_in_ns[abi:f1][abi:f2]<v1::v2::Dummy[abi:c1][abi:c2]"
        "<v1::v2::Dummy[abi:c1][abi:c2]<int>>>(int, v1::v2::Dummy<int>) const "
        "&&",
+       // Return type
+       "v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::Dummy[abi:c1][abi:c2]<int>>",
        // Context
        "v1::v2",
        // Basename
        "with_tag_in_ns[abi:f1][abi:f2]<v1::v2::Dummy[abi:c1][abi:c2]<v1::v2::"
        "Dummy[abi:c1][abi:c2]<int>>>",
        // Args, qualifiers
        "(int, v1::v2::Dummy<int>)", "const &&",
        // Full scope-qualified name without args
        "v1::v2::with_tag_in_ns[abi:f1][abi:f2]<v1::v2::Dummy[abi:c1][abi:c2]<"
        "v1::v2::Dummy[abi:c1][abi:c2]<int>>>"},
 
       // abi_tag with special characters
       {"auto ns::with_tag_in_ns[abi:special tag,0.0][abi:special "
        "tag,1.0]<Dummy<int>>"
        "(float) const &&",
+       // Return type
+       "auto",
        // Context
        "ns",
        // Basename
        "with_tag_in_ns[abi:special tag,0.0][abi:special tag,1.0]<Dummy<int>>",
        // Args, qualifiers
        "(float)", "const &&",
        // Full scope-qualified name without args
        "ns::with_tag_in_ns[abi:special tag,0.0][abi:special "
        "tag,1.0]<Dummy<int>>"},
 
       // abi_tag on operator overloads
-      {"std::__1::error_code::operator bool[abi:v160000]() const",
+      {"std::__1::error_code::operator bool[abi:v160000]() const", "",
        "std::__1::error_code", "operator bool[abi:v160000]", "()", "const",
        "std::__1::error_code::operator bool[abi:v160000]"},
 
-      {"auto ns::foo::operator[][abi:v160000](size_t) const", "ns::foo",
+      {"auto ns::foo::operator[][abi:v160000](size_t) const", "auto", "ns::foo",
        "operator[][abi:v160000]", "(size_t)", "const",
        "ns::foo::operator[][abi:v160000]"},
 
-      {"auto Foo[abi:abc]<int>::operator<<<Foo[abi:abc]<int>>(int) &",
+      {"auto Foo[abi:abc]<int>::operator<<<Foo[abi:abc]<int>>(int) &", "auto",
        "Foo[abi:abc]<int>", "operator<<<Foo[abi:abc]<int>>", "(int)", "&",
        "Foo[abi:abc]<int>::operator<<<Foo[abi:abc]<int>>"}};
 
   for (const auto &test : test_cases) {
     CPlusPlusLanguage::MethodName method(ConstString(test.input));
     EXPECT_TRUE(method.IsValid()) << test.input;
     if (method.IsValid()) {
+      EXPECT_EQ(test.return_type, method.GetReturnType().str());
       EXPECT_EQ(test.context, method.GetContext().str());
       EXPECT_EQ(test.basename, method.GetBasename().str());
       EXPECT_EQ(test.arguments, method.GetArguments().str());
       EXPECT_EQ(test.qualifiers, method.GetQualifiers().str());
       EXPECT_EQ(test.scope_qualified_name, method.GetScopeQualifiedName());
     }
   }
 }