clang-tidy: Apply fixes "modernize-redundant-void-arg"

[mspang]

Problem

Declaring functions (void) is obsolete in C++.

Summary of Changes

Change (void) to () in c++ code.

[andy31415]

+1 to this. Note that I remember some style guide proposals (unsure if they got in or not .. I cannot find them now, so assuming maybe abandoned) which was explicitly asking for this with the reasoning 'being able to differentiate declaration from call'.

[rwalker-apple]

@hawk248 @saurabhst @jelderton @BroderickCarlin ?

[BroderickCarlin]

@mspang can you fix the merge conflicts? Should be good to go after that!

[gerickson]

Personally, I object to this change:

The void type is an intrinsic type just as is char, short, and long. If you declared a function with a single char parameter, you would declare it as:

int foo(char);

and invoke it as:

foo(‘c’);

similarly, when declaring a void parameter, the type should be declared explicitly:

int bar(void);

where it would be invoked as:

bar();

This style makes it easy to visually identify and differentiate, at a glance, a declaration from an invocation, particularly when you have a lot of inline implementation co-mingled with declarations.

[mspang]

Personally, I object to this change:

The void type is an intrinsic type just as is char, short, and long. If you declared a function with a single char parameter, you would declare it as:

int foo(char);

and invoke it as:

foo(‘c’);

similarly, when declaring a void parameter, the type should be declared explicitly:

int bar(void);

where it would be invoked as:

bar();

This style makes it easy to visually identify and differentiate, at a glance, a declaration from an invocation, particularly when you have a lot of inline implementation co-mingled with declarations.

I believe this syntax is considered obsolete. I did some quick digging and it seems Stroustrup abandoned this syntax intentionally when designing C++.

On a more practical note, if we wanted to use (void), it would be good to do so consistently, but I unfortunately don't think there's a tool to convert the other way.

I don't find the readability argument very convincing; arguments for brevity and consistency seem more salient to me.

[mspang]

Personally, I object to this change:
The void type is an intrinsic type just as is char, short, and long. If you declared a function with a single char parameter, you would declare it as:

int foo(char);

and invoke it as:

foo(‘c’);

similarly, when declaring a void parameter, the type should be declared explicitly:

int bar(void);

where it would be invoked as:

bar();

This style makes it easy to visually identify and differentiate, at a glance, a declaration from an invocation, particularly when you have a lot of inline implementation co-mingled with declarations.

I believe this syntax is considered obsolete. I did some quick digging and it seems Stroustrup abandoned this syntax intentionally when designing C++.

On a more practical note, if we wanted to use (void), it would be good to do so consistently, but I unfortunately don't think there's a tool to convert the other way.

I don't find the readability argument very convincing; arguments for brevity and consistency seem more salient to me.

Some languages spell their unit type and instance as () (although void is not really a unit type, it has no value).

Personally, I object to this change:
The void type is an intrinsic type just as is char, short, and long. If you declared a function with a single char parameter, you would declare it as:

int foo(char);

and invoke it as:

foo(‘c’);

similarly, when declaring a void parameter, the type should be declared explicitly:

int bar(void);

where it would be invoked as:

bar();

This style makes it easy to visually identify and differentiate, at a glance, a declaration from an invocation, particularly when you have a lot of inline implementation co-mingled with declarations.

I believe this syntax is considered obsolete. I did some quick digging and it seems Stroustrup abandoned this syntax intentionally when designing C++.

Here's the cite: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.111.7973&rep=rep1&type=pdf

On a more practical note, if we wanted to use (void), it would be good to do so consistently, but I unfortunately don't think there's a tool to convert the other way.

I don't find the readability argument very convincing; arguments for brevity and consistency seem more salient to me.

[mspang]

Personally, I object to this change:

The void type is an intrinsic type just as is char, short, and long. If you declared a function with a single char parameter, you would declare it as:

int foo(char);

and invoke it as:

foo(‘c’);

similarly, when declaring a void parameter, the type should be declared explicitly:

int bar(void);

where it would be invoked as:

bar();

This style makes it easy to visually identify and differentiate, at a glance, a declaration from an invocation, particularly when you have a lot of inline implementation co-mingled with declarations.

Personally, I object to this change:
The void type is an intrinsic type just as is char, short, and long. If you declared a function with a single char parameter, you would declare it as:

int foo(char);

and invoke it as:

foo(‘c’);

similarly, when declaring a void parameter, the type should be declared explicitly:

int bar(void);

where it would be invoked as:

bar();

This style makes it easy to visually identify and differentiate, at a glance, a declaration from an invocation, particularly when you have a lot of inline implementation co-mingled with declarations.

