[Clang] Clang and GCC diverge on array reference overload resolution with int const(&)[] vs int const(&)[1]

[Xniao]

Generated by Fuzzer.

GCC correctly accepts the call as unambiguous, selecting the more specific [1] overload, while Clang incorrectly rejects it with an "ambiguous call" error.
Reproducer: https://godbolt.org/z/4YTerK8Ws

Program:

int f2(int const (&)[]) { return 1; }
int f2(int const (&)[1]) {
  const int size = 1;
  int array[size] = {42};
  if (array[0] > 0) {
    int value_2 = f2(array);
    return value_2;
  }
  return 2;
}

int main() {
  if (f2({}) != 1) return -1;
  if (f2({1}) != 2) return -1;
  return 0;
}

Clang rejects it with following error message:

<source>:6:19: error: call to 'f2' is ambiguous
    6 |     int value_2 = f2(array);
      |                   ^~
<source>:1:5: note: candidate function
    1 | int f2(int const (&)[]) { return 1; }
      |     ^
<source>:2:5: note: candidate function
    2 | int f2(int const (&)[1]) {
      |     ^
1 error generated.
Compiler returned: 1

[chrchr-github]

FWIW, msvc and EDG also reject: https://godbolt.org/z/KnzW4o6df

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Jireh Guo (Xniao)

**_Generated by Fuzzer._**

GCC correctly accepts the call as unambiguous, selecting the more specific [1] overload, while Clang incorrectly rejects it with an "ambiguous call" error.
Reproducer: https://godbolt.org/z/4YTerK8Ws

Program:

int f2(int const (&)[]) { return 1; }
int f2(int const (&)[1]) {
  const int size = 1;
  int array[size] = {42};
  if (array[0] > 0) {
    int value_2 = f2(array);
    return value_2;
  }
  return 2;
}

int main() {
  if (f2({}) != 1) return -1;
  if (f2({1}) != 2) return -1;
  return 0;
}

Clang rejects it with following error message:

<source>:6:19: error: call to 'f2' is ambiguous
    6 |     int value_2 = f2(array);
      |                   ^~
<source>:1:5: note: candidate function
    1 | int f2(int const (&)[]) { return 1; }
      |     ^
<source>:2:5: note: candidate function
    2 | int f2(int const (&)[1]) {
      |     ^
1 error generated.
Compiler returned: 1

[frederick-vs-ja]

The following reduced example is accepted by EDG. https://godbolt.org/z/zoqP7odce

void f(const int (&)[]);
void f(const int (&)[1]);

int main() {
  const int a[1]{};
  f(a);
}

GCC and EDG are correct for this, see [over.ics.rank]/3.2.6 and CWG2803.

---

If we change to use list-initialization to create temporary objects, only EDG rejects some uses. https://godbolt.org/z/qMWYoneh8

void f(const int (&)[]);
void f(const int (&)[1]);

int main() {
  f({});
  f({1});
}

Looks like that EDG is clearly wrong for the second example, as it doesn't reject invalid const int(&)[0] immediately. GCC also seems wrong as it selects the first overload. However, the standard wording is a bit unclear, see CWG2741. I believe Clang and MSVC are correct for this example.

---

When changing to use pointers, only MSVC rejects the example, which is probably wrong. https://godbolt.org/z/ePY5vjKjv

void g(const int (*)[]);
void g(const int (*)[1]);

int main() {
  const int a[1]{};
  g(&a);
}