[Bug c++/114812] New: Arguments of array type decay to pointer type too eagerly when used as arguments to ref- or ptr-to-function

["rkraesig at mozilla dot com" <gcc-bugzilla@gcc.gnu.org>]

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

            Bug ID: 114812
           Summary: Arguments of array type decay to pointer type too
                    eagerly when used as arguments to ref- or
                    ptr-to-function
           Product: gcc
           Version: 13.2.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: rkraesig at mozilla dot com
  Target Milestone: ---

In a function-call expression, if the value F invoked as a function is of type
reference-to-function or pointer-to-function, a value of reference-to-array
type passed as an argument to F appears to be immediately converted to the
corresponding pointer type to which it would decay.

This prevents implicit converting constructors for the nominal argument types
of F which would convert from reference-to-array from being found.

This does not occur if F is of function type, nor if it is of some object type
with an `operator()`; in these cases the array type is passed without decay.

Example code (also at https://godbolt.org/z/jjKE31G7r):

  struct S {
    S(const int (&)[2]) {}
    // S(const int *) {} // footnote [0]
  };

  static const int arr[] = {17, 42};
  void func(S s) {}

  void test() {
    void (&f)(S) = func;
    f(arr);                      // fails on GCC; succeeds on clang & MSVC
    // func(arr);                // succeeds everywhere
    // (std::function{f})(arr);  // succeeds everywhere
  }


[0] If this alternate constructor is uncommented, the above code will compile
successfully under GCC... but will fail to compile on clang and MSVC, which
reject `f(arr);` as ambiguous.


Per testing on godbolt, this is not a recent regression, but appears to happen
on every version of GCC back to at least 4.1.2.