[clang][Parse] Diagnose useless null statements (PR39111)

[lebedev.ri]

Summary

clang has -Wextra-semi (D43162), which is not dictated by the currently selected standard.
While that is great, there is at least one more source of need-less semis - 'null statements'.
Sometimes, they are needed:

for(int x = 0; continueToDoWork(x); x++)
  ; // Ugly code, but the semi is needed here.

But sometimes they are just there for no reason:

switch(X) {
case 0:
  return -2345;
case 5:
  return 0;
default:
  return 42;
}; // <- oops

;;;;;;;;;;; <- OOOOPS, still not diagnosed. Clearly this is junk.

As usual, things may or may not go sideways in the presence of macros.
While evaluating this diag on my codebase of interest, it was unsurprisingly
discovered that Google Test macros are *very* prone to this.
And it seems many issues are deep within the GTest itself, not
in the snippets passed from the codebase that uses GTest.

So after some thought, i decided not do issue a diagnostic if the semi
is within *any* macro, be it either from the normal header, or system header.

Fixes PR39111

[efriedma]

Again, I'm not sure we really want this... we don't really like adding new off-by-default warnings, and we don't usually add diagnostics to enforce style.

include/clang/Basic/DiagnosticGroups.td

163

We usually only use "pedantic" in the names of warnings which are enabled by the "-pedantic" flag.

[rsmith]

Like Eli, I don't see much value in this warning. But it doesn't seem much different from -Wextra-semi in that regard for languages in which such extra semicolons are generally valid -- I expect both warnings will generally diagnose typos and little else.

Does this warn on:

switch (my_enum) {
case E1:
  // stuff
  break;
case E2:
  ; // nothing to do, but a label requires a following statement
}

and

for (/*...outer...*/) {
  for (/*...inner...*/) {
    goto contin_outer;
  }
  contin_outer: ;
}

? We shouldn't warn on a semicolon after a label, because a statement is required there, and use of a null statement is idiomatic.

include/clang/Basic/DiagnosticGroups.td

163

Maybe -Wextra-semi-stmt or -Wredundant-null-stmt or similar would be more appropriate?

lib/Parse/ParseStmt.cpp

237

