Mirrors/rust-clippy
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-clippy synced 2024-11-27 15:11:30 +00:00
Code Issues Projects Releases Packages Wiki Activity

added follow flag

Browse source
This commit is contained in:
llogiq 2015-08-13 09:25:44 +02:00
parent 6aeb955214
commit a2f19f2a38
1 changed files with 113 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

148
src/const.rs
View file

@ -3,60 +3,74 @@ use rustc::middle::const_eval::lookup_const_by_id;
use syntax::ast::*;
use syntax::ptr::P;
pub enum FloatWidth {
Fw32,
Fw64,
FwAny
}
impl From<FloatTy> for FloatWidth {
fn from(ty: FloatTy) -> FloatWidth {
match ty {
TyF32 => Fw32,
TyF64 => Fw64,
}
}
}
/// a Lit_-like enum to fold constant `Expr`s into
#[derive(PartialEq, Eq, Debug, Clone)]
pub enum Constant {
/// a String "abc"
ConstantStr(&'static str, StrStyle),
/// a Binary String b"abc"
ConstantBinary(Rc<Vec<u8>>),
/// a single byte b'a'
ConstantByte(u8),
/// a single char 'a'
ConstantChar(char),
/// an integer
ConstantInt(u64, LitIntType),
ConstantFloat(Cow<'static, str>, FloatTy),
ConstantFloatUnsuffixed(Cow<'static, str>),
/// a float with given type
ConstantFloat(Cow<'static, str>, FloatWidth),
/// true or false
ConstantBool(bool),
/// an array of constants
ConstantVec(Vec<Constant>),
/// also an array, but with only one constant, repeated N times
ConstantRepeat(Constant, usize),
/// a tuple of constants
ConstantTuple(Vec<Constant>),
}
/// simple constant folding
pub fn constant(cx: &Context, e: &Expr) -> Option<Constant> {
pub fn constant(cx: &Context, e: &Expr, follow: bool) -> Option<Constant> {
match e {
&ExprParen(ref inner) => constant(cx, inner),
&ExprPath(_, _) => fetch_path(cx, e),
&ExprBlock(ref block) => constant_block(cx, inner),
&ExprParen(ref inner) => constant(cx, inner, follow),
&ExprPath(_, _) => if follow { fetch_path(cx, e) } else { None },
&ExprBlock(ref block) => constant_block(cx, inner, follow),
&ExprIf(ref cond, ref then, ref otherwise) =>
match constant(cx, cond) {
Some(ConstantBool(true)) => constant(cx, then),
Some(ConstantBool(false)) => constant(cx, otherwise),
Some(ConstantBool(true)) => constant(cx, then, follow),
Some(ConstantBool(false)) => constant(cx, otherwise, follow),
_ => None,
},
&ExprLit(ref lit) => Some(lit_to_constant(lit)),
&ExprVec(ref vec) => constant_vec(cx, vec),
&ExprTup(ref tup) => constant_tup(cx, tup),
&ExprUnary(op, ref operand) => constant(cx, operand).and_then(
&ExprVec(ref vec) => constant_vec(cx, vec, follow),
&ExprTup(ref tup) => constant_tup(cx, tup, follow),
&ExprRepeat(ref value, ref number) =>
constant_binop_apply(cx, value, number,|v, n| ConstantRepeat(v, n)),
&ExprUnary(op, ref operand) => constant(cx, operand, follow).and_then(
|o| match op {
UnNot =>
if let ConstantBool(b) = o {
Some(ConstantBool(!b))
} else { None },
UnNeg =>
match o {
&ConstantInt(value, ty) =>
Some(ConstantInt(value, match ty {
SignedIntLit(ity, sign) =>
SignedIntLit(ity, neg_sign(sign)),
UnsuffixedIntLit(sign) =>
UnsuffixedIntLit(neg_sign(sign)),
_ => { return None; },
})),
&LitFloat(ref is, ref ty) =>
Some(ConstantFloat(neg_float_str(is), ty)),
&LitFloatUnsuffixed(ref is) =>
Some(ConstantFloatUnsuffixed(neg_float_str(is))),
_ => None,
},
UnNeg => constant_negate(o),
UnUniq | UnDeref => o,
}),
&ExprBinary(op, ref left, ref right) =>
constant_binop(cx, op, left, right, follow),
//TODO: add other expressions
_ => None,
}
@ -69,19 +83,19 @@ fn lit_to_constant(lit: &Lit_) -> Constant {
&LitByte(b) => ConstantByte(b),
&LitChar(c) => ConstantChar(c),
&LitInt(value, ty) => ConstantInt(value, ty),
&LitFloat(ref is, ty) => ConstantFloat(Cow::Borrowed(&*is), ty),
&LitFloat(ref is, ty) => ConstantFloat(Cow::Borrowed(&*is), ty.into()),
&LitFloatUnsuffixed(InternedString) =>
ConstantFloatUnsuffixed(Cow::Borrowed(&*is)),
ConstantFloat(Cow::Borrowed(&*is), FwAny),
&LitBool(b) => ConstantBool(b),
}
}
/// create `Some(ConstantVec(..))` of all constants, unless there is any
/// non-constant part
fn constant_vec(cx: &Context, vec: &[&Expr]) -> Option<Constant> {
Vec<Constant> parts = Vec::new();
fn constant_vec(cx: &Context, vec: &[&Expr], follow: bool) -> Option<Constant> {
parts = Vec::new();
for opt_part in vec {
match constant(cx, opt_part) {
match constant(cx, opt_part, follow) {
Some(ref p) => parts.push(p),
None => { return None; },
}
@ -89,10 +103,10 @@ fn constant_vec(cx: &Context, vec: &[&Expr]) -> Option<Constant> {
Some(ConstantVec(parts))
}
fn constant_tup(cx, &Context, tup: &[&Expr]) -> Option<Constant> {
Vec<Constant> parts = Vec::new();
fn constant_tup(cx: &Context, tup: &[&Expr], follow: bool) -> Option<Constant> {
parts = Vec::new();
for opt_part in vec {
match constant(cx, opt_part) {
match constant(cx, opt_part, follow) {
Some(ref p) => parts.push(p),
None => { return None; },
}
@ -109,14 +123,27 @@ fn fetch_path(cx: &Context, e: &Expr) -> Option<Constant> {
}
/// A block can only yield a constant if it only has one constant expression
fn constant_block(cx: &Context, block: &Block) -> Option<Constant> {
fn constant_block(cx: &Context, block: &Block, follow: bool) -> Option<Constant> {
if block.stmts.is_empty() {
block.expr.map(|b| constant(cx, b))
block.expr.map(|b| constant(cx, b, follow))
} else { None }
}
fn constant_negate(o: Constant) -> Option<Constant> {
match o {
&ConstantInt(value, ty) =>
Some(ConstantInt(value, match ty {
SignedIntLit(ity, sign) => SignedIntLit(ity, neg_sign(sign)),
UnsuffixedIntLit(sign) => UnsuffixedIntLit(neg_sign(sign)),
_ => { return None; },
})),
&LitFloat(ref is, ref ty) => Some(ConstantFloat(neg_float_str(is), ty)),
_ => None,
}
}
fn neg_sign(s: Sign) -> Sign {
match s:
match s {
Sign::Plus => Sign::Minus,
Sign::Minus => Sign::Plus,
}
@ -129,3 +156,48 @@ fn neg_float_str(s: &InternedString) -> Cow<'static, str> {
Cow::Owned(format!("-{}", &*s))
}
}
fn constant_binop(cx: &Context, op: BinOp, left: &Expr, right: &Expr,
follow: bool) -> Option<Constant> {
match op.node {
//BiAdd,
//BiSub,
//BiMul,
//BiDiv,
//BiRem,
BiAnd => constant_short_circuit(cx, left, right, false, follow),
BiOr => constant_short_circuit(cx, left, right, true, follow),
//BiBitXor,
//BiBitAnd,
//BiBitOr,
//BiShl,
//BiShr,
//BiEq,
//BiLt,
//BiLe,
//BiNe,
//BiGe,
//BiGt,
_ => None,
}
}
fn constant_binop_apply<F>(cx: &Context, left: &Expr, right: &Expr, op: F,
follow: bool) -> Option<Constant>
where F: FnMut(Constant, Constant) -> Option<Constant> {
constant(cx, left, follow).and_then(|l| constant(cx, right, follow)
.and_then(|r| op(l, r)))
}
fn constant_short_circuit(cx: &Context, left: &Expr, right: &Expr, b: bool,
follow: bool) -> Option<Constant> {
if let ConstantBool(lbool) = constant(cx, left, follow) {
if l == b {
Some(ConstantBool(b))
} else {
if let ConstantBool(rbool) = constant(cx, right, follow) {
Some(ConstantBool(rbool))
} else { None }
}
} else { None }
}