Add a FixItHint for -Wmissing-prototypes to insert 'static '.

[alexfh]

Summary

Missing 'static' on functions that are intended to be local to a translation
unit seems to be the most common cause of -Wmissing-prototypes warnings, so
suggesting a fix seems to be convenient and useful.

[djasper]

lib/Sema/SemaDecl.cpp

11652

Fix the format while here?

11653

Maybe s/Possible/Possibly/ ?

11708

Does this exclude templated functions? If not, the "static" might be put into the wrong place.

12114

I wonder whether it is useful to display the changed message here. In the cases I have seen where the function definition is coming from a macro, you'd actually need to surround it with an unnamed namespace to fix. Maybe just add this logic to the outer if statement?

include/clang/Basic/DiagnosticGroups.td

 def CXX11LongLong : DiagGroup<"c++11-long-long">;
 def LongLong : DiagGroup<"long-long", [CXX11LongLong]>;
 def ImplicitlyUnsignedLiteral : DiagGroup<"implicitly-unsigned-literal">;
 def MethodSignatures : DiagGroup<"method-signatures">;
 def MismatchedParameterTypes : DiagGroup<"mismatched-parameter-types">;
 def MismatchedReturnTypes : DiagGroup<"mismatched-return-types">;
 def MismatchedTags : DiagGroup<"mismatched-tags">;
 def MissingFieldInitializers : DiagGroup<"missing-field-initializers">;
+def MissingPrototypes : DiagGroup<"missing-prototypes">;
 def ModuleBuild : DiagGroup<"module-build">;
 def ModuleConflict : DiagGroup<"module-conflict">;
 def ModuleFileExtension : DiagGroup<"module-file-extension">;
 def NewlineEOF : DiagGroup<"newline-eof">;
 def Nullability : DiagGroup<"nullability">;
 def NullabilityDeclSpec : DiagGroup<"nullability-declspec">;
 def NullabilityInferredOnNestedType : DiagGroup<"nullability-inferred-on-nested-type">;
 def NullableToNonNullConversion : DiagGroup<"nullable-to-nonnull-conversion">;

include/clang/Basic/DiagnosticSemaKinds.td

def warn_not_enough_argument : Warning<
   InGroup<Sentinel>;
 def warn_missing_sentinel : Warning <
   "missing sentinel in %select{function call|method dispatch|block call}0">,
   InGroup<Sentinel>;
 def note_sentinel_here : Note<
   "%select{function|method|block}0 has been explicitly marked sentinel here">;
 def warn_missing_prototype : Warning<
   "no previous prototype for function %0">,
-  InGroup<DiagGroup<"missing-prototypes">>, DefaultIgnore;
+  InGroup<MissingPrototypes>, DefaultIgnore;
+def warn_missing_prototype_maybe_static : Warning<
+  "no previous prototype for function %0; did you mean to mark the function 'static'?">,
+  InGroup<MissingPrototypes>, DefaultIgnore;
 def note_declaration_not_a_prototype : Note<
-  "this declaration is not a prototype; add 'void' to make it a prototype for a zero-parameter function">; 
+  "this declaration is not a prototype; add 'void' to make it a prototype for a zero-parameter function">;
 def warn_strict_prototypes : Warning<
   "this %select{function declaration is not|"
   "old-style function definition is not preceded by}0 a prototype">,
   InGroup<DiagGroup<"strict-prototypes">>, DefaultIgnore;
 def warn_missing_variable_declarations : Warning<
   "no previous extern declaration for non-static variable %0">,
   InGroup<DiagGroup<"missing-variable-declarations">>, DefaultIgnore;
 def err_static_data_member_reinitialization :

lib/Sema/SemaDecl.cpp

Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D,
   return ActOnStartOfFunctionDef(FnBodyScope, DP, SkipBody);
 }
 
 void Sema::ActOnFinishInlineFunctionDef(FunctionDecl *D) {
   Consumer.HandleInlineFunctionDefinition(D);
 }
 
 static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