I'm a little concerned that checking whether the scope is a compound statement isn't really checking the right thing -- what you care about is whether the syntactic context is a compound statement, not which scope a declaration at this level would be injected into. (Example of the difference: back in the pre-standard times when { for (int x = 0; x < 10; ++x) //... injected x into the enclosing scope, the first substatement in that for statement would be in a compound-statement scope, but we definitely shouldn't warn on a stray ; there.) If you moved this check into ParseCompoundStatementBody, there'd be no risk of such problems.

test/Parser/extra-semi-resulting-in-nullstmt.cpp

59

It'd seem reasonable to warn on a null-statement as the *init-statement* of an if / switch / range-based for.

[lebedev.ri]

Thank you for taking a look!

• Move it into ParseCompoundStatementBody(), thus fixing false-positives with case X: ; e.g.
• Rename to -Wextra-semi-stmt
• Add -Wempty-init-stmt (tentatively included into -Wextra too), to diagnose empty init-statements of if/switch/range-based for

lib/Parse/ParseStmt.cpp

237

Great idea, thank you!
Testcases added, that fixed them.

test/Parser/extra-semi-resulting-in-nullstmt.cpp

59

If you so insist :)

[rsmith]

include/clang/Basic/DiagnosticGroups.td

164

I think this should either be folded into -Wextra-semi-stmt or should perhaps be a subgroup of it.

166–167

I would prefer to keep -Wextra-semi and -Wextra-semi-stmt separate. -Wextra-semi is for those cases that are ill-formed in C++98, whereas your new warning is only about code style / typo detection.

lib/Parse/ParseStmt.cpp

1597

You can just use a SourceLocation here; it already has an 'invalid' state.

[lebedev.ri]

• Moved -Wempty-init-stmt into -Wextra-semi-stmt
• Moved -Wextra-semi-stmt out of -Wextra-semi
• Tentatively enabled -Wextra-semi-stmt in -Wextra (and removed -Wempty-init-stmt from -Wextra, since it will be transitively enabled by -Wextra-semi-stmt)

include/clang/Basic/DiagnosticGroups.td

166–167

Hmm, does that mean ExtraSemiStmt[+EmptyInitStatement] should be in -Wextra?

lib/Parse/ParseStmt.cpp

1597

Aha.

[lebedev.ri]

Slightly improved test coverage for macros in extra-semi-resulting-in-nullstmt-in-init-statement.cpp

[lebedev.ri]

include/clang/Basic/DiagnosticGroups.td

770

I'm really unsure of this. Maybe this should only be EmptyInitStatement.

[lebedev.ri]

After looking at stage-2 of LLVM, remove -Wextra-semi-stmt from -Wextra, and add -Wempty-init-stmt back into -Wextra.
Anything else?

[rsmith]

I feel indifferent about this warning, but clearly you care about it enough to work on it, and it's a pretty low-cost feature from a maintenance perspective, so I suppose it's fine.

include/clang/Basic/DiagnosticParseKinds.td

56–58

The warning should explain why we're warning: what the problem is, and why it warrants action from the user. I would expect people seeing this warning to think "yes, but so what?". Something like "statement has no effect" might be better, maybe? (A customized warning for ;; might be nice too.)

[lebedev.ri]

Thank you for taking a look!

• Reworded the diag as suggested a little
• Do consume consequtive semis as one
  • Do still record each one of them in AST. I'm not sure if we want to do that, but else existing tests break.

[lebedev.ri]

Ping.

[lebedev.ri]

Ping.

[lebedev.ri]

ping

[lebedev.ri]

Ping.

[lebedev.ri]

ping.
I wonder if @aaron.ballman has any opinion on this.

[lebedev.ri]

Ping. Is even the -Wempty-init-stmt is not interesting?

[aaron.ballman]

Sorry about the delayed review on this -- I had intended to provide comments earlier, but somehow this fell off my radar.

docs/ReleaseNotes.rst

53

, which is, much like -Wextra-semi, diagnoses extra semicolons. -> that diagnoses extra semicolons, much like -Wextra-semi.

55

fires on all -> diagnoses

56

semi -> semicolon

57

nothing; the semi is -> nothing or if the semicolon

I'd make the parenthetical a stand-alone sentence. Something like: "This applies to macros defined in system headers as well as user-defined macros."

65–68

I'd drop this from the example.

91

diagnostic, which is diagnoses empty -> diagnostic that diagnoses empty

92

semi -> semicolon

93–94

nothing; the semi is -> nothing or if the semicolon

I'd make the parenthetical a stand-alone sentence. Something like: "This applies to macros defined in system headers as well as user-defined macros."

95

diagnostic in -> diagnostic is in the

Drop the comma.

include/clang/Basic/DiagnosticParseKinds.td

57–58

How about: empty expression statement has no effect; remove unnecessary ';' to silence this warning ?

556–557

How about: empty initialization statement of '%select{if|switch|range-based for}0' has no effect?

test/Parser/extra-semi-resulting-in-nullstmt.cpp

82

There are four additional tests I'd like to see: 1) a semicolon at global scope, 2) a semicolon after a namespace declaration (e.g., namespace foo {};), 3) a [[fallthrough]]; null statement, 4) a [[]]; null statement.

[lebedev.ri]

Address @aaron.ballman review notes.

test/Parser/extra-semi-resulting-in-nullstmt.cpp

82

None of these warn, added.

[aaron.ballman]

Aside from some small nits, LGTM!

docs/ReleaseNotes.rst

53

diagnostic, that -> diagnostic that

88

expanded nothing -> expanded to nothing

include/clang/Basic/DiagnosticParseKinds.td

57

Spurious whitespace at the start of the diagnostic text.

[lebedev.ri]

In D52695#1304225, @aaron.ballman wrote:

Aside from some small nits, LGTM!

Thank you for the review!
Will address nits and land.

docs/ReleaseNotes.rst

 
 Major New Features
 ------------------
 
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- ``-Wextra-semi-pedantic`` is a new diagnostic, which is, much like
+  ``-Wextra-semi``, diagnoses extra semicolons. This new diagnostic
+  fires on all *unnecessary* null statements (expression statements without
+  an expression), unless: the semi directly follows a macro that was expanded
+  to nothing; the semi is within the macro itself (both macros from system
+  headers, and normal macros).
+
+  .. code-block:: c++
+
+      #define MACRO(x) int x;
+
+      void test() {
+        ; // <- warning: ';' with no preceding expression is a null statement
+
+        while (true)
+          ; // OK, it is needed.
+
+        MACRO(v0;) // Extra semi, but within macro, so ignored.
+
+        MACRO(v1); // <- warning: ';' with no preceding expression is a null statement
+      }
+
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
 - ...
 
 New Compiler Flags
 ------------------
 
 - ...
 
 Deprecated Compiler Flags
 -------------------------
 
 The following options are deprecated and ignored. They will be removed in
 future versions of Clang.
 
 - ...
 
 Modified Compiler Flags
 -----------------------
 
 
 New Pragmas in Clang
 --------------------
 
 Clang now supports the ...
 
 

include/clang/Basic/DiagnosticGroups.td

 def EmptyBody : DiagGroup<"empty-body">;
 def Exceptions : DiagGroup<"exceptions">;
 
 def GNUEmptyInitializer : DiagGroup<"gnu-empty-initializer">;
 def GNUEmptyStruct : DiagGroup<"gnu-empty-struct">;
 def ExtraTokens : DiagGroup<"extra-tokens">;
 def CXX98CompatExtraSemi : DiagGroup<"c++98-compat-extra-semi">;
 def CXX11ExtraSemi : DiagGroup<"c++11-extra-semi">;
+def ExtraSemiPedantic : DiagGroup<"extra-semi-pedantic">;
 def ExtraSemi : DiagGroup<"extra-semi", [CXX98CompatExtraSemi,
-                                         CXX11ExtraSemi]>;
+                                         CXX11ExtraSemi,
+                                         ExtraSemiPedantic]>;
 
 def GNUFlexibleArrayInitializer : DiagGroup<"gnu-flexible-array-initializer">;
 def GNUFlexibleArrayUnionMember : DiagGroup<"gnu-flexible-array-union-member">;
 def GNUFoldingConstant : DiagGroup<"gnu-folding-constant">;
 def FormatExtraArgs : DiagGroup<"format-extra-args">;
 def FormatZeroLength : DiagGroup<"format-zero-length">;
 
 def InvalidIOSDeploymentTarget : DiagGroup<"invalid-ios-deployment-target">;
 
