[Sema] Split off warn_impcast_integer_float_precision_constant into -Wimplicit-const-int-float-conversion

[MaskRay]

Summary

Currently, both warn_impcast_integer_float_precision_constant and
warn_impcast_integer_float_precision are covered by
-Wimplicit-int-float-conversion, but only the ..._constant warning is on
by default.

warn_impcast_integer_float_precision_constant likely flags real problems
while warn_impcast_integer_float_precision may flag legitimate use
cases (for example, int used with limited range supported by float).

If -Wno-implicit-int-float-conversion is used, currently there is no way
to restore the ..._constant warning. This patch adds
-Wimplicit-const-int-float-conversion to address the issue. (Similar to
the reasoning in https://reviews.llvm.org/D64666#1598194)

Adapted from a patch by Brooks Moses.

[MaskRay]

Fixed a typo noticed by @bmoses

[nickdesaulniers]

clang/test/Sema/implicit-int-float-conversion.c

3

If I understand the bug description properly:
You should add a test based on the description where you disable -Wimplicit-int-float-conversion, then re-enable -Wimplicit-const-int-float-conversion, and observe -Wimplicit-const-int-float-conversion diagnostics. ie.

// RUN: %clang_cc1 %s -verify -Wno-implicit-int-float-conversion -Wimplicit-const-int-float-conversion

[MaskRay]

Change RUN lines

[nickdesaulniers]

Thanks for the helping get the patch upstreamed!

clang/include/clang/Basic/DiagnosticGroups.td

 def EnumConversion : DiagGroup<"enum-conversion",
                                [EnumEnumConversion,
                                 EnumFloatConversion,
                                 EnumCompareConditional]>;
 def ObjCSignedCharBoolImplicitIntConversion :
   DiagGroup<"objc-signed-char-bool-implicit-int-conversion">;
 def ImplicitIntConversion : DiagGroup<"implicit-int-conversion",
                                      [ObjCSignedCharBoolImplicitIntConversion]>;
-def ImplicitIntFloatConversion : DiagGroup<"implicit-int-float-conversion">;
+def ImplicitConstIntFloatConversion : DiagGroup<"implicit-const-int-float-conversion">;
+def ImplicitIntFloatConversion : DiagGroup<"implicit-int-float-conversion",
+ [ImplicitConstIntFloatConversion]>;
 def ObjCSignedCharBoolImplicitFloatConversion :
   DiagGroup<"objc-signed-char-bool-implicit-float-conversion">;
 def ImplicitFloatConversion : DiagGroup<"implicit-float-conversion",
   [ImplicitIntFloatConversion,
    ObjCSignedCharBoolImplicitFloatConversion]>;
 def ImplicitFixedPointConversion : DiagGroup<"implicit-fixed-point-conversion">;
 
 def FloatOverflowConversion : DiagGroup<"float-overflow-conversion">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_impcast_int_to_objc_signed_char_bool : Warning<
   InGroup<ObjCSignedCharBoolImplicitIntConversion>, DefaultIgnore;
 
 // Implicit int -> float conversion precision loss warnings.
 def warn_impcast_integer_float_precision : Warning<
   "implicit conversion from %0 to %1 may lose precision">,
   InGroup<ImplicitIntFloatConversion>, DefaultIgnore;
 def warn_impcast_integer_float_precision_constant : Warning<
   "implicit conversion from %2 to %3 changes value from %0 to %1">,
-  InGroup<ImplicitIntFloatConversion>;
+  InGroup<ImplicitConstIntFloatConversion>;
 
 def warn_impcast_float_to_integer : Warning<
   "implicit conversion from %0 to %1 changes value from %2 to %3">,
   InGroup<FloatOverflowConversion>, DefaultIgnore;
 def warn_impcast_float_to_integer_out_of_range : Warning<
   "implicit conversion of out of range value from %0 to %1 is undefined">,
   InGroup<FloatOverflowConversion>, DefaultIgnore;
 def warn_impcast_float_to_integer_zero : Warning<

clang/test/Sema/implicit-int-float-conversion.c

-// RUN: %clang_cc1 %s -verify -Wno-conversion -Wimplicit-int-float-conversion
+// RUN: %clang_cc1 %s -verify
+// RUN: %clang_cc1 %s -verify -Wimplicit-const-int-float-conversion
+// RUN: %clang_cc1 %s -DNONCONST=1 -verify -Wimplicit-int-float-conversion
 
+#ifdef NONCOST
 long testReturn(long a, float b) {
   return a + b; // expected-warning {{implicit conversion from 'long' to 'float' may lose precision}}
 }
+#endif
 
 void testAssignment() {
   float f = 222222;
   double b = 222222222222L;
 
   float ff = 222222222222L;    // expected-warning {{changes value from 222222222222 to 222222221312}}
   float ffff = 222222222222UL; // expected-warning {{changes value from 222222222222 to 222222221312}}
 
   long l = 222222222222L;
+#ifdef NONCOST
   float fff = l; // expected-warning {{implicit conversion from 'long' to 'float' may lose precision}}
+#endif
 }
 
 void testExpression() {
   float a = 0.0f;
 
   float b = 222222222222L + a; // expected-warning {{changes value from 222222222222 to 222222221312}}
 
   float g = 22222222 + 22222222;
   float c = 22222222 + 22222223; // expected-warning {{implicit conversion from 'int' to 'float' changes value from 44444445 to 44444444}}
 
   int i = 0;
+#ifdef NONCOST
   float d = i + a; // expected-warning {{implicit conversion from 'int' to 'float' may lose precision}}
+#endif
 
   double e = 0.0;
   double f = i + e;
 }
 
 void testCNarrowing() {
   // Since this is a C file. C++11 narrowing is not in effect.
   // In this case, we should issue warnings.
   float a = {222222222222L}; // expected-warning {{changes value from 222222222222 to 222222221312}}
 
   long b = 222222222222L;
+#ifdef NONCOST
   float c = {b}; // expected-warning {{implicit conversion from 'long' to 'float' may lose precision}}
+#endif
 }