[clang-tidy] Allow disabling integer narrowing conversions for cppcoreguidelines-narrowing-conversions

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.h

bool handleConditionalOperator(const ASTContext &Context, const Expr &Lhs,
                                  const Expr &Rhs);
 
   void handleImplicitCast(const ASTContext &Context,
                           const ImplicitCastExpr &Cast);
 
   void handleBinaryOperator(const ASTContext &Context,
                             const BinaryOperator &Op);
 
+  const bool WarnOnIntegerNarrowingConversion;
   const bool WarnOnFloatingPointNarrowingConversion;
   const bool WarnWithinTemplateInstantiation;
   const bool WarnOnEquivalentBitWidth;
   const std::string IgnoreConversionFromTypes;
   const bool PedanticMode;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NARROWING_CONVERSIONS_H

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

const std::vector<std::string> NameList =
       utils::options::parseStringList(Names);
   return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
 }
 } // namespace
 
 NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
+      WarnOnIntegerNarrowingConversion(
+          Options.get("WarnOnIntegerNarrowingConversion", true)),
       WarnOnFloatingPointNarrowingConversion(
           Options.get("WarnOnFloatingPointNarrowingConversion", true)),
       WarnWithinTemplateInstantiation(
           Options.get("WarnWithinTemplateInstantiation", false)),
       WarnOnEquivalentBitWidth(Options.get("WarnOnEquivalentBitWidth", true)),
       IgnoreConversionFromTypes(Options.get("IgnoreConversionFromTypes", "")),
       PedanticMode(Options.get("PedanticMode", false)) {}
 
 void NarrowingConversionsCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "WarnOnIntegerNarrowingConversion",
+                WarnOnIntegerNarrowingConversion);
   Options.store(Opts, "WarnOnFloatingPointNarrowingConversion",
                 WarnOnFloatingPointNarrowingConversion);
   Options.store(Opts, "WarnWithinTemplateInstantiation",
                 WarnWithinTemplateInstantiation);
   Options.store(Opts, "WarnOnEquivalentBitWidth", WarnOnEquivalentBitWidth);
   Options.store(Opts, "IgnoreConversionFromTypes", IgnoreConversionFromTypes);
   Options.store(Opts, "PedanticMode", PedanticMode);
 }