I believe this syntax is considered obsolete. I did some quick digging and it seems Stroustrup abandoned this syntax intentionally when designing C++.
On a more practical note, if we wanted to use (void), it would be good to do so consistently, but I unfortunately don't think there's a tool to convert the other way.
I don't find the readability argument very convincing; arguments for brevity and consistency seem more salient to me.

Some languages spell their unit type and instance as () (although void is not really a unit type, it has no value).

Personally, I object to this change:
The void type is an intrinsic type just as is char, short, and long. If you declared a function with a single char parameter, you would declare it as:

int foo(char);

and invoke it as:

foo(‘c’);

similarly, when declaring a void parameter, the type should be declared explicitly:

int bar(void);

where it would be invoked as:

bar();

This style makes it easy to visually identify and differentiate, at a glance, a declaration from an invocation, particularly when you have a lot of inline implementation co-mingled with declarations.

I believe this syntax is considered obsolete. I did some quick digging and it seems Stroustrup abandoned this syntax intentionally when designing C++.

Here's the cite: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.111.7973&rep=rep1&type=pdf

On a more practical note, if we wanted to use (void), it would be good to do so consistently, but I unfortunately don't think there's a tool to convert the other way.
I don't find the readability argument very convincing; arguments for brevity and consistency seem more salient to me.

FWIW, I don't really care strongly about this. The only reason I made this PR is because I was going down the list of clang-tidy's modernize transformers.

[rwalker-apple]

@mspang conflicts?

[yufengwangca]

C and C++ are different in this respect.

C++:
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4296.pdf
"8.3.5 Functions [dcl.fct]
...
4 The parameter-declaration-clause determines the arguments that can be specified, and their processing, when the function is called. [ Note: the parameter-declaration-clause is used to convert the arguments specified on the function call; see 5.2.2. — end note ] If the parameter-declaration-clause is empty, the function takes no arguments. A parameter list consisting of a single unnamed parameter of non-dependent type void is equivalent to an empty parameter list. "

In the case of C++, an empty parameter list in either a declaration or a definition indicates that the function takes no arguments, and is equivalent to using a parameter list of void.

C:
http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
"6.7.6.3 Function declarators (including prototypes)
...
10 The special case of an unnamed parameter of type void as the only item in the list specifies that the function has no parameters.
...
14 An identifier list declares only the identifiers of the parameters of the function. An empty list in a function declarator that is part of a definition of that function specifies that the function has no parameters. The empty list in a function declarator that is not part of a definition of that function specifies that no information about the number or types of the parameters is supplied.145)"

In the case of C, an empty parameter list in a function declaration indicates that the function takes an unspecified number of parameters, while an empty parameter list in a function definition indicates that the function takes no parameters.

So in C, you should never use an empty identifier list in a function declaration or definition. If a function is not meant to take any parameters, specify that by using void in the parameter list.

In summary, if we want CHIP code base comply with C standard, we should keep void in the parameter list, if we only want CHIP code comply with C++ standard, then we can keep or remove void in the parameter list.

[mspang]

C and C++ are different in this respect.

Yep.

C++:
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4296.pdf
"8.3.5 Functions [dcl.fct]
...
4 The parameter-declaration-clause determines the arguments that can be specified, and their processing, when the function is called. [ Note: the parameter-declaration-clause is used to convert the arguments specified on the function call; see 5.2.2. — end note ] If the parameter-declaration-clause is empty, the function takes no arguments. A parameter list consisting of a single unnamed parameter of non-dependent type void is equivalent to an empty parameter list. "

In the case of C++, an empty parameter list in either a declaration or a definition indicates that the function takes no arguments, and is equivalent to using a parameter list of void.

C:
http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
"6.7.6.3 Function declarators (including prototypes)
...
10 The special case of an unnamed parameter of type void as the only item in the list specifies that the function has no parameters.
...
14 An identifier list declares only the identifiers of the parameters of the function. An empty list in a function declarator that is part of a definition of that function specifies that the function has no parameters. The empty list in a function declarator that is not part of a definition of that function specifies that no information about the number or types of the parameters is supplied.145)"

In the case of C, an empty parameter list in a function declaration indicates that the function takes an unspecified number of parameters, while an empty parameter list in a function definition indicates that the function takes no parameters.

So in C, you should never use an empty identifier list in a function declaration or definition. If a function is not meant to take any parameters, specify that by using void in the parameter list.

In summary, if we want CHIP code base comply with C standard, we should keep void in the parameter list, if we only want CHIP code comply with C++ standard, then we can keep or remove void in the parameter list.

I think the boat has sailed on using C++...