[Bug c++/91465] [9 Regression] unexpected expression of kind overload (ICE)

["mpolacek at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91465

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|[9/10 Regression]           |[9 Regression] unexpected
                   |unexpected expression of    |expression of kind overload
                   |kind overload  (ICE)        | (ICE)

--- Comment #9 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
commit d417b4f5414d9076300ab41974a14424f722688c
Author: Marek Polacek <polacek@redhat.com>
Date:   Fri Feb 28 16:57:04 2020 -0500

    c++: Fix convert_like in template [PR91465, PR93870, PR92031, PR94068]

    The point of this patch is to fix the recurring problem of trees
    generated by convert_like while processing a template that break when
    substituting.  For instance, when convert_like creates a CALL_EXPR
    while in a template, substituting such a call breaks in finish_call_expr
    because we have two 'this' arguments.  Another problem is that we
    can create &TARGET_EXPR<> and then fail when substituting because we're
    taking the address of an rvalue.  I've analyzed some of the already fixed
    PRs and also some of the currently open ones:

    In c++/93870 we create EnumWrapper<E>::operator E(&operator~(E)).
    In c++/87145 we create S::operator int (&{N}).
    In c++/92031 we create &TARGET_EXPR <0>.

    The gist of the problem is when convert_like_real creates a call for
    a ck_user or wraps a TARGET_EXPR in & in a template.  So in these cases
    use IMPLICIT_CONV_EXPR.  In a template we shouldn't need to perform the
    actual conversion, we only need it's result type.
    perform_direct_initialization_if_possible and
    perform_implicit_conversion_flags can also create an IMPLICIT_CONV_EXPR.

    Given the change above, build_converted_constant_expr can return an
    IMPLICIT_CONV_EXPR so call fold_non_dependent_expr rather than
    maybe_constant_value to deal with that.

    To avoid the problem of instantiating something twice in a row I'm
    removing a call to instantiate_non_dependent_expr_sfinae in
    compute_array_index_type_loc.  And the build_converted_constant_expr
    pattern can now be simplified.

    2020-03-09  Marek Polacek  <polacek@redhat.com>

            PR c++/92031 - bogus taking address of rvalue error.
            PR c++/91465 - ICE with template codes in check_narrowing.
            PR c++/93870 - wrong error when converting template non-type arg.
            PR c++/94068 - ICE with template codes in check_narrowing.
            * call.c (convert_like_real): Return IMPLICIT_CONV_EXPR
            in a template when not ck_identity and we're dealing with a class.
            (convert_like_real) <case ck_ref_bind>: Return IMPLICIT_CONV_EXPR
            in a template if we need a temporary.
            * decl.c (compute_array_index_type_loc): Remove
            instantiate_non_dependent_expr_sfinae call.  Call
            fold_non_dependent_expr instead of maybe_constant_value.
            (build_explicit_specifier): Don't instantiate or create a sentinel
            before converting the expression.
            * except.c (build_noexcept_spec): Likewise.
            * pt.c (convert_nontype_argument): Don't build IMPLICIT_CONV_EXPR.
            Set IMPLICIT_CONV_EXPR_NONTYPE_ARG if that's what
            build_converted_constant_expr returned.
            * typeck2.c (check_narrowing): Call fold_non_dependent_expr instead
            of maybe_constant_value.

            * g++.dg/cpp0x/conv-tmpl2.C: New test.
            * g++.dg/cpp0x/conv-tmpl3.C: New test.
            * g++.dg/cpp0x/conv-tmpl4.C: New test.
            * g++.dg/cpp0x/conv-tmpl5.C: New test.
            * g++.dg/cpp0x/conv-tmpl6.C: New test.
            * g++.dg/cpp1z/conv-tmpl1.C: New test.