fix bug that undefined internal is a warning only for -pedantic-errors (#98016)

This fixes issue #39558 which mentions the problem when compiling the
following code with `-pedantic-errors` flag (it also mentions `-Wall
-Wextra` but those shouldn't change the output, which is also the case
in GCC):

```c
static void f();

int main()
{
    f;
}
```

Clang only outputs an `undefined-internal` warning on the first line,
but according to 6.9/3

```
"... Moreover, if an identifier declared with internal linkage is used in an
 expression (other than as a part of the operand of a sizeof or _Alignof
 operator whose result is an integer constant), there shall be exactly one
 external definition for the identifier in the translation unit."
```

this should be illegal and hence an error.

I fixed this by changing the warning type from `Warning` to `ExtWarn`
and by adding a suitable test.

Author: ccrownhill

clang/docs/ReleaseNotes.rst

@@ -592,6 +592,9 @@ Attribute Changes in Clang
 
 Improvements to Clang's diagnostics
 -----------------------------------
+- Clang now emits an error instead of a warning for ``-Wundefined-internal``
+  when compiling with `-pedantic-errors` to conform to the C standard
+
 - Clang now applies syntax highlighting to the code snippets it
   prints.
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -6016,7 +6016,7 @@ def note_deleted_assign_field : Note<
   "because field %2 is of %select{reference|const-qualified}4 type %3">;
 
 // These should be errors.
-def warn_undefined_internal : Warning<
+def warn_undefined_internal : ExtWarn<
   "%select{function|variable}0 %q1 has internal linkage but is not defined">,
   InGroup<DiagGroup<"undefined-internal">>;
 def err_undefined_internal_type : Error<

clang/test/Sema/undefined-internal-basic.c

@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -Wno-pointer-arith -Wno-gnu-alignof-expression -Wno-unused -pedantic-errors
+
+static void *a(void); // expected-error {{function 'a' has internal linkage but is not defined}}
+static void *b(void); // expected-error {{function 'b' has internal linkage but is not defined}}
+static void *c(void); // expected-error {{function 'c' has internal linkage but is not defined}}
+static void *d(void); // expected-error {{function 'd' has internal linkage but is not defined}}
+static void *no_err(void);
+
+int main(void)
+{
+    a; // expected-note {{used here}}
+    
+    int i = _Alignof(no_err);
+
+    int j = _Generic(&no_err, void *(*)(void): 0);
+
+    void *k = _Generic(&no_err, void *(*)(void): b(), default: 0); // expected-note {{used here}}
+
+    // FIXME according to the C standard there should be no error if the undefined internal is
+    // "part of the expression in a generic association that is not the result expression of its generic selection;"
+    // but, currently, clang wrongly emits an error in this case
+    k = _Generic(&no_err, void *(*)(void): 0, default: c()); // expected-note {{used here}}
+
+    k = _Generic(&no_err, int (*)(void) : 0, default : d()); // expected-note {{used here}}
+
+    int l = sizeof(no_err);
+
+    __typeof__(&no_err) x;
+}

clang/test/Sema/undefined-internal-typeof-c23.c

@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c23 -pedantic-errors
+
+// expected-no-diagnostics
+
+static int f(void);
+
+int main(void)
+{
+    typeof(&f) x;
+}