[Bug c++/90679] Template specialization with const: “ambiguous template instantiation” error

[Bug c++/90679] Template specialization with const: “ambiguous template instantiation” error

[cvs-commit at gcc dot gnu.org]

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

--- Comment #1 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Patrick Palka <ppalka@gcc.gnu.org>:

https://gcc.gnu.org/g:6d27ee7fcc3e31c2142124027dc87e5a0288c9ab

commit r14-6714-g6d27ee7fcc3e31c2142124027dc87e5a0288c9ab
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Dec 19 11:26:34 2023 -0500

    c++: refine dependent_alias_template_spec_p [PR90679]

    For a (complex) alias template-id, dependent_alias_template_spec_p
    returns true if any template argument of the template-id is dependent.
    This predicate indicates that substitution into the template-id may
    behave differently with respect to SFINAE than substitution into the
    expanded alias, and so the alias is in a way non-transparent.

    For example, 'first_t<T, T&>' in

      template<class T, class...> using first_t = T;
      template<class T> first_t<T, T&> f();

    is such an alias template-id since first_t doesn't use its second
    template parameter and so the substitution into the expanded alias would
    discard the SFINAE effects of the corresponding (dependent) argument 'T&'.

    But this predicate is overly conservative since what really matters for
    sake of SFINAE equivalence is whether a template argument corresponding
    to an _unused_ template parameter is dependent.  So the predicate should
    return false for e.g. 'first_t<T&, int>'.

    This patch refines the predicate appropriately.  We need to be able to
    efficiently determine which template parameters of a complex alias
    template are unused, so to that end we add a new out parameter to
    complex_alias_template_p and cache its result in an on-the-side hash_map
    that replaces the existing TEMPLATE_DECL_COMPLEX_ALIAS_P flag.

            PR c++/90679

    gcc/cp/ChangeLog:

            * cp-tree.h (TEMPLATE_DECL_COMPLEX_ALIAS_P): Remove.
            (most_general_template): Constify parameter.
            * pt.cc (push_template_decl): Adjust after removing
            TEMPLATE_DECL_COMPLEX_ALIAS_P.
            (complex_alias_tmpl_info): New hash_map.
            (uses_all_template_parms_data::seen): Change type to
            tree* from bool*.
            (complex_alias_template_r): Adjust accordingly.
            (complex_alias_template_p): Add 'seen_out' out parameter.
            Call most_general_template and check PRIMARY_TEMPLATE_P.
            Use complex_alias_tmpl_info to cache the result and set
            '*seen_out' accordigly.
            (dependent_alias_template_spec_p): Add !processing_template_decl
            early exit test.  Consider dependence of only template arguments
            corresponding to seen template parameters as per

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/alias-decl-76.C: New test.

[Bug c++/90679] Template specialization with const: “ambiguous template instantiation” error

[cvs-commit at gcc dot gnu.org]

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

--- Comment #2 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Patrick Palka <ppalka@gcc.gnu.org>:

https://gcc.gnu.org/g:0a37463758dabc9647fa3d675dffdf43a737035d

commit r14-6715-g0a37463758dabc9647fa3d675dffdf43a737035d
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Dec 19 11:40:15 2023 -0500

    c++: partial ordering and dep alias tmpl specs [PR90679]

    During partial ordering, we want to look through dependent alias
    template specializations within template arguments and otherwise
    treat them as opaque in other contexts (see e.g. r7-7116-g0c942f3edab108
    and r11-7011-g6e0a231a4aa240).  To that end template_args_equal was
    given a partial_order flag that controls this behavior.  This flag
    does the right thing when a dependent alias template specialization
    appears as template argument of the partial specialization, e.g. in

      template<class T, class...> using first_t = T;
      template<class T> struct traits;
      template<class T> struct traits<first_t<T, T&>> { }; // #1
      template<class T> struct traits<first_t<const T, T&>> { }; // #2

    we correctly consider #2 to be more specialized than #1.  But if the
    alias specialization appears as a nested template argument of another
    class template specialization, e.g. in

      template<class T> struct traits<A<first_t<T, T&>>> { }; // #1
      template<class T> struct traits<A<first_t<const T, T&>>> { }; // #2

    then we incorrectly consider #1 and #2 to be unordered.  This is because

      1. we don't propagate the flag to recursive template_args_equal calls
      2. we don't use structural equality for class template specializations
         written in terms of dependent alias template specializations

    This patch fixes the first issue by turning the partial_order flag into
    a global.  This patch fixes the second issue by making us propagate
    structural equality appropriately when building a class template
    specialization.  In passing this patch also improves hashing of
    specializations that use structural equality.

            PR c++/90679

    gcc/cp/ChangeLog:

            * cp-tree.h (comp_template_args): Remove partial_order parameter.
            (template_args_equal): Likewise.
            * pt.cc (comparing_for_partial_ordering): New global flag.
            (iterative_hash_template_arg) <case tcc_type>: Hash the template
            and arguments for specializations that use structural equality.
            (template_args_equal): Remove partial order parameter and
            use comparing_for_partial_ordering instead.
            (comp_template_args): Likewise.
            (comp_template_args_porder): Set comparing_for_partial_ordering
            instead.  Make static.
            (any_template_arguments_need_structural_equality_p): Return true
            for an argument that's a dependent alias template specialization
            or a class template specialization that itself needs structural
            equality.
            * tree.cc (cp_tree_equal) <case TREE_VEC>: Adjust call to
            comp_template_args.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/alias-decl-75a.C: New test.
            * g++.dg/cpp0x/alias-decl-75b.C: New test.

[Bug c++/90679] Template specialization with const: “ambiguous template instantiation” error

[ppalka at gcc dot gnu.org]

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

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Assignee|unassigned at gcc dot gnu.org      |ppalka at gcc dot gnu.org
         Resolution|---                         |FIXED
   Target Milestone|---                         |14.0
                 CC|                            |ppalka at gcc dot gnu.org
             Status|UNCONFIRMED                 |RESOLVED

--- Comment #3 from Patrick Palka <ppalka at gcc dot gnu.org> ---
Fixed for GCC 14, thanks for the bug report.