if (Constant.isFloat())
     return diagNarrowConstant(SourceLoc, Lhs, Rhs);
   return diagNarrowType(SourceLoc, Lhs, Rhs);
 }
 
 void NarrowingConversionsCheck::handleIntegralCast(const ASTContext &Context,
                                                    SourceLocation SourceLoc,
                                                    const Expr &Lhs,
                                                    const Expr &Rhs) {
+  if (WarnOnIntegerNarrowingConversion) {
     const BuiltinType *ToType = getBuiltinType(Lhs);
     // From [conv.integral]p7.3.8:
     // Conversions to unsigned integer is well defined so no warning is issued.
     // "The resulting value is the smallest unsigned value equal to the source
     // value modulo 2^n where n is the number of bits used to represent the
     // destination type."
     if (ToType->isUnsignedInteger())
       return;
     const BuiltinType *FromType = getBuiltinType(Rhs);
 
     // With this option, we don't warn on conversions that have equivalent width
     // in bits. eg. uint32 <-> int32.
     if (!WarnOnEquivalentBitWidth) {
       uint64_t FromTypeSize = Context.getTypeSize(FromType);
       uint64_t ToTypeSize = Context.getTypeSize(ToType);
       if (FromTypeSize == ToTypeSize)
         return;
     }
 
     llvm::APSInt IntegerConstant;
     if (getIntegerConstantExprValue(Context, Rhs, IntegerConstant)) {
       if (!isWideEnoughToHold(Context, IntegerConstant, *ToType))
-      diagNarrowIntegerConstantToSignedInt(SourceLoc, Lhs, Rhs, IntegerConstant,
+        diagNarrowIntegerConstantToSignedInt(SourceLoc, Lhs, Rhs,
+                                             IntegerConstant,
                                              Context.getTypeSize(FromType));
       return;
     }
     if (!isWideEnoughToHold(Context, *FromType, *ToType))
       diagNarrowTypeToSignedInt(SourceLoc, Lhs, Rhs);
   }
+}
 
 void NarrowingConversionsCheck::handleIntegralToBoolean(
     const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
     const Expr &Rhs) {
   // Conversion from Integral to Bool value is well defined.
 
   // We keep this function (even if it is empty) to make sure that
   // handleImplicitCast and handleBinaryOperator are symmetric in their behavior

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-narrowing-conversions.rst

 .. title:: clang-tidy - cppcoreguidelines-narrowing-conversions
 
 cppcoreguidelines-narrowing-conversions
 =======================================
 
 Checks for silent narrowing conversions, e.g: ``int i = 0; i += 0.1;``. While
 the issue is obvious in this former example, it might not be so in the
 following: ``void MyClass::f(double d) { int_member_ += d; }``.
 
 This rule is part of the "Expressions and statements" profile of the C++ Core
 Guidelines, corresponding to rule ES.46. See
 
 https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es46-avoid-lossy-narrowing-truncating-arithmetic-conversions.
 
 We enforce only part of the guideline, more specifically, we flag narrowing conversions from:
- - an integer to a narrower integer (e.g. ``char`` to ``unsigned char``),
+ - an integer to a narrower integer (e.g. ``char`` to ``unsigned char``)
+   if WarnOnIntegerNarrowingConversion Option is set,
  - an integer to a narrower floating-point (e.g. ``uint64_t`` to ``float``),
  - a floating-point to an integer (e.g. ``double`` to ``int``),
  - a floating-point to a narrower floating-point (e.g. ``double`` to ``float``)
    if WarnOnFloatingPointNarrowingConversion Option is set.
 
 This check will flag:
  - All narrowing conversions that are not marked by an explicit cast (c-style or
    ``static_cast``). For example: ``int i = 0; i += 0.1;``,
    ``void f(int); f(0.1);``,
  - All applications of binary operators with a narrowing conversions.
    For example: ``int i; i+= 0.1;``.
 
 
 Options
 -------
 
+.. option:: WarnOnIntegerNarrowingConversion
+
+    When `true`, the check will warn on narrowing integer conversion
+    (e.g. ``int`` to ``size_t``). `true` by default.
+
 .. option:: WarnOnFloatingPointNarrowingConversion
 
     When `true`, the check will warn on narrowing floating point conversion
     (e.g. ``double`` to ``float``). `true` by default.
 
 .. option:: WarnWithinTemplateInstantiation
 
     When `true`, the check will warn on narrowing conversions within template

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-narrowing-conversions-narrowinginteger-option.cpp

+// RUN: %check_clang_tidy -check-suffix=DEFAULT %s \
+// RUN: cppcoreguidelines-narrowing-conversions %t -- \
+// RUN: -config='{CheckOptions: [{key: cppcoreguidelines-narrowing-conversions.WarnOnIntegerNarrowingConversion, value: true}]}'
+
+// RUN: %check_clang_tidy -check-suffix=DISABLED %s \
+// RUN: cppcoreguidelines-narrowing-conversions %t -- \
+// RUN: -config='{CheckOptions: [{key: cppcoreguidelines-narrowing-conversions.WarnOnIntegerNarrowingConversion, value: false}]}'
+
+void foo(unsigned long long value) {
+  int a = value;
+  // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:11: warning: narrowing conversion from 'unsigned long long' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
+  // DISABLED: No warning for integer narrowing conversions when WarnOnIntegerNarrowingConversion = false.
+  long long b = value;
+  // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:17: warning: narrowing conversion from 'unsigned long long' to signed type 'long long' is implementation-defined [cppcoreguidelines-narrowing-conversions]
+  // DISABLED: No warning for integer narrowing conversions when WarnOnIntegerNarrowingConversion = false.
+}
+
+void casting_float_to_bool_is_still_operational_when_integer_narrowing_is_disabled(float f) {
+  if (f) {
+    // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'float' to 'bool' [cppcoreguidelines-narrowing-conversions]
+    // CHECK-MESSAGES-DISABLED: :[[@LINE-2]]:7: warning: narrowing conversion from 'float' to 'bool' [cppcoreguidelines-narrowing-conversions]
+  }
+}