[clang-tidy] Correct IncorrectRoundings namespace.

[alexfh]

LG

clang-tidy/misc/IncorrectRoundings.h

 //===--- IncorrectRoundings.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_MISC_INCORRECTROUNDINGS_H_
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
+namespace misc {
 
 /// \brief Checks the usage of patterns known to produce incorrect rounding.
 /// Programmers often use
 ///   (int)(double_expression + 0.5)
 /// to round the double expression to an integer. The problem with this
 ///  1. It is unnecessarily slow.
 ///  2. It is incorrect. The number 0.499999975 (smallest representable float
 ///     number below 0.5) rounds to 1.0. Even worse behavior for negative
 ///     numbers where both -0.5f and -1.4f both round to 0.0.
 class IncorrectRoundings : public ClangTidyCheck {
 public:
   IncorrectRoundings(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang
 
-
 #endif  // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_

clang-tidy/misc/IncorrectRoundings.cpp

 }
 } // namespace ast_matchers
 } // namespace clang
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
+namespace misc {
 void IncorrectRoundings::registerMatchers(MatchFinder *MatchFinder) {
   // Match a floating literal with value 0.5.
   auto FloatHalf = floatLiteral(floatHalf());
 
   // Match a floating point expression.
   auto FloatType = expr(hasType(builtinType(isFloatingPoint())));
 
   // Match a floating literal of 0.5 or a floating literal of 0.5 implicitly.

 
 void IncorrectRoundings::check(const MatchFinder::MatchResult &Result) {
   const auto *CastExpr = Result.Nodes.getStmtAs<ImplicitCastExpr>("CastExpr");
   diag(CastExpr->getLocStart(),
        "casting (double + 0.5) to integer leads to incorrect rounding; "
        "consider using lround (#include <cmath>) instead");
 }
 
+} // namespace misc
 } // namespace tidy
 } // namespace clang