Allow parameter names to be elided in a function definition in C

[aaron.ballman]

Summary

WG14 has adopted N2480 (http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2480.pdf) into C2x at the meetings last week, allowing parameter names of a function definition to be elided. This patch relaxes the error so that C++ and C2x do not diagnose this situation, and modes before C2x will allow it as an extension.

This also adds the same feature to ObjC blocks under the assumption that ObjC wishes to follow the C standard in this regard.

[erik.pilkington]

This also adds the same feature to ObjC blocks under the assumption that ObjC wishes to follow the C standard in this regard.

SGTM - thats generally been the idea for blocks.

[rsmith]

clang/include/clang/Basic/DiagnosticSemaKinds.td

278

Why the extra "m"? This was spelled correctly before.

[aaron.ballman]

I've committed in 86b5eabfeab164dcb680f6690e7718e3d21ceeb5

clang/include/clang/Basic/DiagnosticSemaKinds.td

278

I fat-fingered that, good catch! I've corrected the issue in the commit.

[dexonsmith]

In D77586#1967052, @erik.pilkington wrote:

This also adds the same feature to ObjC blocks under the assumption that ObjC wishes to follow the C standard in this regard.

SGTM - thats generally been the idea for blocks.

Note that -fblocks is a C extension, not just Objective-C. (SGTM to me too.)

clang/include/clang/Basic/DiagnosticGroups.td

def DelegatingCtorCycles :
   DiagGroup<"delegating-ctor-cycles">;
 
 // A warning group for warnings about using C11 features as extensions.
 def C11 : DiagGroup<"c11-extensions">;
 
 // A warning group for warnings about using C99 features as extensions.
 def C99 : DiagGroup<"c99-extensions", [C99Designator]>;
 
+// A warning group for warnings about using C2x features as extensions.
+def C2x : DiagGroup<"c2x-extensions">;
+
 // A warning group for warnings about GCC extensions.
 def GNU : DiagGroup<"gnu", [GNUAlignofExpression, GNUAnonymousStruct,
                             GNUAutoType,
                             GNUBinaryLiteral, GNUCaseRange,
                             GNUComplexInteger, GNUCompoundLiteralInitializer,
                             GNUConditionalOmittedOperand, GNUDesignator,
                             GNUEmptyInitializer, GNUEmptyStruct,
                             VLAExtension, GNUFlexibleArrayInitializer,

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_redeclaration_different_type : Error<
   "redeclaration of %0 with a different type%diff{: $ vs $|}1,2">;
 def err_bad_variable_name : Error<
   "%0 cannot be the name of a variable or data member">;
 def err_bad_parameter_name : Error<
   "%0 cannot be the name of a parameter">;
 def err_bad_parameter_name_template_id : Error<
   "parameter name cannot have template arguments">;
-def err_parameter_name_omitted : Error<"parameter name omitted">;
+def ext_parameter_name_ommitted_c2x : ExtWarn<
+  "omitting the parameter name in a function definition is a C2x extension">,
+  InGroup<C2x>;
 def err_anyx86_interrupt_attribute : Error<
   "%select{x86|x86-64}0 'interrupt' attribute only applies to functions that "
   "have %select{a 'void' return type|"
   "only a pointer parameter optionally followed by an integer parameter|"
   "a pointer as the first parameter|a %2 type as the second parameter}1">;
 def err_anyx86_interrupt_called : Error<
   "interrupt service routine cannot be called directly">;
 def warn_arm_interrupt_calling_convention : Warning<

clang/lib/Sema/SemaChecking.cpp

         RequireCompleteType(Param->getLocation(), Param->getType(),
                             diag::err_typecheck_decl_incomplete_type)) {
       Param->setInvalidDecl();
       HasInvalidParm = true;
     }
 
     // C99 6.9.1p5: If the declarator includes a parameter type list, the
     // declaration of each parameter shall include an identifier.
-    if (CheckParameterNames &&
-        Param->getIdentifier() == nullptr &&
-        !Param->isImplicit() &&
-        !getLangOpts().CPlusPlus)
-      Diag(Param->getLocation(), diag::err_parameter_name_omitted);
+    if (CheckParameterNames && Param->getIdentifier() == nullptr &&
+        !Param->isImplicit() && !getLangOpts().CPlusPlus) {
+      // Diagnose this as an extension in C17 and earlier.
+      if (!getLangOpts().C2x)
+        Diag(Param->getLocation(), diag::ext_parameter_name_ommitted_c2x);
+    }
 
     // C99 6.7.5.3p12:
     //   If the function declarator is not part of a definition of that
     //   function, parameters may have incomplete type and may use the [*]
     //   notation in their sequences of declarator specifiers to specify
     //   variable length array types.
     QualType PType = Param->getOriginalType();
     // FIXME: This diagnostic should point the '[*]' if source-location