def Extra : DiagGroup<"extra", [
     MissingFieldInitializers,
     IgnoredQualifiers,
     InitializerOverrides,
     SemiBeforeMethodBody,
     MissingMethodReturnType,
     SignCompare,
     UnusedParameter,
     NullPointerArithmetic
   ]>;
 
 def Most : DiagGroup<"most", [
     CharSubscript,
     Comment,
     DeleteNonVirtualDtor,
     ForLoopAnalysis,
     Format,
     Implicit,

include/clang/Basic/DiagnosticParseKinds.td

def ext_extra_semi : Extension<
   "after member function definition}0">,
   InGroup<ExtraSemi>;
 def ext_extra_semi_cxx11 : Extension<
   "extra ';' outside of a function is a C++11 extension">,
   InGroup<CXX11ExtraSemi>;
 def warn_extra_semi_after_mem_fn_def : Warning<
   "extra ';' after member function definition">,
   InGroup<ExtraSemi>, DefaultIgnore;
+def warn_null_statement : Warning<
+  "';' with no preceding expression is a null statement">,
+  InGroup<ExtraSemiPedantic>, DefaultIgnore;
 
 def ext_thread_before : Extension<"'__thread' before '%0'">;
 def ext_keyword_as_ident : ExtWarn<
   "keyword '%0' will be made available as an identifier "
   "%select{here|for the remainder of the translation unit}1">,
   InGroup<KeywordCompat>;
 
 def ext_nullability : Extension<
def warn_cxx14_compat_init_statement : Warning<
   "C++ standards before C++17">, DefaultIgnore, InGroup<CXXPre17Compat>;
 def ext_for_range_init_stmt : ExtWarn<
   "range-based for loop initialization statements are a C++2a extension">,
   InGroup<CXX2a>;
 def warn_cxx17_compat_for_range_init_stmt : Warning<
   "range-based for loop initialization statements are incompatible with "
   "C++ standards before C++2a">, DefaultIgnore, InGroup<CXXPre2aCompat>;
 
 // C++ derived classes
 def err_dup_virtual : Error<"duplicate 'virtual' in base specifier">;
 
 // C++ operator overloading
 def err_literal_operator_string_prefix : Error<
   "string literal after 'operator' cannot have an encoding prefix">;
 def err_literal_operator_string_not_empty : Error<
   "string literal after 'operator' must be '\"\"'">;
 def warn_cxx98_compat_literal_operator : Warning<
   "literal operators are incompatible with C++98">,

lib/Parse/ParseStmt.cpp

case tok::kw_case:                // C99 6.8.1: labeled-statement
     return ParseCaseStatement();
   case tok::kw_default:             // C99 6.8.1: labeled-statement
     return ParseDefaultStatement();
 
   case tok::l_brace:                // C99 6.8.2: compound-statement
     return ParseCompoundStatement();
   case tok::semi: {                 // C99 6.8.3p3: expression[opt] ';'
     bool HasLeadingEmptyMacro = Tok.hasLeadingEmptyMacro();
-    return Actions.ActOnNullStmt(ConsumeToken(), HasLeadingEmptyMacro);
+    SourceLocation SemiLocation = ConsumeToken();
+    if (!HasLeadingEmptyMacro && getCurScope()->isCompoundStmtScope() &&
+        !SemiLocation.isMacroID()) {
+      Diag(SemiLocation, diag::warn_null_statement)
+          << FixItHint::CreateRemoval(SemiLocation);
+    }
+    return Actions.ActOnNullStmt(SemiLocation, HasLeadingEmptyMacro);
   }
 
   case tok::kw_if:                  // C99 6.8.4.1: if-statement
     return ParseIfStatement(TrailingElseLoc);
   case tok::kw_switch:              // C99 6.8.4.2: switch-statement
     return ParseSwitchStatement(TrailingElseLoc);
 
   case tok::kw_while:               // C99 6.8.5.1: while-statement
Actions.CodeCompleteOrdinaryName(getCurScope(),
                                                    : Sema::PCC_Expression);
     cutOffParsing();
     return StmtError();
   }
 
   ParsedAttributesWithRange attrs(AttrFactory);
   MaybeParseCXX11Attributes(attrs);
 
   // Parse the first part of the for specifier.
   if (Tok.is(tok::semi)) {  // for (;
     ProhibitAttributes(attrs);
     // no first part, eat the ';'.
     ConsumeToken();
   } else if (getLangOpts().CPlusPlus && Tok.is(tok::identifier) &&
              isForRangeIdentifier()) {
     ProhibitAttributes(attrs);
     IdentifierInfo *Name = Tok.getIdentifierInfo();

test/Parser/extra-semi-resulting-in-nullstmt.cpp

+// RUN: %clang_cc1 -fsyntax-only -Wextra-semi-pedantic -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wextra-semi-pedantic -std=c++17 -verify %s
+// RUN: cp %s %t
+// RUN: %clang_cc1 -x c++ -Wextra-semi-pedantic -fixit %t
+// RUN: %clang_cc1 -x c++ -Wextra-semi-pedantic -Werror %t
+
+#define GOODMACRO(varname) int varname
+#define BETTERMACRO(varname) GOODMACRO(varname);
+#define NULLMACRO(varname)
+
+void test() {
+  ; // expected-warning {{';' with no preceding expression is a null statement}}
+  ; // expected-warning {{';' with no preceding expression is a null statement}}
+
+  // clang-format: off
+  ;; // expected-warning 2 {{';' with no preceding expression is a null statement}}
+  // clang-format: on
+
+  {}; // expected-warning {{';' with no preceding expression is a null statement}}
+
+  {
+    ; // expected-warning {{';' with no preceding expression is a null statement}}
+  }
+
+  if (true) {
+    ; // expected-warning {{';' with no preceding expression is a null statement}}
+  }
+
+  GOODMACRO(v0); // OK
+
+  GOODMACRO(v1;) // OK
+
+  BETTERMACRO(v2) // OK
+
+  BETTERMACRO(v3;) // Extra ';', but within macro expansion, so ignored.
+
+  BETTERMACRO(v4); // expected-warning {{';' with no preceding expression is a null statement}}
+
+  BETTERMACRO(v5;); // expected-warning {{';' with no preceding expression is a null statement}}
+
+  NULLMACRO(v6) // OK
+
+  NULLMACRO(v7); // OK. This could be either GOODMACRO() or BETTERMACRO() situation, so we can't know we can drop it.
+
+  if (true)
+    ; // OK
+
+  while (true)
+    ; // OK
+
+  do
+    ; // OK
+  while (true);
+
+  for (;;) // OK
+    ;      // OK
+
+#if __cplusplus >= 201703L
+  if (; true) // OK
+    ;         // OK
+#endif
+}