[clang-tidy] introduce modernize-deprecated-headers check

[omtcyf0]

Summary

This patch introduces the modernize-deprecated-headers check, which is supposed to replace deprecated C library headers with the C++ STL-ones.

For information see documentation; for exmaples see the test cases.

[omtcyf0]

fixed clang-tidy/modernize/DeprecatedHeaders.h head typo caused by the check rename

[Eugene.Zelenko]

Thank you for implementing this check!

However, I think will be good idea to always wrap header name in <> for warning and FixIt.

[omtcyf0]

Thanks for a review, Eugene!

The FixItHint and warning now comes with the "angled" version of header wrapping.

[LegalizeAdulthood]

Other than a few nits, LGTM.

clang-tidy/modernize/DeprecatedHeadersCheck.cpp

54

Can't we use C++11 brace initialization here instead of repeated assignments?

docs/clang-tidy/checks/modernize-deprecated-headers.rst

33

Can we sort these lists of includes? Otherwise it's hard to find a specific include in the list.

test/clang-tidy/modernize-deprecated-headers-cxx11.cpp

3

Can we sort the includes in the test files too please?

[Eugene.Zelenko]

Another idea: to replace limits.h with limits and also replace its defines with their C++ counterparts. For example, INT_MIN with numeric_limits<int>::min().

Will be definitely useful for LLDB code modernization.

[omtcyf0]

Thanks for a review, Richard!
Fixed all the issues you pointed to!

Thanks for the hint, Eugene!
I'll try to add this functionality to this check later on.

[alexfh]

Thank you for this check! Mostly looks good, but there are a number of style nits.

The most important question to this check is that the standard doesn't guarantee that the C++ headers declare all the same functions in the global namespace (at least, this is how I understand the section of the standard you quoted). This means that the check in its current form can break the code that uses library symbols from the global namespace. The check could add std:: wherever it's needed (though it may be not completely trivial) to mitigate the risk. It's not what needs to be addressed in the first iteration, but it's definitely worth a look at in order to make the check actually useful. It also could be a separate check or a separate mode (configurable via parameters) of this check, while someone could have reasons to do the migration in two stages (add std:: qualifiers and then switch to new headers).

clang-tidy/modernize/DeprecatedHeadersCheck.cpp

16

Is this header used?

37

There's a more effective container in LLVM: llvm::StringMap<std::string>. If your code guarantees that only string literals be used to initialize this map, this can be a llvm::StringMap<StringRef>.

55

It should be possible to initialize this in the constructor initializer list.

78

nit: Please add a trailing period.

95

1. s/std::string(FileName)/FileName.str()/
2. no need for this, if llvm::StringMap is used

97

FileName.str()

docs/clang-tidy/checks/modernize-deprecated-headers.rst

9

This quote from the standard is too long for my taste. A simple reference to the relevant section should be enough ([depr.c.headers]).

test/clang-tidy/modernize-deprecated-headers-cxx03.cpp

2

You seem to have forgotten to add these headers to Inputs/Headers. Or doesn't the check care about them actually being present?

26

Trailing period.

33