clang/lib/Sema/SemaExpr.cpp

     CurBlock->HasImplicitReturnType = false;
   }
 
   // Push block parameters from the declarator if we had them.
   SmallVector<ParmVarDecl*, 8> Params;
   if (ExplicitSignature) {
     for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) {
       ParmVarDecl *Param = ExplicitSignature.getParam(I);
-      if (Param->getIdentifier() == nullptr &&
-          !Param->isImplicit() &&
-          !Param->isInvalidDecl() &&
-          !getLangOpts().CPlusPlus)
-        Diag(Param->getLocation(), diag::err_parameter_name_omitted);
+      if (Param->getIdentifier() == nullptr && !Param->isImplicit() &&
+          !Param->isInvalidDecl() && !getLangOpts().CPlusPlus) {
+        // Diagnose this as an extension in C17 and earlier.
+        if (!getLangOpts().C2x)
+          Diag(Param->getLocation(), diag::ext_parameter_name_ommitted_c2x);
+      }
       Params.push_back(Param);
     }
 
   // Fake up parameter variables if we have a typedef, like
   //   ^ fntype { ... }
   } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
     for (const auto &I : Fn->param_types()) {
       ParmVarDecl *Param = BuildParmVarDeclForTypedef(

clang/test/Sema/block-args.c

 int main(int argc, char** argv) {
   ^(int argCount) {
     argCount = 3;
   }(argc);
 }
 
 // radar 7528255
 void f0() {
-  ^(int, double d, char) {}(1, 1.34, 'a'); // expected-error {{parameter name omitted}} \
-             // expected-error {{parameter name omitted}}
+  ^(int, double d, char) {}(1, 1.34, 'a'); // expected-warning {{omitting the parameter name in a function definition is a C2x extension}} \
+                                           // expected-warning {{omitting the parameter name in a function definition is a C2x extension}}
 }
 
 // rdar://problem/8962770
 void test4() {
   int (^f)() = ^((x)) { }; // expected-warning {{type specifier missing}} expected-error {{type-id cannot have a name}}
 }
 
 // rdar://problem/9170609

clang/test/Sema/c89.c

 
 /* PR2012 */
 test7;  /* expected-warning {{declaration specifier missing, defaulting to 'int'}} */
 
 void test8(int, x);  /* expected-warning {{declaration specifier missing, defaulting to 'int'}} */
 
 typedef int sometype;
 int a(sometype, y) {return 0;}  /* expected-warning {{declaration specifier missing, defaulting to 'int'}} \
-                                   expected-error {{parameter name omitted}}*/
+                                   expected-warning {{omitting the parameter name in a function definition is a C2x extension}}*/
 
 
 
 
 void bar (void *); 
 void f11 (z)       /* expected-error {{may not have 'void' type}} */
 void z; 
 { bar (&z); }

clang/test/Sema/function.c

-// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic
+// RUN: %clang_cc1 %s -fsyntax-only -verify -verify=c2x -pedantic
+// RUN: %clang_cc1 %s -fsyntax-only -std=c2x -verify -pedantic
 
 // PR1892, PR11354
 void f(double a[restrict][5]) { __typeof(a) x = 10; } // expected-warning {{(aka 'double (*restrict)[5]')}}
 
 int foo (__const char *__path);
 int foo(__const char *__restrict __file);
 
 void func(const char*); // expected-note {{previous declaration is here}}

 int t9(int a, );  // expected-error {{expected parameter declarator}}
 
 
 // PR2042
 void t10(){}
 void t11(){t10(1);} // expected-warning{{too many arguments}}
 
 // PR3208
-void t12(int) {}  // expected-error{{parameter name omitted}}
+void t12(int) {}  // c2x-warning{{omitting the parameter name in a function definition is a C2x extension}}
 
 // PR2790
 void t13() {
   return 0; // expected-error {{void function 't13' should not return a value}}
 }
 int t14() {
   return; // expected-error {{non-void function 't14' should return a value}}
 }

 // rdar://6802350
 inline foo_t invalid_type() {  // expected-error {{unknown type name 'foo_t'}}
 }
 
 typedef void fn_t(void);
 fn_t t17;
 
 // PR4049
-unknown_type t18(void*) {   // expected-error {{unknown type name 'unknown_type'}} expected-error{{parameter name omitted}}
+unknown_type t18(void*) {   // expected-error {{unknown type name 'unknown_type'}} \
+                            // c2x-warning {{omitting the parameter name in a function definition is a C2x extension}}
 }
 
 unknown_type t19(int* P) {   // expected-error {{unknown type name 'unknown_type'}}
   P = P+1;  // no warning.
 }
 
 // missing ',' before '...'
 void t20(int i...) { } // expected-error {{requires a comma}}