Implement a sub-group of -Wconversion: -Wliteral-conversion. This

specifically targets literals which are implicitly converted, a those
are more often unintended and trivial to fix. This can be especially
helpful for diagnosing what makes 'const int x = 1e6' not an ICE.

Original patch authored by Jim Meehan with contributions from other
Googlers and a few cleanups from myself.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@125745 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td
index e257c482ba44ed831be6ac87eb64c40e2630d0bc..d4377c9a0b07baa230cdccbe52467a8fd2828fb5 100644 (file)
--- a/include/clang/Basic/DiagnosticGroups.td
+++ b/include/clang/Basic/DiagnosticGroups.td
@@ -181,10 +181,12 @@ def Parentheses : DiagGroup<"parentheses",
 // legacy reasons:
 //   - some people want just 64-to-32 warnings
 //   - conversion warnings with constant sources are on by default
+//   - conversion warnings for literals are on by default
 //   - bool-to-pointer conversion warnings are on by default
 def Conversion : DiagGroup<"conversion",
                            [DiagGroup<"shorten-64-to-32">,
                             DiagGroup<"constant-conversion">,
+                            DiagGroup<"literal-conversion">,
                             BoolConversions]>,
                  DiagCategory<"Value Conversion Issue">;
 

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index 985a771028c7b5480fc6bafaf35e5824fea1e937..d6840903e3bcaaff5860afceb1a4788320dd0155 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1127,6 +1127,10 @@ def warn_impcast_integer_precision_constant : Warning<
 def warn_impcast_bitfield_precision_constant : Warning<
   "implicit truncation from %2 to bitfield changes value from %0 to %1">,
   InGroup<DiagGroup<"constant-conversion">>;
+def warn_impcast_literal_float_to_integer : Warning<
+  "implicit conversion turns literal floating-point number into integer: "
+  "%0 to %1">,
+  InGroup<DiagGroup<"literal-conversion">>, DefaultIgnore;
 
 def warn_cast_align : Warning<
   "cast from %0 to %1 increases required alignment from %2 to %3">,

diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp
index 9913edb43470b55e7cb09bec16454db05d0e4747..a3ab52c0006fc102177ee570199df46f9dc96ca2 100644 (file)
--- a/lib/Sema/SemaChecking.cpp
+++ b/lib/Sema/SemaChecking.cpp
@@ -2799,9 +2799,15 @@ void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
     }
 
     // If the target is integral, always warn.
-    if ((TargetBT && TargetBT->isInteger()))
-      // TODO: don't warn for integer values?
-      DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_float_integer);
+    if ((TargetBT && TargetBT->isInteger())) {
+      Expr *InnerE = E->IgnoreParenImpCasts();
+      if (FloatingLiteral *LiteralExpr = dyn_cast<FloatingLiteral>(InnerE)) {
+        DiagnoseImpCast(S, LiteralExpr, T, CC,
+                        diag::warn_impcast_literal_float_to_integer);
+      } else {
+        DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_float_integer);
+      }
+    }
 
     return;
   }

diff --git a/test/Sema/knr-def-call.c b/test/Sema/knr-def-call.c
index b23beb57114b64162bf42da61caa954cd556056c..d054a047650546448daf1fc66b0e35566fd41935 100644 (file)
--- a/test/Sema/knr-def-call.c
+++ b/test/Sema/knr-def-call.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -Wconversion -fsyntax-only -verify %s
+// RUN: %clang_cc1 -Wconversion -Wliteral-conversion -fsyntax-only -verify %s
 
 // C DR #316, PR 3626.
 void f0(a, b, c, d) int a,b,c,d; {}
@@ -36,6 +36,6 @@ void proto(x)
 }
 
 void use_proto() {
-  proto(42.0); // expected-warning{{implicit conversion turns floating-point number into integer: 'double' to 'int'}}
-  (&proto)(42.0); // expected-warning{{implicit conversion turns floating-point number into integer: 'double' to 'int'}}
+  proto(42.0); // expected-warning{{implicit conversion turns literal floating-point number into integer}}
+  (&proto)(42.0); // expected-warning{{implicit conversion turns literal floating-point number into integer}}
 }

diff --git a/test/SemaCXX/warn-literal-conversion.cpp b/test/SemaCXX/warn-literal-conversion.cpp
new file mode 100644 (file)
index 0000000..dab5c01
--- /dev/null
+++ b/test/SemaCXX/warn-literal-conversion.cpp
@@ -0,0 +1,41 @@
+// RUN: %clang_cc1 -fsyntax-only -Wliteral-conversion -verify %s
+
+void foo(int y);
+
+// Warn when a literal float or double is assigned or bound to an integer.
+void test0() {
+  // Float
+  int y0 = 1.2222F; // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int y1 = (1.2222F); // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int y2 = (((1.2222F))); // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int y3 = 12E1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int y4 = 1.2E1F; // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  // Double
+  int y5 = 1.2222; // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int y6 = 12E1; // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int y7 = 1.2E1; // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+  int y8 = (1.2E1); // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+
+  // Test assignment to an existing variable.
+  y8 = 2.22F; // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+
+  // Test direct initialization.
+  int y9(1.23F); // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+
+  // Test passing a literal floating-point value to a function that takes an integer.
+  foo(1.2F); // expected-warning {{implicit conversion turns literal floating-point number into integer}}
+
+  // FIXME: -Wconversion-literal doesn't catch "-1.2F".
+  int y10 = -1.2F;
+
+  // -Wconversion-literal does NOT catch const values.
+  // (-Wconversion DOES catch them.)
+  static const float sales_tax_rate = .095F;
+  int z = sales_tax_rate;
+  foo(sales_tax_rate);
+
+  // Expressions, such as those that indicate rounding-down, should NOT produce warnings.
+  int x = 24 * 0.5;
+  int y = (24*60*60) * 0.25;
+  int pennies = 123.45 * 100;
+}