X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fconsts.rs;h=5d509ef76f3f2c071ef37fda6d6188ef5017089b;hb=8b45dd704b974fb9c6d8ea58330ca893154cb5db;hp=8e0e60193bbafb9247fb646c45e79976ee2accde;hpb=1bd17e4fa2ba4bad31c15c50300c32235a715223;p=rust.git diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs index 8e0e60193bb..5d509ef76f3 100644 --- a/clippy_lints/src/consts.rs +++ b/clippy_lints/src/consts.rs @@ -1,36 +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::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 { @@ -122,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)) @@ -139,11 +134,11 @@ pub fn partial_cmp(tcx: TyCtxt, cmp_type: &ty::TypeVariants, left: &Self, right: (&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, } @@ -155,7 +150,7 @@ pub fn partial_cmp(tcx: TyCtxt, cmp_type: &ty::TypeVariants, left: &Self, right: /// 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()), @@ -165,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), @@ -219,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)), @@ -235,15 +230,16 @@ pub fn expr(&mut self, e: &Expr) -> Option { } } - fn constant_not(&self, o: &Constant, ty: ty::Ty) -> Option { + #[allow(clippy::cast_possible_wrap)] + fn constant_not(&self, o: &Constant, ty: ty::Ty<'_>) -> Option { use self::Constant::*; match *o { Bool(b) => Some(Bool(!b)), Int(value) => { - let mut value = !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, } }, @@ -251,12 +247,12 @@ fn constant_not(&self, o: &Constant, ty: ty::Ty) -> Option { } } - fn constant_negate(&self, o: &Constant, ty: ty::Ty) -> Option { + fn constant_negate(&self, o: &Constant, ty: ty::Ty<'_>) -> Option { use self::Constant::*; match *o { Int(value) => { let ity = match ty.sty { - ty::TyInt(ity) => ity, + ty::Int(ity) => ity, _ => return None, }; // sign extend @@ -281,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) => { @@ -295,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() { @@ -335,48 +333,56 @@ 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)); match op.node { - BiAdd => l.checked_add(r).map(zext), - BiSub => l.checked_sub(r).map(zext), - BiMul => l.checked_mul(r).map(zext), - BiDiv if r != 0 => l.checked_div(r).map(zext), - BiRem if r != 0 => l.checked_rem(r).map(zext), - BiShr => l.checked_shr(r as u128 as u32).map(zext), - BiShl => l.checked_shl(r as u128 as u32).map(zext), - BiBitXor => Some(zext(l ^ r)), - BiBitOr => Some(zext(l | r)), - BiBitAnd => Some(zext(l & r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + BinOpKind::Add => l.checked_add(r).map(zext), + BinOpKind::Sub => l.checked_sub(r).map(zext), + 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.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)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, } } - ty::TyUint(_) => { + ty::Uint(_) => { match op.node { - BiAdd => l.checked_add(r).map(Constant::Int), - BiSub => l.checked_sub(r).map(Constant::Int), - BiMul => l.checked_mul(r).map(Constant::Int), - BiDiv => l.checked_div(r).map(Constant::Int), - BiRem => l.checked_rem(r).map(Constant::Int), - BiShr => l.checked_shr(r as u32).map(Constant::Int), - BiShl => l.checked_shl(r as u32).map(Constant::Int), - BiBitXor => Some(Constant::Int(l ^ r)), - BiBitOr => Some(Constant::Int(l | r)), - BiBitAnd => Some(Constant::Int(l & r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + 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.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)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, } }, @@ -384,40 +390,40 @@ fn binop(&mut self, op: BinOp, left: &Expr, right: &Expr) -> Option { } }, (Constant::F32(l), Some(Constant::F32(r))) => match op.node { - BiAdd => Some(Constant::F32(l + r)), - BiSub => Some(Constant::F32(l - r)), - BiMul => Some(Constant::F32(l * r)), - BiDiv => Some(Constant::F32(l / r)), - BiRem => Some(Constant::F32(l % r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + BinOpKind::Add => Some(Constant::F32(l + r)), + BinOpKind::Sub => Some(Constant::F32(l - r)), + BinOpKind::Mul => Some(Constant::F32(l * r)), + BinOpKind::Div => Some(Constant::F32(l / r)), + BinOpKind::Rem => Some(Constant::F32(l % r)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, }, (Constant::F64(l), Some(Constant::F64(r))) => match op.node { - BiAdd => Some(Constant::F64(l + r)), - BiSub => Some(Constant::F64(l - r)), - BiMul => Some(Constant::F64(l * r)), - BiDiv => Some(Constant::F64(l / r)), - BiRem => Some(Constant::F64(l % r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + BinOpKind::Add => Some(Constant::F64(l + r)), + BinOpKind::Sub => Some(Constant::F64(l - r)), + BinOpKind::Mul => Some(Constant::F64(l * r)), + BinOpKind::Div => Some(Constant::F64(l / r)), + BinOpKind::Rem => Some(Constant::F64(l % r)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, }, (l, r) => match (op.node, l, r) { - (BiAnd, Constant::Bool(false), _) => Some(Constant::Bool(false)), - (BiOr, Constant::Bool(true), _) => Some(Constant::Bool(true)), - (BiAnd, Constant::Bool(true), Some(r)) | (BiOr, Constant::Bool(false), Some(r)) => Some(r), - (BiBitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)), - (BiBitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)), - (BiBitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)), + (BinOpKind::And, Constant::Bool(false), _) => Some(Constant::Bool(false)), + (BinOpKind::Or, Constant::Bool(true), _) => Some(Constant::Bool(true)), + (BinOpKind::And, Constant::Bool(true), Some(r)) | (BinOpKind::Or, Constant::Bool(false), Some(r)) => Some(r), + (BinOpKind::BitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)), + (BinOpKind::BitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)), + (BinOpKind::BitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)), _ => None, }, } @@ -425,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) },