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.