[SIL Diagnostics] Warn when assigning an integer literal to a

variable of floating-point type results in loss of precision.
<rdar://15224041>

Author: ravikandhadai

include/swift/AST/DiagnosticsSIL.def

@@ -337,6 +337,11 @@ WARNING(warning_float_overflows_maxbuiltin, none,
   "'%0' overflows to %select{|-}1inf because its magnitude exceeds "
   "the limits of a float literal", (StringRef, bool))
 
+// Integer to floating-point conversions
+WARNING(warning_int_to_fp_inexact, none,
+  "'%1' is not exactly representable as %0; it becomes '%2'",
+  (Type, StringRef, StringRef))
+
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1087,7 +1087,8 @@ bool isHexLiteralInSource(FloatLiteralInst *flitInst) {
 }
 
 bool maybeExplicitFPCons(BuiltinInst *BI, const BuiltinInfo &Builtin) {
-  assert(Builtin.ID == BuiltinValueKind::FPTrunc);
+  assert(Builtin.ID == BuiltinValueKind::FPTrunc ||
+         Builtin.ID == BuiltinValueKind::IntToFPWithOverflow);
 
   auto *callExpr = BI->getLoc().getAsASTNode<CallExpr>();
   if (!callExpr || !dyn_cast<ConstructorRefCallExpr>(callExpr->getFn()))
@@ -1253,21 +1254,38 @@ case BuiltinValueKind::id:
     SILLocation Loc = BI->getLoc();
     const ApplyExpr *CE = Loc.getAsASTNode<ApplyExpr>();
 
-    // Check for overflow.
-    if (ConversionStatus & APFloat::opOverflow) {
-      // If we overflow and are not asked for diagnostics, just return nullptr.
-      if (!ResultsInError.hasValue())
-        return nullptr;
+    bool overflow = ConversionStatus & APFloat::opOverflow;
+    bool inexact = ConversionStatus & APFloat::opInexact;
 
-      SmallString<10> SrcAsString;
-      SrcVal.toString(SrcAsString, /*radix*/10, true /*isSigned*/);
+    if (overflow || inexact) {
+      // Check if diagnostics is enabled. If so, make sure to suppress
+      // warnings for conversions through explicit initializers,
+      // but do not suppress errors.
+      if (ResultsInError.hasValue() &&
+          (overflow || !maybeExplicitFPCons(BI, Builtin))) {
+        SmallString<10> SrcAsString;
+        SrcVal.toString(SrcAsString, /*radix*/ 10, true /*isSigned*/);
 
-      // Otherwise emit our diagnostics and then return nullptr.
-      diagnose(M.getASTContext(), Loc.getSourceLoc(),
-               diag::integer_literal_overflow,
-               CE ? CE->getType() : DestTy, SrcAsString);
-      ResultsInError = Optional<bool>(true);
-      return nullptr;
+        if (overflow) {
+          diagnose(M.getASTContext(), Loc.getSourceLoc(),
+                   diag::integer_literal_overflow, CE ? CE->getType() : DestTy,
+                   SrcAsString);
+        } else {
+          SmallString<10> destStr;
+          unsigned srcBitWidth = SrcVal.getBitWidth();
+          // Display the 'TruncVal' like an integer in order to make the
+          // imprecision due to floating-point representation obvious.
+          TruncVal.toString(destStr, srcBitWidth, srcBitWidth);
+          diagnose(M.getASTContext(), Loc.getSourceLoc(),
+                   diag::warning_int_to_fp_inexact, CE ? CE->getType() : DestTy,
+                   SrcAsString, destStr);
+        }
+        ResultsInError = Optional<bool>(true);
+      }
+      // If there is an overflow, just return nullptr as this is undefined
+      // behavior. Otherwise, continue folding as in the normal workflow.
+      if (overflow)
+        return nullptr;
     }
 
     // The call to the builtin should be replaced with the constant value.

test/SILOptimizer/diagnostic_constant_propagation.swift

@@ -185,49 +185,53 @@ func testConvertOverflow() {
   Int64(UInt32(200)) // expected-warning{{unused}}
   UInt64(UInt32(200)) // expected-warning{{unused}}
 
-  // IEEE binary32 max value = 2^128 * (2^23-1)/2^23
-  var _ /*float32_max*/                     : Float32 = (340282326356119256160033759537265639424)
-  var _ /*float32_max_p1*/                  : Float32 = (340282326356119256160033759537265639425)
 
-  // 2^128 * (2^25-1)/2^25 - 1
-  var _ /*float32_max_not_yet_overflow*/    : Float32 = (340282356779733661637539395458142568447)
-  // 2^128 * (2^25-1)/2^25
+  var _ /*float32_max*/                     : Float32 = (340282346638528859811704183484516925440) // in hexfloat = 0x1.fffffep127
+
+  var _ /*float32_near_max_but_imprecise*/  : Float32 = (340282326356119256160033759537265639425) // expected-warning {{'340282326356119256160033759537265639425' is not exactly representable as 'Float32' (aka 'Float'); it becomes '340282326356119256160033759537265639424'}}
+
+  // FIXME: false negative: this should flagged as an overflow error but it doesn't due to a bug (possibly in LLVM::APFloat) <rdar://40079582>
+  var _ /*float32_max_not_yet_overflow??*/   : Float32 = (340282356779733661637539395458142568447) // expected-warning {{'340282356779733661637539395458142568447' is not exactly representable as 'Float32' (aka 'Float'); it becomes '340282346638528859811704183484516925440'}}
+
   var _ /*float32_max_first_overflow*/      : Float32 = (340282356779733661637539395458142568448) // expected-error {{integer literal '340282356779733661637539395458142568448' overflows when stored into 'Float32'}}
 
   // 2^128
   var _ /*float32_max_definitely_overflow*/ : Float32 = (340282366920938463463374607431768211456) // expected-error {{integer literal '340282366920938463463374607431768211456' overflows when stored into 'Float32'}}
 
-  // IEEE binary32 min value = -1 * 2^128 * (2^23-1)/2^23
-  var _ /*float32_min*/                     : Float32 = (-340282326356119256160033759537265639424)
-  var _ /*float32_min_p1*/                  : Float32 = (-340282326356119256160033759537265639425)
+  // IEEE binary32 min value
+  var _ /*float32_min*/                     : Float32 = -340282346638528859811704183484516925440 // (in hexfloat) = -0x1.fffffep127
+  var _ /*float32_near_min*/                : Float32 = (-340282326356119256160033759537265639424)
+  var _ /*float32_min_p1*/                  : Float32 = (-340282326356119256160033759537265639425) // expected-warning {{'-340282326356119256160033759537265639425' is not exactly representable as 'Float32' (aka 'Float'); it becomes '-340282326356119256160033759537265639424'}}
+
+  // FIXME: false negative: this should be flagged by overflow diagnostics
+  var _ /*float32_min_not_yet_overflow??*/  : Float32 = (-340282356779733661637539395458142568447) // expected-warning {{'-340282356779733661637539395458142568447' is not exactly representable as 'Float32' (aka 'Float'); it becomes '-340282346638528859811704183484516925440'}}
 
-  // -1 * 2^128 * (2^25-1)/2^25 - 1
-  var _ /*float32_min_not_yet_overflow*/    : Float32 = (-340282356779733661637539395458142568447)
-  // -1 * 2^128 * (2^25-1)/2^25
   var _ /*float32_min_first_overflow*/      : Float32 = (-340282356779733661637539395458142568448) // expected-error {{integer literal '-340282356779733661637539395458142568448' overflows when stored into 'Float32'}}
 
   // -1 * 2^128
   var _ /*float32_min_definitely_overflow*/ : Float32 = (-340282366920938463463374607431768211456) // expected-error {{integer literal '-340282366920938463463374607431768211456' overflows when stored into 'Float32'}}
 
-  // IEEE binary64 max value = 2^1024 * (2^52-1)/2^52
-  var _ /*float64_max*/                     : Float64 = (179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
-  var _ /*float64_max_p1*/                  : Float64 = (179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
+  // IEEE binary64 max value in hexfloat notation
+  var _ /*float64_max*/                     : Float64 = 0x1.fffffffffffffp1023
+  var _ /*float64_near_max*/                : Float64 = (179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
+  var _ /*float64_near_max_p1*/             : Float64 = (179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
+
+  // FIXME: false negative: this should be flagged by overflow diagnostics
+  var _/*float64_max_not_yet_overflo??*/    : Float64 = (179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791)
 
-  // 2^1024 * (2^54-1)/2^54 - 1
-  var _/*float64_max_not_yet_overflow*/    : Float64 = (179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791)
-  // 2^1024 * (2^54-1)/2^54
-  var _ /*float64_max_first_overflow*/      : Float64 = (179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792) // expected-error {{integer literal '179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792' overflows when stored into 'Double'}}
+  var _ /*float64_max_first_overflow*/    : Float64 = (179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792) // expected-error {{integer literal '179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792' overflows when stored into 'Double'}}
 
   // 2^1024
   var _/*float64_max_definitely_overflow*/ : Float64 = (179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216) // expected-error {{integer literal '179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216' overflows when stored into 'Double'}}
 
   // IEEE binary64 min value = -1 * 2^1024 * (2^52-1)/2^52
-  var _/*float64_min*/                     : Float64 = (-179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
-  var _/*float64_min_p1*/                  : Float64 = (-179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
+  var _/*float64_min*/                     : Float64 = -0x1.fffffffffffffp1023
+  var _/*float64_near_min*/                : Float64 = (-179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
+  var _/*float64_near_min_p1*/                  : Float64 = (-179769313486231550856124328384506240234343437157459335924404872448581845754556114388470639943126220321960804027157371570809852884964511743044087662767600909594331927728237078876188760579532563768698654064825262115771015791463983014857704008123419459386245141723703148097529108423358883457665451722744025579520)
 
-  // -1 * 2^1024 * (2^54-1)/2^54 - 1
+  // FIXME: flase negative: this should be flagged by overflow diagnostics
   var _/*float64_min_not_yet_overflow*/    : Float64 = (-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791)
-  // -1 * 2^1024 * (2^54-1)/2^54
+
   var _/*float64_min_first_overflow*/      : Float64 = (-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792) // expected-error {{integer literal '-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792' overflows when stored into 'Double'}}
 
   // -1 * 2^1024

test/SILOptimizer/diagnostic_constant_propagation_floats.swift

@@ -191,3 +191,28 @@ func testFloatArithmetic() {
   let b: Float = 10.0
   _blackHole(a * b)
 }
+
+func testIntToFloatConversion() {
+  let f1: Float = 16777216
+  _blackHole(f1)
+
+  let f2: Float = 1_000_000_000_000 // expected-warning {{'1000000000000' is not exactly representable as 'Float'; it becomes '999999995904'}}
+  _blackHole(f2)
+
+  // First positive integer that cannot be precisely represented in Float: 2^24 + 1
+  let f3: Float = 16777217 // expected-warning {{'16777217' is not exactly representable as 'Float'; it becomes '16777216'}}
+  _blackHole(f3)
+
+  let d1: Double = 9_007_199_254_740_992 // This value is 2^53
+  _blackHole(d1)
+
+  // FIXME: False Negative: no warning is produced here since we do not
+  // distinguish between implicit Double conversion that are within the
+  // context of an explicit conversion from others.
+  let d2: Double = 9_007_199_254_740_993
+  _blackHole(d2)
+
+   // No warnings are emitted for conversion through explicit constructor calls.
+  _blackHole(Float(16777217))
+  _blackHole(Double(2_147_483_647))
+}

test/SILOptimizer/diagnostic_constant_propagation_floats_x86.swift

@@ -101,3 +101,16 @@ func testHexFloatImprecision() {
   _blackHole(Double(0x1.00000000000001p-1000))
   _blackHole(Float80(0x1p-1075))
 }
+
+func testIntToFloatConversion() {
+  let e1: Float80 =  18_446_744_073_709_551_616 // This value is 2^64
+  _blackHole(e1)
+
+  let e2: Float80 =  18_446_744_073_709_551_617 // expected-warning {{'18446744073709551617' is not exactly representable as 'Float80'; it becomes '18446744073709551616'}}
+  _blackHole(e2)
+
+  // No warnings are emitted for conversion through explicit constructor calls.
+  // Note that the error here is because of an implicit conversion of the input
+  // literal to 'Int'.
+  _blackHole(Float80(18_446_744_073_709_551_617)) // expected-error {{integer literal '18446744073709551617' overflows when stored into 'Int'}}
+}

test/SILOptimizer/diagnostic_constant_propagation_int_arch32.swift

@@ -13,6 +13,8 @@
 //
 // FIXME: <rdar://problem/39193272> A false negative that happens only in REPL
 
+import StdlibUnittest
+
 func testArithmeticOverflow_Int_32bit() {
   do {
     // Literals.
@@ -230,3 +232,10 @@ func testArithmeticOverflow_UInt_32bit() {
     var _ : UInt = (0x7fff_ffff) | 0x8000_0000
   }
 }
+
+func testIntToFloatConversion() {
+  // No warnings are emitted for conversion through explicit constructor calls.
+  // Note that the error here is because of an implicit conversion of the input
+  // literal to 'Int', which is 32 bits in arch32.
+  _blackHole(Double(9_007_199_254_740_993)) // expected-error {{integer literal '9007199254740993' overflows when stored into 'Int'}}
+}

test/SILOptimizer/diagnostic_constant_propagation_int_arch64.swift

@@ -13,6 +13,8 @@
 //
 // FIXME: <rdar://problem/39193272> A false negative that happens only in REPL
 
+import StdlibUnittest
+
 func testArithmeticOverflow_Int_64bit() {
   do {
     // Literals.
@@ -233,3 +235,8 @@ func testArithmeticOverflow_UInt_64bit() {
     var _ : UInt = (0x7fff_ffff) | 0x8000_0000_0000_0000
   }
 }
+
+func testIntToFloatConversion() {
+  // No warnings are emitted for conversion through explicit constructor calls.
+  _blackHole(Double(9_007_199_254_740_993))
+}