Update based on review feedback; fix tests

Author: AaronBallman

clang-tools-extra/clangd/IncludeFixer.cpp

@@ -84,7 +84,6 @@ std::vector<Fix> IncludeFixer::fix(DiagnosticsEngine::Level DiagLevel,
   case diag::err_array_incomplete_or_sizeless_type:
   case diag::err_array_size_incomplete_type:
   case diag::err_asm_incomplete_type:
-  case diag::err_assoc_type_incomplete:
   case diag::err_bad_cast_incomplete:
   case diag::err_call_function_incomplete_return:
   case diag::err_call_incomplete_argument:

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10426,11 +10426,11 @@ def warn_type_safety_null_pointer_required : Warning<
 
 // Generic selections.
 def ext_assoc_type_incomplete : Extension<
-  "ISO C requires a complete type in a '_Generic' association; %0 is an "
-  "incomplete type">;
+  "incomplete type %0 in a '_Generic' association is a C2y extension">,
+  InGroup<C2y>;
 def warn_c2y_compat_assoc_type_incomplete : Warning<
-  "use of an incomplete type in a '_Generic' association is incompatible with "
-  "C standards before C2y; %0 is an incomplete type">,
+  "use of incomplete type %0 in a '_Generic' association is incompatible with "
+  "C standards before C2y">,
   InGroup<CPre2yCompat>, DefaultIgnore;
 def err_assoc_type_nonobject : Error<
   "type %0 in generic association not an object type">;

clang/lib/Sema/SemaStmt.cpp

@@ -2269,11 +2269,10 @@ StmtResult Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
       for (auto *DI : DS->decls()) {
         if (VarDecl *VD = dyn_cast<VarDecl>(DI)) {
           VarDeclSeen = true;
-          if (VD->isLocalVarDecl() && !VD->hasLocalStorage())
-            Diag(DI->getLocation(),
-                 getLangOpts().C23
-                     ? diag::warn_c17_non_local_variable_decl_in_for
-                     : diag::ext_c23_non_local_variable_decl_in_for);
+          if (VD->isLocalVarDecl() && !VD->hasLocalStorage()) {
+            Diag(DI->getLocation(), diag::err_non_local_variable_decl_in_for);
+            DI->setInvalidDecl();
+          }
         } else if (!NonVarSeen) {
           // Keep track of the first non-variable declaration we saw so that
           // we can diagnose if we don't see any variable declarations. This
@@ -2285,9 +2284,7 @@ StmtResult Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
       // Diagnose if we saw a non-variable declaration but no variable
       // declarations.
       if (NonVarSeen && !VarDeclSeen)
-        Diag(NonVarSeen->getLocation(),
-             getLangOpts().C23 ? diag::warn_c17_non_variable_decl_in_for
-                               : diag::ext_c23_non_variable_decl_in_for);
+        Diag(NonVarSeen->getLocation(), diag::err_non_variable_decl_in_for);
     }
   }
 
@@ -4052,9 +4049,9 @@ StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
           Diag(ReturnLoc, D) << CurDecl << isa<CXXDestructorDecl>(CurDecl)
                              << RetValExp->getSourceRange();
         }
-        // return (some void expression); is legal in C++.
+        // return (some void expression); is legal in C++ and C2y.
         else if (D != diag::ext_return_has_void_expr ||
-                 !getLangOpts().CPlusPlus) {
+                 (!getLangOpts().CPlusPlus && !getLangOpts().C2y)) {
           NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
 
           int FunctionKind = 0;

clang/test/C/C2y/n3409.c

@@ -19,14 +19,18 @@ void foo() {
   (void)(void)1;
   // FIXME: same with this.
   x;
-  _Generic(x, void: 1);      /* pre-c2y-warning {{use of an incomplete type in a '_Generic' association is incompatible with C standards before C2y; 'void' is an incomplete type}}
-                                ext-warning {{ISO C requires a complete type in a '_Generic' association; 'void' is an incomplete type}}
+  _Generic(x, void: 1);      /* pre-c2y-warning {{use of incomplete type 'void' in a '_Generic' association is incompatible with C standards before C2y}}
+                                ext-warning {{incomplete type 'void' in a '_Generic' association is a C2y extension}}
                               */
-  _Generic(x, typeof(x): 1); /* pre-c2y-warning {{use of an incomplete type in a '_Generic' association is incompatible with C standards before C2y; 'typeof (x)' (aka 'void') is an incomplete type}}
-                                ext-warning {{ISO C requires a complete type in a '_Generic' association; 'typeof (x)' (aka 'void') is an incomplete type}}
+  _Generic(x, typeof(x): 1); /* pre-c2y-warning {{use of incomplete type 'typeof (x)' (aka 'void') in a '_Generic' association is incompatible with C standards before C2y}}
+                                ext-warning {{incomplete type 'typeof (x)' (aka 'void') in a '_Generic' association is a C2y extension}}
                               */
   (void)_Generic(void, default : 1); /* pre-c2y-warning {{passing a type argument as the first operand to '_Generic' is incompatible with C standards before C2y}}
                                         ext-warning {{passing a type argument as the first operand to '_Generic' is a C2y extension}}
                                       */
-}
 
+  // This is not sufficiently important of an extension to warrant a "not
+  // compatible with standards before C2y" warning, but it is an extension in
+  // C23 and earlier.
+  return x; // ext-warning {{void function 'foo' should not return void expression}}
+}

clang/test/Sema/generic-selection-type-extension.c

@@ -37,7 +37,7 @@ static_assert(_Generic(ci, int : 1, const int : 0) == 1); // expected-warning {{
 // but the expression operand form still rejects them.
 static_assert(_Generic(struct incomplete, struct incomplete : 1, default : 0) == 1);
 static_assert(_Generic(struct another_incomplete, struct incomplete : 1, default : 0) == 0);
-static_assert(_Generic(1, struct also_incomplete : 1, default : 0) == 0); // expected-error {{type 'struct also_incomplete' in generic association incomplete}}
+static_assert(_Generic(1, struct also_incomplete : 1, default : 0) == 0);
 
 void foo(int);
 static_assert(_Generic(__typeof__(foo), void(int) : 1, default : 0) == 1);

clang/test/Sema/generic-selection.c

@@ -5,7 +5,7 @@ void g(void);
 
 void foo(int n) {
   (void) _Generic(0, // ext-warning {{'_Generic' is a C11 extension}}
-      struct A: 0, // expected-error {{type 'struct A' in generic association incomplete}}
+      struct A: 0, // ext-warning {{incomplete type 'struct A' in a '_Generic' association is a C2y extension}}
       void(): 0,   // expected-error {{type 'void ()' in generic association not an object type}}
       int[n]: 0);  // expected-error {{type 'int[n]' in generic association is a variably modified type}}
 

clang/test/SemaCXX/generic-selection.cpp

@@ -81,10 +81,10 @@ void func(struct S s) {
   // is an elaborated type specifier followed by the association's value and
   // it should work the same as in C.
   (void)_Generic(s, struct S : 1);
+  (void)_Generic(s, struct T : 1);
 
   // The rest of these cases test that we still produce a reasonable diagnostic
   // when referencing an unknown type or trying to define a type in other ways.
-  (void)_Generic(s, struct T : 1);            // expected-error {{type 'struct T' in generic association incomplete}}
   (void)_Generic(s, struct U { int a; } : 1); // expected-error {{'U' cannot be defined in a type specifier}}
   (void)_Generic(s, struct V : S);            // expected-error {{'S' does not refer to a value}}
   (void)_Generic(s, struct W : S { int b; } : 1); // expected-error {{expected '(' for function-style cast or type construction}}