[BUG] Unable to use enums in inspect expressions - `no matching function for call to 'is'`

[filipsajdak]

The current implementation is not supporting enums in inspect expressions.

This cpp2 code

enum class lexeme : std::uint8_t {
    hash,
};

to_string: (e:lexeme) -> auto = {
    return inspect (e) -> std::string {
        is lexeme::hash = "hash";
        is _ = "INTERNAL_ERROR";
    };
}

compiles by cppfront to (skipping enum declaration):

[[nodiscard]] auto to_string(cpp2::in<lexeme> e) -> auto{
    return [&] () -> std::string { auto&& __expr = (e);
        if (cpp2::is<lexeme::hash>(__expr)) { if constexpr( requires{"hash";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF("hash"),std::string> ) return "hash"; else return std::string{}; else return std::string{}; }
        else return "INTERNAL_ERROR"; }
    ()
; }

and fails to compile with the cpp1 compiler with the error:

main.cpp2:26:13: error: no matching function for call to 'is'
[build]         if (cpp2::is<lexeme::hash>(__expr)) { if constexpr( requires{"hash";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF("hash"),std::string> ) return "hash"; else return std::string{}; else return std::string{}; }
[build]             ^~~~~~~~~~~~~~~~~~~~~~
[build] /Users/filipsajdak/dev/execspec/external/cppfront/include/cpp2util.h:517:6: note: candidate template ignored: invalid explicitly-specified argument for template parameter 'C'

The issue is caused that enums cannot match to any provided is function overloads. To handle that we need special overload for enums.

[hsutter]

This now works with the latest checkin:

enum class lexeme : std::uint8_t {
    hash,
};

main: ()->int = {
    e := lexeme::hash;
    std::cout << inspect (e) -> std::string {
        is (lexeme::hash) = "hash";
        is _ = "INTERNAL_ERROR";
    };
}

Thanks!

[filipsajdak]

@hsutter I am testing the main branch.

Below code

#include <variant>
#include <string_view>
#include <iostream>

main: () -> int = {

    v : std::variant<int, double, std::string_view> = 42;

    std::cout << inspect v -> std::string {
        is 42 = "this is 42";
        is 3.14 = "this is pi";
        is "text" = "this is \"text \"";
        is _ = "unknown";
    } << std::endl;
}

returns "unknown".

Generated code:

// ----- Cpp2 support -----
#include "cpp2util.h"

#line 1 "tests/inspect-variant.cpp2"
#include <variant>
#include <string_view>
#include <iostream>

[[nodiscard]] auto main() -> int;

//=== Cpp2 definitions ==========================================================

#line 4 "tests/inspect-variant.cpp2"

[[nodiscard]] auto main() -> int{

    std::variant<int,double,std::string_view> v { 42 }; 

    std::cout << [&] () -> std::string { auto&& __expr = std::move(v);
        if (cpp2::is(__expr, 42)) { if constexpr( requires{"this is 42";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("this is 42")),std::string> ) return "this is 42"; else return std::string{}; else return std::string{}; }
        else if (cpp2::is(__expr, 3.14)) { if constexpr( requires{"this is pi";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("this is pi")),std::string> ) return "this is pi"; else return std::string{}; else return std::string{}; }
        else if (cpp2::is(__expr, "text")) { if constexpr( requires{"this is \"text \"";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("this is \"text \"")),std::string> ) return "this is \"text \""; else return std::string{}; else return std::string{}; }
        else return "unknown"; }
    ()
 << std::endl;}

[hsutter]

Yes, this is fixed by commit 7d743ef.

I was still investigating a similar quirk and just tracked it down to operator_as not being declared before being used, and long story short, GCC up to 11.3 and MSVC worked fine but GCC 12+ and Clang didn't find the match. Now fixed.

---

More detail in case anyone's interested:

Here's a repro in Godbolt: https://godbolt.org/z/85hYeTWEb

It shows GCC 11.3 matching, and GCC 12.1 and Clang failing to match. To make all three match, do either or both of the following:

• EITHER remove namespace cpp2 { ... } and change the call from cpp2::is to just is.
• OR move operator_as to before is.

If anyone knows more about why the Cpp1 language rule is this way, I'd be happy to learn more about it. My guess is that it's some wrinkle or interaction in the two-phase-lookup and ADL lookup rules, because it seems to have aspects of phase 1 (the declaration isn't found unless it's lexically earlier) and phase 2 (the declaration is found even though it's later as long as it's in the same namespace)... my best guess is something like 'for phase 2 name lookup of a dependent call, ADL considers only declarations visible to phase 1'? But that's only a guess. A Core expert would likely rattle off the clause in the standard that says this and give more detail about why it is this way. :) My guess is that it's in the ADL clauses, but it could be in the two-phase lookup clauses, or an interaction of both.

In the meantime, I've just worked around it by just moving the operator_as template to before the is template that uses it.