-                             const FunctionDecl*& PossibleZeroParamPrototype) {
+                             const FunctionDecl*& PossibleZeroParamPrototype,
+                             bool *PossibleMissingStatic) {
   // Don't warn about invalid declarations.
   if (FD->isInvalidDecl())
     return false;
 
   // Or declarations that aren't global.
   if (!FD->isGlobal())
     return false;
 
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
   // Don't warn for OpenCL kernels.
   if (FD->hasAttr<OpenCLKernelAttr>())
     return false;
 
   // Don't warn on explicitly deleted functions.
   if (FD->isDeleted())
     return false;
 
-  bool MissingPrototype = true;
   for (const FunctionDecl *Prev = FD->getPreviousDecl();
        Prev; Prev = Prev->getPreviousDecl()) {
     // Ignore any declarations that occur in function or method
     // scope, because they aren't visible from the header.
     if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
       continue;
 
-    MissingPrototype = !Prev->getType()->isFunctionProtoType();
+    if (Prev->getType()->isFunctionProtoType())
+      return false;
+
     if (FD->getNumParams() == 0)
       PossibleZeroParamPrototype = Prev;
     break;
   }
 
-  return MissingPrototype;
+  // Check whether applying a 'static' could make sense for this function.
+  *PossibleMissingStatic = FD->getDeclContext() &&
+                           FD->getDeclContext()->isTranslationUnit() &&
+                           FD->getStorageClass() == SC_None;
+
+  return true;
 }
 
 void
 Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
                                    const FunctionDecl *EffectiveDefinition,
                                    SkipBodyInfo *SkipBody) {
   const FunctionDecl *Definition = EffectiveDefinition;
   if (!Definition)
if (FD) {
     }
 
     // GNU warning -Wmissing-prototypes:
     //   Warn if a global function is defined without a previous
     //   prototype declaration. This warning is issued even if the
     //   definition itself provides a prototype. The aim is to detect
     //   global functions that fail to be declared in header files.
     const FunctionDecl *PossibleZeroParamPrototype = nullptr;
-    if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
+    bool PossibleMissingStatic = false;
+    if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype,
+                                        &PossibleMissingStatic)) {
+      if (PossibleMissingStatic) {
+        auto DiagBuilder =
+            Diag(FD->getLocation(), diag::warn_missing_prototype_maybe_static)
+            << FD;
+        SourceLocation Loc = FD->getLocStart();
+        if (Loc.isFileID())
+          DiagBuilder << FixItHint::CreateInsertion(Loc, "static ");
+      } else {
         Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
+      }
 
       if (PossibleZeroParamPrototype) {
         // We found a declaration that is not a prototype,
         // but that could be a zero-parameter prototype
         if (TypeSourceInfo *TI =
                 PossibleZeroParamPrototype->getTypeSourceInfo()) {
           TypeLoc TL = TI->getTypeLoc();
           if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>())

test/SemaCXX/warn-missing-prototypes.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wmissing-prototypes -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -Wmissing-prototypes -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -implicit-check-not=fix-it:
 
-void f() { } // expected-warning {{no previous prototype for function 'f'}}
+void f() { } // expected-warning {{no previous prototype for function 'f'; did you mean to mark the function 'static'?}}
+// CHECK: fix-it:"{{.*}}":{4:1-4:1}:"static "
+
+#define F2 void f2() { }
+
+F2 // expected-warning {{no previous prototype for function 'f2'}}
+
+extern void f3() {} // expected-warning {{no previous prototype for function 'f3'}}
+extern "C" void f4() {} // expected-warning {{no previous prototype for function 'f4'}}
+extern "C++" void f5() {} // expected-warning {{no previous prototype for function 'f5'}}
+extern "C" {
+  void f6() {} // expected-warning {{no previous prototype for function 'f6'}}
+}
+extern "C++" {
+  void f7() {} // expected-warning {{no previous prototype for function 'f7'}}
+}
 
 namespace NS {
   void f() { } // expected-warning {{no previous prototype for function 'f'}}
 }
 
 namespace {
   // Don't warn about functions in anonymous namespaces.
   void f() { }
 }
 
 struct A {
   // Don't warn about member functions.
   void f() { }
 };
 
+
 // Don't warn about inline functions.
 inline void g() { }
 
 // Don't warn about function templates.
 template<typename> void h() { }
 
 // Don't warn when instantiating function templates.
 template void h<int>();
 
 // PR9519: don't warn about friend functions.
 class I {
   friend void I_friend() {}
 };
 
 // Don't warn on explicitly deleted functions.
 void j() = delete;
+
+// Don't warn on static functions.
+static void s() {}