Please also check diagnostic messages (// CHECK-MESSAGES: ...).

[alexfh]

In D17484#358617, @alexfh wrote:

... the check in its current form can break the code that uses library symbols from the global namespace. ...

An action item for this is: document this possible issue and add a FIXME somewhere in the code to add std:: qualifiers.

[LegalizeAdulthood]

In D17484#358617, @alexfh wrote:

Thank you for this check! Mostly looks good, but there are a number of style nits.

The most important question to this check is that the standard doesn't guarantee that the C++ headers declare all the same functions in the global namespace (at least, this is how I understand the section of the standard you quoted).

Oh crap, I totally forgot about this. Yes, I believe the weasel wording in the standard is that an implementation may put the symbols in the global namespace as well as inside std when the C++ header is used, but is not required to put them in the global namespace. They are required to put them in namespace std when the C++ header form is used.

So if you switch to C++ headers, you code may still compile, but it is implementation dependent.

If you use the C headers, you can't prefix symbols with std because they won't be there.

In other discussions of this topic, it was considered best to make both changes at the same time: switch to the C++ header and decorate the symbols with std prefix.

It would be reasonable for this check to insert a using namespace std; at the top of the translation unit after all the #include lines as a means of preserving meaning without trying to identify every symbol that needs std on it.

[omtcyf0]

Thank you for a review, Alex!

I'll clean up the parts you mentioned soon!

In D17484#358617, @alexfh wrote:

The most important question to this check is that the standard doesn't guarantee that the C++ headers declare all the same functions in the global namespace (at least, this is how I understand the section of the standard you quoted). This means that the check in its current form can break the code that uses library symbols from the global namespace. The check could add std:: wherever it's needed (though it may be not completely trivial) to mitigate the risk. It's not what needs to be addressed in the first iteration, but it's definitely worth a look at in order to make the check actually useful. It also could be a separate check or a separate mode (configurable via parameters) of this check, while someone could have reasons to do the migration in two stages (add std:: qualifiers and then switch to new headers).

Yes, you are correct: the check might cause some troubles in codebases, because it is not guaranteed that the functions from the C library headers will occur in the global namespace.

I was initially aware of that, but I thought it'd be better to add the initial check first and enhance it later. Appropriate FIXME seems great.

In D17484#358757, @LegalizeAdulthood wrote:

It would be reasonable for this check to insert a using namespace std; at the top of the translation unit after all the #include lines as a means of preserving meaning without trying to identify every symbol that needs std on it.

I'm not sure that's a good option. I would certainly argue about putting using namespaces like std anywhere during the vanilla check run. Simply because of the collisions caused by some libraries with the functions having analogies in STL.

However, I can see it as an option for the further variations of this check.

Say, let it have three options:

• Don't bother about namespaces: in case user already has using namespace std or doesn't care about implementation-dependend things. Seems like a reasonable scenario to me.
• Add std:: prefix to all functions from these headers in the process of migration: generally it seems a bit better to me.
• Put using namespace std; somewhere (maybe even specify where: i.e. if user wants to put it right to the top of TU or in each source file where a C library is used. That's considerably good, too.

just note for the future
I also think there might be a good place in clang-tidy for an independent check responsible for namespace migrations. Say, user has been using only one library and now when he wants to add another one it would be good to put the appropriate namespace prefixes where appropriate.

Seems quite sophisticated ATM though.

[omtcyf0]

Fixed all the issues @alexfh pointed to.

[omtcyf0]

Marked the comments as *done*.

test/clang-tidy/modernize-deprecated-headers-cxx03.cpp

2

Correct. It doesn't care about them being present.

[alexfh]

clang-tidy/modernize/DeprecatedHeadersCheck.cpp

79

This can be done without STL algorithms and lambdas:

for (const auto &Pair : {{"fenv.h", "cfenv"}, ...})
  CStyledHeaderToCxx.insert(Pair);

(didn't actually try this, so it might need some massaging, e.g. std::pair<....> instead of auto).

105

A usual way to concatenate strings in LLVM is to use llvm::Twine:

std::string Replacement = (llvm::Twine("<") + ... + ...).str();

106

The message should name the header it complains about and suggest the replacement (in words, not only by attaching a fix. Something along the lines of:

"inclusion of  a deprecated C++ header '%0'; consider including '%1' instead"

test/clang-tidy/modernize-deprecated-headers-cxx03.cpp

33

We usually specify each unique diagnostic message completely in one CHECK line and truncate repeated parts (e.g. the check name in brackets) in all other CHECK lines to make tests easier to read.

[omtcyf0]

Resolved issues @alexfh pointed to.

[omtcyf0]

changed the warning comment to be more precise; fixed line with > 80 symbols

[alexfh]

Looks good with one nit.

Let me know if you need me to commit the patch for you.

clang-tidy/modernize/DeprecatedHeadersCheck.cpp

100

No need to convert all of them to llvm::Twine. The first one is enough to make the compiler choose the right overloaded operators:

(llvm::Twine("<") + CStyledHeaderToCxx[FileName] + ">").str();

[omtcyf0]

replaced few explicit casts to llvm::Twine with implicit ones

[omtcyf0]

In D17484#359634, @alexfh wrote:

Looks good with one nit.

Let me know if you need me to commit the patch for you.

Yes, commit please!

clang-tidy/modernize/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyModernizeModule
+  DeprecatedHeadersCheck.cpp
   LoopConvertCheck.cpp
   LoopConvertUtils.cpp
   MakeUniqueCheck.cpp
   ModernizeTidyModule.cpp
   PassByValueCheck.cpp
   RedundantVoidArgCheck.cpp
   ReplaceAutoPtrCheck.cpp
   ShrinkToFitCheck.cpp

clang-tidy/modernize/DeprecatedHeadersCheck.h

+//===--- DeprecatedHeadersCheck.h - clang-tidy-------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_C_HEADERS_TO_CXX_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_C_HEADERS_TO_CXX_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+/// This check replaces deprecated C library headers with their C++ STL
+/// alternatives.
+///
+/// Before:
+///   #include <header.h>
+/// After:
+///   #include <cheader>
+///
+/// Example: <stdio.h> => <cstdio>
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/modernize-deprecated-headers.html
+class DeprecatedHeadersCheck : public ClangTidyCheck {
+public:
+  DeprecatedHeadersCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerPPCallbacks(CompilerInstance &Compiler) override;
+};
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_C_HEADERS_TO_CXX_H

clang-tidy/modernize/DeprecatedHeadersCheck.cpp

+//===--- DeprecatedHeadersCheck.cpp - clang-tidy---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DeprecatedHeadersCheck.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
+
+#include <iostream>
+#include <vector>
+#include <map>
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+namespace {
+class IncludeModernizePPCallbacks : public PPCallbacks {
+public:
+  explicit IncludeModernizePPCallbacks(ClangTidyCheck &Check,
+                                       LangOptions LangOpts);
+
+  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
+                          StringRef FileName, bool IsAngled,
+                          CharSourceRange FilenameRange, const FileEntry *File,
+                          StringRef SearchPath, StringRef RelativePath,
+                          const Module *Imported) override;
+
+private:
+  std::map<std::string, std::string> CStyledHeaderToCxx;
+
+  ClangTidyCheck &Check;
+  LangOptions LangOpts;
+};
+} // namespace
+
+void DeprecatedHeadersCheck::registerPPCallbacks(CompilerInstance &Compiler) {
+  if (this->getLangOpts().CPlusPlus) {
+    Compiler.getPreprocessor().addPPCallbacks(
+        ::llvm::make_unique<IncludeModernizePPCallbacks>(*this,
+                                                         this->getLangOpts()));
+  }
+}
+
+IncludeModernizePPCallbacks::IncludeModernizePPCallbacks(ClangTidyCheck &Check,
+                                                         LangOptions LangOpts)
+    : Check(Check), LangOpts(LangOpts) {
+  CStyledHeaderToCxx["assert.h"] = "cassert";
+  CStyledHeaderToCxx["float.h"] = "cfloat";
+  CStyledHeaderToCxx["math.h"] = "cmath";
+  CStyledHeaderToCxx["stddef.h"] = "cstddef";
+  CStyledHeaderToCxx["setjmp.h"] = "csetjmp";
+  CStyledHeaderToCxx["stdio.h"] = "cstdio";
+  CStyledHeaderToCxx["time.h"] = "ctime";
+  CStyledHeaderToCxx["ctype.h"] = "cctype";
+  CStyledHeaderToCxx["iso646.h"] = "ciso646";
+  CStyledHeaderToCxx["signal.h"] = "csignal";
+  CStyledHeaderToCxx["errno.h"] = "cerrno";
+  CStyledHeaderToCxx["limits.h"] = "climits";
+  CStyledHeaderToCxx["stdarg.h"] = "cstdarg";
+  CStyledHeaderToCxx["stdlib.h"] = "cstdlib";
+  CStyledHeaderToCxx["wchar.h"] = "cwchar";
+  CStyledHeaderToCxx["locale.h"] = "clocale";
+  CStyledHeaderToCxx["string.h"] = "cstring";
+  CStyledHeaderToCxx["wctype.h"] = "cwctype";
+  CStyledHeaderToCxx["complex.h"] = "ccomplex";
+  CStyledHeaderToCxx["stdint.h"] = "cstdint";
+  CStyledHeaderToCxx["inttypes.h"] = "cinttypes";
+
+  // C++ 11 headers
+  if (LangOpts.CPlusPlus11) {
+    CStyledHeaderToCxx["stdbool.h"] = "cstdbool";
+    CStyledHeaderToCxx["fenv.h"] = "cfenv";
+    CStyledHeaderToCxx["tgmath.h"] = "ctgmath";
+    CStyledHeaderToCxx["uchar.h"] = "cuchar";
+    CStyledHeaderToCxx["stdalign.h"] = "cstdalign";
+  }
+}
+
+void IncludeModernizePPCallbacks::InclusionDirective(
+    SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
+    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    StringRef SearchPath, StringRef RelativePath, const Module *Imported) {
+  if (CStyledHeaderToCxx.count(std::string(FileName)) != 0) {
+    std::string Replacement =
+        "<" + CStyledHeaderToCxx[std::string(FileName)] + ">";
+    Check.diag(FilenameRange.getBegin(), "including deprecated C++ header")
+        << FixItHint::CreateReplacement(FilenameRange.getAsRange(),
+                                        Replacement);
+  }
+}
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang

clang-tidy/modernize/ModernizeTidyModule.cpp

 //===--- ModernizeTidyModule.cpp - clang-tidy -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "DeprecatedHeadersCheck.h"
 #include "LoopConvertCheck.h"
 #include "MakeUniqueCheck.h"
 #include "PassByValueCheck.h"
 #include "RedundantVoidArgCheck.h"
 #include "ReplaceAutoPtrCheck.h"
 #include "ShrinkToFitCheck.h"
 #include "UseAutoCheck.h"
 #include "UseDefaultCheck.h"
 #include "UseNullptrCheck.h"
 #include "UseOverrideCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class ModernizeModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<DeprecatedHeadersCheck>(
+        "modernize-deprecated-headers");
     CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
     CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");
     CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
     CheckFactories.registerCheck<RedundantVoidArgCheck>(
         "modernize-redundant-void-arg");
     CheckFactories.registerCheck<ReplaceAutoPtrCheck>(
         "modernize-replace-auto-ptr");
     CheckFactories.registerCheck<ShrinkToFitCheck>("modernize-shrink-to-fit");

docs/clang-tidy/checks/list.rst

.. toctree::
    misc-swapped-arguments
    misc-throw-by-value-catch-by-reference
    misc-undelegated-constructor
    misc-uniqueptr-reset-release
    misc-unused-alias-decls
    misc-unused-parameters
    misc-unused-raii
    misc-virtual-near-miss
+   modernize-deprecated-headers
    modernize-loop-convert
    modernize-make-unique
    modernize-pass-by-value
    modernize-redundant-void-arg
    modernize-replace-auto-ptr
    modernize-shrink-to-fit
    modernize-use-auto
    modernize-use-default

docs/clang-tidy/checks/modernize-deprecated-headers.rst

+.. title:: clang-tidy - modernize-deprecated-headers
+
+modernize-deprecated-headers
+==========================
+
+This check replaces C standard library headers with their C++ alternatives.
+
+  Annex D (normative)
+  Compatibility features [depr]
+
+  D.5 C standard library headers [depr.c.headers]
+  1 For compatibility with the C standard library and the C Unicode TR, the C++
+  standard library provides the 26 C headers, as shown in Table 155
+
+  ...
+
+  Every C header, each of which has a name of the form name.h, behaves as if
+  each name placed in the standard library namespace by the corresponding cname
+  header is placed within the global namespace scope. It is unspecified whether
+  these names are first declared or defined within namespace scope (3.3.6) of
+  the namespace std and are then injected into the global namespace scope by
+  explicit using-declarations (7.3.3).
+
+  [ Example: The header <cstdlib> assuredly provides its declarations and
+  definitions within the namespace std. It may also provide these names within
+  the global namespace. The header <stdlib.h> assuredly provides the same
+  declarations and definitions within the global namespace, much as in the C
+  Standard. It may also provide these names within the namespace std.
+  —end example ]
+
+  -- C++ 14 Standard
+
+The following headers were deprecated before C++ 11:
+
+* `<assert.h>`
+* `<inttypes.h>`
+* `<signal.h>`
+* `<stdio.h>`
+* `<wchar.h>`
+* `<complex.h>`
+* `<iso646.h>`
+* `<stdlib.h>`
+* `<wctype.h>`
+* `<ctype.h>`
+* `<limits.h>`
+* `<stdarg.h>`
+* `<string.h>`
+* `<errno.h>`
+* `<locale.h>`
+* `<math.h>`
+* `<stddef.h>`
+* `<time.h>`
+* `<float.h>`
+* `<setjmp.h>`
+* `<stdint.h>`
+
+The following headers were deprecated in C++ 11:
+
+* `<stdbool.h>`
+* `<tgmath.h>`
+* `<fenv.h>`
+* `<uchar.h>`
+* `<stdalign.h>`
+
+If the specified standard is older than C++11 the check will only replace
+headers from the first list, otherwise -- every header that appeared before.

test/clang-tidy/modernize-deprecated-headers-cxx03.cpp

+// RUN: %check_clang_tidy %s modernize-deprecated-headers %t -- -- -std=c++03 -isystem %S/Inputs/Headers
+
+#include "assert.h"
+#include "float.h"
+#include "math.h"
+#include "stddef.h"
+#include "setjmp.h"
+#include "stdio.h"
+#include "time.h"
+#include "ctype.h"
+#include "iso646.h"
+#include "signal.h"
+#include "errno.h"
+#include "limits.h"
+#include "stdarg.h"
+#include "stdlib.h"
+#include "wchar.h"
+#include "locale.h"
+#include "string.h"
+#include "wctype.h"
+#include "complex.h"
+#include "stdint.h"
+#include "inttypes.h"
+
+// C++11 deprecated headers
+#include "stdalign.h"
+#include "stdbool.h"
+#include "fenv.h"
+#include "tgmath.h"
+#include "uchar.h"
+
+// CHECK-FIXES: #include <cassert>
+// CHECK-FIXES-NEXT: #include <cfloat>
+// CHECK-FIXES-NEXT: #include <cmath>
+// CHECK-FIXES-NEXT: #include <cstddef>
+// CHECK-FIXES-NEXT: #include <csetjmp>
+// CHECK-FIXES-NEXT: #include <cstdio>
+// CHECK-FIXES-NEXT: #include <ctime>
+// CHECK-FIXES-NEXT: #include <cctype>
+// CHECK-FIXES-NEXT: #include <ciso646>
+// CHECK-FIXES-NEXT: #include <csignal>
+// CHECK-FIXES-NEXT: #include <cerrno>
+// CHECK-FIXES-NEXT: #include <climits>
+// CHECK-FIXES-NEXT: #include <cstdarg>
+// CHECK-FIXES-NEXT: #include <cstdlib>
+// CHECK-FIXES-NEXT: #include <cwchar>
+// CHECK-FIXES-NEXT: #include <clocale>
+// CHECK-FIXES-NEXT: #include <cstring>
+// CHECK-FIXES-NEXT: #include <cwctype>
+// CHECK-FIXES-NEXT: #include <ccomplex>
+// CHECK-FIXES-NEXT: #include <cstdint>
+// CHECK-FIXES-NEXT: #include <cinttypes>
+
+#include <assert.h>
+#include <float.h>
+#include <math.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <time.h>
+#include <ctype.h>
+#include <iso646.h>
+#include <signal.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <locale.h>
+#include <string.h>
+#include <wctype.h>
+#include <complex.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+// C++11 deprecated headers
+#include <stdalign.h>
+#include <stdbool.h>
+#include <fenv.h>
+#include <tgmath.h>
+#include <uchar.h>
+
+// CHECK-FIXES: #include <cassert>
+// CHECK-FIXES-NEXT: #include <cfloat>
+// CHECK-FIXES-NEXT: #include <cmath>
+// CHECK-FIXES-NEXT: #include <cstddef>
+// CHECK-FIXES-NEXT: #include <csetjmp>
+// CHECK-FIXES-NEXT: #include <cstdio>
+// CHECK-FIXES-NEXT: #include <ctime>
+// CHECK-FIXES-NEXT: #include <cctype>
+// CHECK-FIXES-NEXT: #include <ciso646>
+// CHECK-FIXES-NEXT: #include <csignal>
+// CHECK-FIXES-NEXT: #include <cerrno>
+// CHECK-FIXES-NEXT: #include <climits>
+// CHECK-FIXES-NEXT: #include <cstdarg>
+// CHECK-FIXES-NEXT: #include <cstdlib>
+// CHECK-FIXES-NEXT: #include <cwchar>
+// CHECK-FIXES-NEXT: #include <clocale>
+// CHECK-FIXES-NEXT: #include <cstring>
+// CHECK-FIXES-NEXT: #include <cwctype>
+// CHECK-FIXES-NEXT: #include <ccomplex>
+// CHECK-FIXES-NEXT: #include <cstdint>
+// CHECK-FIXES-NEXT: #include <cinttypes>

test/clang-tidy/modernize-deprecated-headers-cxx11.cpp

+// RUN: %check_clang_tidy %s modernize-deprecated-headers %t -- -- -std=c++11 -isystem %S/Inputs/Headers
+
+#include "assert.h"
+#include "float.h"
+#include "math.h"
+#include "stddef.h"
+#include "setjmp.h"
+#include "stdio.h"
+#include "time.h"
+#include "ctype.h"
+#include "iso646.h"
+#include "signal.h"
+#include "errno.h"
+#include "limits.h"
+#include "stdarg.h"
+#include "stdlib.h"
+#include "wchar.h"
+#include "locale.h"
+#include "string.h"
+#include "wctype.h"
+#include "complex.h"
+#include "stdint.h"
+#include "inttypes.h"
+
+// C++11 deprecated headers
+#include "stdalign.h"
+#include "stdbool.h"
+#include "fenv.h"
+#include "tgmath.h"
+#include "uchar.h"
+
+// CHECK-FIXES: #include <cassert>
+// CHECK-FIXES-NEXT: #include <cfloat>
+// CHECK-FIXES-NEXT: #include <cmath>
+// CHECK-FIXES-NEXT: #include <cstddef>
+// CHECK-FIXES-NEXT: #include <csetjmp>
+// CHECK-FIXES-NEXT: #include <cstdio>
+// CHECK-FIXES-NEXT: #include <ctime>
+// CHECK-FIXES-NEXT: #include <cctype>
+// CHECK-FIXES-NEXT: #include <ciso646>
+// CHECK-FIXES-NEXT: #include <csignal>
+// CHECK-FIXES-NEXT: #include <cerrno>
+// CHECK-FIXES-NEXT: #include <climits>
+// CHECK-FIXES-NEXT: #include <cstdarg>
+// CHECK-FIXES-NEXT: #include <cstdlib>
+// CHECK-FIXES-NEXT: #include <cwchar>
+// CHECK-FIXES-NEXT: #include <clocale>
+// CHECK-FIXES-NEXT: #include <cstring>
+// CHECK-FIXES-NEXT: #include <cwctype>
+// CHECK-FIXES-NEXT: #include <ccomplex>
+// CHECK-FIXES-NEXT: #include <cstdint>
+// CHECK-FIXES-NEXT: #include <cinttypes>
+
+// C++11 headers
+// CHECK-FIXES: #include <cstdalign>
+// CHECK-FIXES-NEXT: #include <cstdbool>
+// CHECK-FIXES-NEXT: #include <cfenv>
+// CHECK-FIXES-NEXT: #include <ctgmath>
+// CHECK-FIXES-NEXT: #include <cuchar>
+
+#include <assert.h>
+#include <float.h>
+#include <math.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <time.h>
+#include <ctype.h>
+#include <iso646.h>
+#include <signal.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <locale.h>
+#include <string.h>
+#include <wctype.h>
+#include <complex.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+// C++11 deprecated headers
+#include <stdalign.h>
+#include <stdbool.h>
+#include <fenv.h>
+#include <tgmath.h>
+#include <uchar.h>
+
+// CHECK-FIXES: #include <cassert>
+// CHECK-FIXES-NEXT: #include <cfloat>
+// CHECK-FIXES-NEXT: #include <cmath>
+// CHECK-FIXES-NEXT: #include <cstddef>
+// CHECK-FIXES-NEXT: #include <csetjmp>
+// CHECK-FIXES-NEXT: #include <cstdio>
+// CHECK-FIXES-NEXT: #include <ctime>
+// CHECK-FIXES-NEXT: #include <cctype>
+// CHECK-FIXES-NEXT: #include <ciso646>
+// CHECK-FIXES-NEXT: #include <csignal>
+// CHECK-FIXES-NEXT: #include <cerrno>
+// CHECK-FIXES-NEXT: #include <climits>
+// CHECK-FIXES-NEXT: #include <cstdarg>
+// CHECK-FIXES-NEXT: #include <cstdlib>
+// CHECK-FIXES-NEXT: #include <cwchar>
+// CHECK-FIXES-NEXT: #include <clocale>
+// CHECK-FIXES-NEXT: #include <cstring>
+// CHECK-FIXES-NEXT: #include <cwctype>
+// CHECK-FIXES-NEXT: #include <ccomplex>
+// CHECK-FIXES-NEXT: #include <cstdint>
+// CHECK-FIXES-NEXT: #include <cinttypes>
+
+// C++11 headers
+// CHECK-FIXES: #include <cstdalign>
+// CHECK-FIXES-NEXT: #include <cstdbool>
+// CHECK-FIXES-NEXT: #include <cfenv>
+// CHECK-FIXES-NEXT: #include <ctgmath>
+// CHECK-FIXES-NEXT: #include <cuchar>