X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fconsts.rs;h=5d509ef76f3f2c071ef37fda6d6188ef5017089b;hb=8b45dd704b974fb9c6d8ea58330ca893154cb5db;hp=d116ffafeacdcb614439c1e85dc79783f37b5d11;hpb=d7ffaab0fbe3d5254470f552d870e45bf21a0c71;p=rust.git diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs index d116ffafeac..5d509ef76f3 100644 --- a/clippy_lints/src/consts.rs +++ b/clippy_lints/src/consts.rs @@ -1,37 +1,31 @@ -#![allow(cast_possible_truncation)] -#![allow(float_cmp)] +// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. -use rustc::lint::LateContext; -use rustc::{span_bug, bug}; -use rustc::hir::def::Def; -use rustc::hir::*; -use rustc::ty::{self, Ty, TyCtxt, Instance}; -use rustc::ty::subst::{Subst, Substs}; + +#![allow(clippy::float_cmp)] + +use crate::rustc::lint::LateContext; +use crate::rustc::{span_bug, bug}; +use crate::rustc::hir::def::Def; +use crate::rustc::hir::*; +use crate::rustc::ty::{self, Ty, TyCtxt, Instance}; +use crate::rustc::ty::subst::{Subst, Substs}; use std::cmp::Ordering::{self, Equal}; use std::cmp::PartialOrd; +use std::convert::TryInto; use std::hash::{Hash, Hasher}; use std::mem; use std::rc::Rc; -use syntax::ast::{FloatTy, LitKind}; -use syntax::ptr::P; +use crate::syntax::ast::{FloatTy, LitKind}; +use crate::syntax::ptr::P; use crate::utils::{sext, unsext, clip}; -#[derive(Debug, Copy, Clone)] -pub enum FloatWidth { - F32, - F64, - Any, -} - -impl From for FloatWidth { - fn from(ty: FloatTy) -> Self { - match ty { - FloatTy::F32 => FloatWidth::F32, - FloatTy::F64 => FloatWidth::F64, - } - } -} - /// A `LitKind`-like enum to fold constant `Expr`s into. #[derive(Debug, Clone)] pub enum Constant { @@ -123,12 +117,12 @@ fn hash(&self, state: &mut H) } impl Constant { - pub fn partial_cmp(tcx: TyCtxt<'_, '_, '_>, cmp_type: &ty::TypeVariants<'_>, left: &Self, right: &Self) -> Option { + pub fn partial_cmp(tcx: TyCtxt<'_, '_, '_>, cmp_type: &ty::TyKind<'_>, left: &Self, right: &Self) -> Option { match (left, right) { (&Constant::Str(ref ls), &Constant::Str(ref rs)) => Some(ls.cmp(rs)), (&Constant::Char(ref l), &Constant::Char(ref r)) => Some(l.cmp(r)), (&Constant::Int(l), &Constant::Int(r)) => { - if let ty::TyInt(int_ty) = *cmp_type { + if let ty::Int(int_ty) = *cmp_type { Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty))) } else { Some(l.cmp(&r)) @@ -140,11 +134,11 @@ pub fn partial_cmp(tcx: TyCtxt<'_, '_, '_>, cmp_type: &ty::TypeVariants<'_>, lef (&Constant::Tuple(ref l), &Constant::Tuple(ref r)) | (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l .iter() .zip(r.iter()) - .map(|(li, ri)| Constant::partial_cmp(tcx, cmp_type, li, ri)) + .map(|(li, ri)| Self::partial_cmp(tcx, cmp_type, li, ri)) .find(|r| r.map_or(true, |o| o != Ordering::Equal)) .unwrap_or_else(|| Some(l.len().cmp(&r.len()))), (&Constant::Repeat(ref lv, ref ls), &Constant::Repeat(ref rv, ref rs)) => { - match Constant::partial_cmp(tcx, cmp_type, lv, rv) { + match Self::partial_cmp(tcx, cmp_type, lv, rv) { Some(Equal) => Some(ls.cmp(rs)), x => x, } @@ -156,7 +150,7 @@ pub fn partial_cmp(tcx: TyCtxt<'_, '_, '_>, cmp_type: &ty::TypeVariants<'_>, lef /// parse a `LitKind` to a `Constant` pub fn lit_to_constant<'tcx>(lit: &LitKind, ty: Ty<'tcx>) -> Constant { - use syntax::ast::*; + use crate::syntax::ast::*; match *lit { LitKind::Str(ref is, _) => Constant::Str(is.to_string()), @@ -166,8 +160,8 @@ pub fn lit_to_constant<'tcx>(lit: &LitKind, ty: Ty<'tcx>) -> Constant { LitKind::Int(n, _) => Constant::Int(n), LitKind::Float(ref is, _) | LitKind::FloatUnsuffixed(ref is) => match ty.sty { - ty::TyFloat(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()), - ty::TyFloat(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()), + ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()), + ty::Float(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()), _ => bug!(), }, LitKind::Bool(b) => Constant::Bool(b), @@ -220,10 +214,10 @@ pub fn expr(&mut self, e: &Expr) -> Option { ExprKind::Tup(ref tup) => self.multi(tup).map(Constant::Tuple), ExprKind::Repeat(ref value, _) => { let n = match self.tables.expr_ty(e).sty { - ty::TyArray(_, n) => n.assert_usize(self.tcx).expect("array length"), + ty::Array(_, n) => n.assert_usize(self.tcx).expect("array length"), _ => span_bug!(e.span, "typeck error"), }; - self.expr(value).map(|v| Constant::Repeat(Box::new(v), n as u64)) + self.expr(value).map(|v| Constant::Repeat(Box::new(v), n)) }, ExprKind::Unary(op, ref operand) => self.expr(operand).and_then(|o| match op { UnNot => self.constant_not(&o, self.tables.expr_ty(e)), @@ -236,6 +230,7 @@ pub fn expr(&mut self, e: &Expr) -> Option { } } + #[allow(clippy::cast_possible_wrap)] fn constant_not(&self, o: &Constant, ty: ty::Ty<'_>) -> Option { use self::Constant::*; match *o { @@ -243,8 +238,8 @@ fn constant_not(&self, o: &Constant, ty: ty::Ty<'_>) -> Option { Int(value) => { let value = !value; match ty.sty { - ty::TyInt(ity) => Some(Int(unsext(self.tcx, value as i128, ity))), - ty::TyUint(ity) => Some(Int(clip(self.tcx, value, ity))), + ty::Int(ity) => Some(Int(unsext(self.tcx, value as i128, ity))), + ty::Uint(ity) => Some(Int(clip(self.tcx, value, ity))), _ => None, } }, @@ -257,7 +252,7 @@ fn constant_negate(&self, o: &Constant, ty: ty::Ty<'_>) -> Option { match *o { Int(value) => { let ity = match ty.sty { - ty::TyInt(ity) => ity, + ty::Int(ity) => ity, _ => return None, }; // sign extend @@ -282,6 +277,8 @@ fn multi(&mut self, vec: &[Expr]) -> Option> { /// lookup a possibly constant expression from a ExprKind::Path fn fetch_path(&mut self, qpath: &QPath, id: HirId) -> Option { + use crate::rustc::mir::interpret::GlobalId; + let def = self.tables.qpath_def(qpath, id); match def { Def::Const(def_id) | Def::AssociatedConst(def_id) => { @@ -296,7 +293,7 @@ fn fetch_path(&mut self, qpath: &QPath, id: HirId) -> Option { instance, promoted: None, }; - use rustc::mir::interpret::GlobalId; + let result = self.tcx.const_eval(self.param_env.and(gid)).ok()?; let ret = miri_to_const(self.tcx, result); if ret.is_some() { @@ -336,7 +333,7 @@ fn binop(&mut self, op: BinOp, left: &Expr, right: &Expr) -> Option { match (l, r) { (Constant::Int(l), Some(Constant::Int(r))) => { match self.tables.expr_ty(left).sty { - ty::TyInt(ity) => { + ty::Int(ity) => { let l = sext(self.tcx, l, ity); let r = sext(self.tcx, r, ity); let zext = |n: i128| Constant::Int(unsext(self.tcx, n, ity)); @@ -346,8 +343,12 @@ fn binop(&mut self, op: BinOp, left: &Expr, right: &Expr) -> Option { BinOpKind::Mul => l.checked_mul(r).map(zext), BinOpKind::Div if r != 0 => l.checked_div(r).map(zext), BinOpKind::Rem if r != 0 => l.checked_rem(r).map(zext), - BinOpKind::Shr => l.checked_shr(r as u128 as u32).map(zext), - BinOpKind::Shl => l.checked_shl(r as u128 as u32).map(zext), + BinOpKind::Shr => l.checked_shr( + r.try_into().expect("invalid shift") + ).map(zext), + BinOpKind::Shl => l.checked_shl( + r.try_into().expect("invalid shift") + ).map(zext), BinOpKind::BitXor => Some(zext(l ^ r)), BinOpKind::BitOr => Some(zext(l | r)), BinOpKind::BitAnd => Some(zext(l & r)), @@ -360,15 +361,19 @@ fn binop(&mut self, op: BinOp, left: &Expr, right: &Expr) -> Option { _ => None, } } - ty::TyUint(_) => { + ty::Uint(_) => { match op.node { BinOpKind::Add => l.checked_add(r).map(Constant::Int), BinOpKind::Sub => l.checked_sub(r).map(Constant::Int), BinOpKind::Mul => l.checked_mul(r).map(Constant::Int), BinOpKind::Div => l.checked_div(r).map(Constant::Int), BinOpKind::Rem => l.checked_rem(r).map(Constant::Int), - BinOpKind::Shr => l.checked_shr(r as u32).map(Constant::Int), - BinOpKind::Shl => l.checked_shl(r as u32).map(Constant::Int), + BinOpKind::Shr => l.checked_shr( + r.try_into().expect("shift too large") + ).map(Constant::Int), + BinOpKind::Shl => l.checked_shl( + r.try_into().expect("shift too large") + ).map(Constant::Int), BinOpKind::BitXor => Some(Constant::Int(l ^ r)), BinOpKind::BitOr => Some(Constant::Int(l | r)), BinOpKind::BitAnd => Some(Constant::Int(l & r)), @@ -426,24 +431,29 @@ fn binop(&mut self, op: BinOp, left: &Expr, right: &Expr) -> Option { } pub fn miri_to_const<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, result: &ty::Const<'tcx>) -> Option { - use rustc::mir::interpret::{Scalar, ConstValue}; + use crate::rustc::mir::interpret::{Scalar, ConstValue}; match result.val { ConstValue::Scalar(Scalar::Bits{ bits: b, ..}) => match result.ty.sty { - ty::TyBool => Some(Constant::Bool(b == 1)), - ty::TyUint(_) | ty::TyInt(_) => Some(Constant::Int(b)), - ty::TyFloat(FloatTy::F32) => Some(Constant::F32(f32::from_bits(b as u32))), - ty::TyFloat(FloatTy::F64) => Some(Constant::F64(f64::from_bits(b as u64))), + ty::Bool => Some(Constant::Bool(b == 1)), + ty::Uint(_) | ty::Int(_) => Some(Constant::Int(b)), + ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits( + b.try_into().expect("invalid f32 bit representation") + ))), + ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits( + b.try_into().expect("invalid f64 bit representation") + ))), // FIXME: implement other conversion _ => None, }, - ConstValue::ScalarPair(Scalar::Ptr(ptr), Scalar::Bits { bits: n, .. }) => match result.ty.sty { - ty::TyRef(_, tam, _) => match tam.sty { - ty::TyStr => { + ConstValue::ScalarPair(Scalar::Ptr(ptr), + Scalar::Bits { bits: n, .. }) => match result.ty.sty { + ty::Ref(_, tam, _) => match tam.sty { + ty::Str => { let alloc = tcx .alloc_map .lock() .unwrap_memory(ptr.alloc_id); - let offset = ptr.offset.bytes() as usize; + let offset = ptr.offset.bytes().try_into().expect("too-large pointer offset"); let n = n as usize; String::from_utf8(alloc.bytes[offset..(offset + n)].to_owned()).ok().map(Constant::Str) },