Handle cv qualifiers on function pointers and handle unnamed types

Author: jeremy-rifkin

src/prune_symbol.cpp

@@ -413,10 +413,11 @@ namespace detail {
                  | operator
                  | name
                  | lambda
+                 | unnamed
 
     function-pointer := "(" pointer-refs-junk symbol ")"
 
-    pointer-refs-junk := { function-pointer-modifier } { pointer-refs }
+    pointer-refs-junk := { function-pointer-modifier } { pointer-refs } { ignored-identifier }
 
     anonymous-namespace := "(anonymous namespace)" | "`anonymous namespace'"
 
@@ -445,6 +446,9 @@ namespace detail {
             | LITERAL                          // 'lambda*' or `symbol'
             | "<" IDENTIFIER ">"               // lambda_*
 
+    unnamed := "{" "unnamed" "#" LITERAL "}"
+             | LITERAL                         // 'unnamed*'
+
     balanced-punctuation := "(" balanced-punctuation-innards ")"
                           | "[" balanced-punctuation-innards "]"
                           | "<" balanced-punctuation-innards ">"
@@ -695,17 +699,30 @@ namespace detail {
             return did_consume;
         }
 
-        NODISCARD Result<bool, parse_error> accept_lambda() {
+        NODISCARD Result<bool, parse_error> accept_lambda_or_unnamed() {
             // LLVM does main::'lambda'<...>(...)::operator()<...>(...) -- apparently this can be 'lambda<count>'
             // GCC does main::{lambda<...>(...)#1}::operator()<...>(...)
             // MSVC does `int main(void)'::`2'::<lambda_1>::operator()<...>(...)
             // https://github.com/llvm/llvm-project/blob/90beda2aba3cac34052827c560449fcb184c7313/libcxxabi/src/demangle/ItaniumDemangle.h#L1848-L1850 TODO: What about the count?
             // https://github.com/gcc-mirror/gcc/blob/b76f1fb7bf8a7b66b8acd469309257f8b18c0c51/libiberty/cp-demangle.c#L6210-L6251 TODO: What special characters can appear?
             TRY_TOK(opening_brace, tokenizer.accept({token_type::punctuation, "{"}));
             if(opening_brace) {
+                optional<token> token1;
+                optional<token> token2;
                 TRY_TOK(lambda_token, tokenizer.accept({token_type::identifier, "lambda"}));
-                if(!lambda_token) {
-                    return parse_error{};
+                if(lambda_token) {
+                    token1 = lambda_token;
+                } else {
+                    TRY_TOK(unnamed_token, tokenizer.accept({token_type::identifier, "unnamed"}));
+                    if(!unnamed_token) {
+                        return parse_error{};
+                    }
+                    TRY_TOK(type_token, tokenizer.accept({token_type::identifier, "type"}));
+                    if(!type_token) {
+                        return parse_error{};
+                    }
+                    token1 = unnamed_token;
+                    token2 = type_token;
                 }
                 TRY_PARSE(consume_punctuation(), (void)0);
                 TRY_TOK(hash_token, tokenizer.accept({token_type::punctuation, "#"}));
@@ -721,7 +738,10 @@ namespace detail {
                     return parse_error{};
                 }
                 append_output({token_type::punctuation, "<"});
-                append_output(lambda_token.unwrap());
+                append_output(token1.unwrap());
+                if(token2) {
+                    append_output(token2.unwrap());
+                }
                 append_output(hash_token.unwrap());
                 append_output(discriminator_token.unwrap());
                 append_output({token_type::punctuation, ">"});
@@ -731,7 +751,10 @@ namespace detail {
             if(
                 maybe_literal_token
                 && maybe_literal_token.unwrap().type == token_type::literal
-                && maybe_literal_token.unwrap().str.starts_with("'lambda")
+                && (
+                    maybe_literal_token.unwrap().str.starts_with("'lambda")
+                    || maybe_literal_token.unwrap().str.starts_with("'unnamed")
+                )
                 && maybe_literal_token.unwrap().str.ends_with("'")
             ) {
                 tokenizer.advance();
@@ -822,7 +845,10 @@ namespace detail {
                     } else if(
                         next
                         && next.unwrap().type == token_type::identifier
-                        && is_microsoft_calling_convention(next.unwrap().str)
+                        && (
+                            is_microsoft_calling_convention(next.unwrap().str)
+                            || is_ignored_identifier(next.unwrap().str)
+                        )
                     ) {
                         tokenizer.advance();
                     } else {
@@ -851,7 +877,7 @@ namespace detail {
             TRY_PARSE(accept_anonymous_namespace(), return true);
             TRY_PARSE(accept_operator(), return true);
             TRY_PARSE(accept_identifier_token(), return true);
-            TRY_PARSE(accept_lambda(), return true);
+            TRY_PARSE(accept_lambda_or_unnamed(), return true);
             return false;
         }
 

test/unit/lib/prune_symbol.cpp

@@ -412,6 +412,12 @@ TEST(PruneSymbolTests, FunctionPointers) {
     DO_TEST("void (__cdecl&baz<int>(void))(int,double)", "baz");
 }
 
+TEST(PruneSymbolTests, UnnamedTypes) {
+    // https://godbolt.org/z/jx8GnrW4v
+    DO_TEST("main::'unnamed'::foo()", "main::<unnamed>::foo");
+    DO_TEST("main::{unnamed type#1}::foo()", "main::<unnamed type#1>::foo");
+}
+
 TEST(PruneSymbolTests, TemplateHeavySymbols) {
     // https://godbolt.org/z/z1nrMsYfs
     DO_TEST("__find_if<__gnu_cxx::__normal_iterator<int*, std::vector<int> >, __gnu_cxx::__ops::_Iter_pred<main()::<lambda(auto:19)> > >", "__find_if");
@@ -481,4 +487,13 @@ TEST(PruneSymbolTests, Extra) {
     DO_TEST("void foo<std::basic_string<char>>(std::basic_string<char> const&)", "foo");
 }
 
+TEST(PruneSymbolTests, RegressionTests) {
+    // Symbols I've observed not pruning correctly
+    DO_TEST("void (* const&std::_Any_data::_M_access<void (*)(cpptrace::v1::log_level, char const*)>() const)(cpptrace::v1::log_level, char const*)", "std::_Any_data::_M_access");
+    DO_TEST("void (* const*std::__addressof<void (* const)(cpptrace::v1::log_level, char const*)>(void (* const&)(cpptrace::v1::log_level, char const*)))(cpptrace::v1::log_level, char const*)", "std::__addressof");
+    DO_TEST("void (* const&std::forward<void (* const&)(cpptrace::v1::log_level, char const*)>(std::remove_reference<void (* const&)(cpptrace::v1::log_level, char const*)>::type&))(cpptrace::v1::log_level, char const*)", "std::forward");
+    DO_TEST("fmt::v10::detail::parse_format_specs<char>(char const*, char const*, fmt::v10::detail::dynamic_format_specs<char>&, fmt::v10::basic_format_parse_context<char>&, fmt::v10::detail::type)::{unnamed type#1}::operator()(fmt::v10::detail::state, bool)", "fmt::v10::detail::parse_format_specs::<unnamed type#1>::operator()");
+    DO_TEST("fmt::v10::detail::parse_format_specs<char>(char const*, char const*, fmt::v10::detail::dynamic_format_specs<char>&, fmt::v10::basic_format_parse_context<char>&, fmt::v10::detail::type)::{unnamed type#2}::operator()(fmt::v10::presentation_type, int)", "fmt::v10::detail::parse_format_specs::<unnamed type#2>::operator()");
+}
+
 }