fix clippy matches on FloatTy

Author: folkertdev

src/tools/clippy/clippy_lints/src/approx_const.rs

@@ -5,6 +5,7 @@ use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::attrs::RustcVersion;
 use rustc_hir::{HirId, Lit};
 use rustc_lint::{LateContext, LateLintPass, impl_lint_pass};
+use rustc_middle::bug;
 use rustc_span::{Span, symbol};
 use std::f64::consts as f64;
 
@@ -84,6 +85,7 @@ impl LateLintPass<'_> for ApproxConstant {
                 FloatTy::F32 => self.check_known_consts(cx, lit.span, s, "f32"),
                 FloatTy::F64 => self.check_known_consts(cx, lit.span, s, "f64"),
                 FloatTy::F128 => self.check_known_consts(cx, lit.span, s, "f128"),
+                FloatTy::PpcF128 => bug!("there are no ppcf128 literals"),
             },
             // FIXME(f16_f128): add `f16` and `f128` when these types become stable.
             LitKind::Float(s, LitFloatType::Unsuffixed) => self.check_known_consts(cx, lit.span, s, "f{32, 64}"),

src/tools/clippy/clippy_lints/src/float_literal.rs

@@ -5,6 +5,7 @@ use rustc_ast::ast::{LitFloatType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, impl_lint_pass};
+use rustc_middle::bug;
 use rustc_middle::ty::{self, FloatTy};
 use std::fmt;
 
@@ -93,6 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                 LitFloatType::Suffixed(FloatTy::F32) => Some("f32"),
                 LitFloatType::Suffixed(FloatTy::F64) => Some("f64"),
                 LitFloatType::Suffixed(FloatTy::F128) => Some("f128"),
+                LitFloatType::Suffixed(FloatTy::PpcF128) => bug!("there are no ppcf128 literals"),
                 LitFloatType::Unsuffixed => None,
             };
             let (is_whole, is_inf, mut float_str) = match fty {
@@ -110,6 +112,9 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
 
                     (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
                 },
+                FloatTy::PpcF128 => {
+                    bug!("there are no ppcf128 literals")
+                },
             };
 
             if is_inf {
@@ -182,6 +187,7 @@ fn max_digits(fty: FloatTy) -> u32 {
         FloatTy::F32 => f32::DIGITS,
         FloatTy::F64 => f64::DIGITS,
         FloatTy::F128 => f128::DIGITS,
+        FloatTy::PpcF128 => bug!("there are no ppcf128 literals"),
     }
 }
 

src/tools/clippy/clippy_lints/src/utils/author.rs

@@ -393,6 +393,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                             FloatTy::F32 => "F32",
                             FloatTy::F64 => "F64",
                             FloatTy::F128 => "F128",
+                            FloatTy::PpcF128 => "PpcF128",
                         };
                         format!("LitFloatType::Suffixed(FloatTy::{t})")
                     },

src/tools/clippy/clippy_utils/src/consts.rs

@@ -428,6 +428,7 @@ pub fn lit_to_mir_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
             FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
             FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
             FloatTy::F128 => Constant::parse_f128(is.as_str()),
+            FloatTy::PpcF128 => bug!("no ppcf128 literals"),
         },
         LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind() {
             ty::Float(FloatTy::F16) => Constant::parse_f16(is.as_str()),
@@ -991,8 +992,9 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                     let l = sext(self.tcx, l, ity);
                     let r = sext(self.tcx, r, ity);
 
-                    // Using / or %, where the left-hand argument is the smallest integer of a signed integer type and
-                    // the right-hand argument is -1 always panics, even with overflow-checks disabled
+                    // Using / or %, where the left-hand argument is the smallest integer of a
+                    // signed integer type and the right-hand argument is -1
+                    // always panics, even with overflow-checks disabled
                     if let BinOpKind::Div | BinOpKind::Rem = op
                         && l == ty_min_value
                         && r == -1
@@ -1106,10 +1108,14 @@ pub fn mir_to_const<'tcx>(tcx: TyCtxt<'tcx>, val: ConstValue, ty: Ty<'tcx>) -> O
         (ConstValue::Scalar(Scalar::Int(int)), _) => match ty.kind() {
             ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
             ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.to_bits(int.size()))),
-            ty::Float(FloatTy::F16) => Some(Constant::F16(int.into())),
-            ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits(int.into()))),
-            ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(int.into()))),
-            ty::Float(FloatTy::F128) => Some(Constant::F128(int.into())),
+
+            ty::Float(float) => match float {
+                FloatTy::F16 => Some(Constant::F16(int.into())),
+                FloatTy::F32 => Some(Constant::F32(f32::from_bits(int.into()))),
+                FloatTy::F64 => Some(Constant::F64(f64::from_bits(int.into()))),
+                FloatTy::F128 => Some(Constant::F128(int.into())),
+                FloatTy::PpcF128 => None,
+            },
             ty::RawPtr(_, _) => Some(Constant::RawPtr(int.to_bits(int.size()))),
             _ => None,
         },
@@ -1133,6 +1139,7 @@ pub fn mir_to_const<'tcx>(tcx: TyCtxt<'tcx>, val: ConstValue, ty: Ty<'tcx>) -> O
                     FloatTy::F32 => Constant::F32(f32::from_bits(val.to_u32().discard_err()?)),
                     FloatTy::F64 => Constant::F64(f64::from_bits(val.to_u64().discard_err()?)),
                     FloatTy::F128 => Constant::F128(val.to_u128().discard_err()?),
+                    FloatTy::PpcF128 => return None,
                 });
             }
             Some(Constant::Vec(res))