use rustc::lint::LateContext;
use rustc::middle::const_eval::lookup_const_by_id;
-use rustc::middle::def::PathResolution;
-use rustc::middle::def::Def;
+use rustc::middle::def::{Def, PathResolution};
use rustc_front::hir::*;
-use syntax::ptr::P;
-use std::cmp::PartialOrd;
use std::cmp::Ordering::{self, Greater, Less, Equal};
-use std::rc::Rc;
+use std::cmp::PartialOrd;
+use std::hash::{Hash, Hasher};
+use std::mem;
use std::ops::Deref;
- use syntax::ast::{LitIntType, Lit_};
- use syntax::ast::Sign::{self, Plus, Minus};
- use syntax::ast::{UintTy, FloatTy, StrStyle};
+use std::rc::Rc;
++use syntax::ast::{FloatTy, LitIntType, LitKind, StrStyle, UintTy};
+use syntax::ptr::P;
-use syntax::ast::LitKind;
-use syntax::ast::LitIntType;
-use syntax::ast::{UintTy, FloatTy, StrStyle};
-
--
-#[derive(PartialEq, Eq, Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
pub enum FloatWidth {
Fw32,
Fw64,
}
}
-#[derive(Copy, Eq, Debug, Clone, PartialEq)]
++#[derive(Copy, Eq, Debug, Clone, PartialEq, Hash)]
+ pub enum Sign {
+ Plus,
+ Minus,
+ }
+
/// a Lit_-like enum to fold constant `Expr`s into
-#[derive(Eq, Debug, Clone)]
+#[derive(Debug, Clone)]
pub enum Constant {
/// a String "abc"
Str(String, StrStyle),
(&Constant::Binary(ref l), &Constant::Binary(ref r)) => l == r,
(&Constant::Byte(l), &Constant::Byte(r)) => l == r,
(&Constant::Char(l), &Constant::Char(r)) => l == r,
- (&Constant::Int(lv, lty), &Constant::Int(rv, rty)) => {
- lv == rv && (is_negative(lty) & (lv != 0)) == (is_negative(rty) & (rv != 0))
+ (&Constant::Int(0, _, _), &Constant::Int(0, _, _)) => true,
+ (&Constant::Int(lv, _, lneg), &Constant::Int(rv, _, rneg)) => {
+ lv == rv && lneg == rneg
}
- (&Constant::Float(ref ls, lw), &Constant::Float(ref rs, rw)) => {
- use self::FloatWidth::*;
- if match (lw, rw) {
- (FwAny, _) | (_, FwAny) | (Fw32, Fw32) | (Fw64, Fw64) => true,
+ (&Constant::Float(ref ls, _), &Constant::Float(ref rs, _)) => {
+ // we want `Fw32 == FwAny` and `FwAny == Fw64`, by transitivity we must have
+ // `Fw32 == Fw64` so don’t compare them
+ match (ls.parse::<f64>(), rs.parse::<f64>()) {
+ (Ok(l), Ok(r)) => l.eq(&r),
_ => false,
- } {
- match (ls.parse::<f64>(), rs.parse::<f64>()) {
- (Ok(l), Ok(r)) => l.eq(&r),
- _ => false,
- }
- } else {
- false
}
}
(&Constant::Bool(l), &Constant::Bool(r)) => l == r,
}
}
- Constant::Int(u, t) => {
+impl Hash for Constant {
+ fn hash<H>(&self, state: &mut H) where H: Hasher {
+ match *self {
+ Constant::Str(ref s, ref k) => {
+ s.hash(state);
+ k.hash(state);
+ }
+ Constant::Binary(ref b) => {
+ b.hash(state);
+ }
+ Constant::Byte(u) => {
+ u.hash(state);
+ }
+ Constant::Char(c) => {
+ c.hash(state);
+ }
++ Constant::Int(u, _, t) => {
+ u.hash(state);
+ t.hash(state);
+ }
+ Constant::Float(ref f, _) => {
+ // don’t use the width here because of PartialEq implementation
+ if let Ok(f) = f.parse::<f64>() {
+ unsafe { mem::transmute::<f64, u64>(f) }.hash(state);
+ }
+ }
+ Constant::Bool(b) => {
+ b.hash(state);
+ }
+ Constant::Vec(ref v) | Constant::Tuple(ref v)=> {
+ v.hash(state);
+ }
+ Constant::Repeat(ref c, l) => {
+ c.hash(state);
+ l.hash(state);
+ }
+ }
+ }
+}
+
impl PartialOrd for Constant {
fn partial_cmp(&self, other: &Constant) -> Option<Ordering> {
match (self, other) {
}
(&Constant::Byte(ref l), &Constant::Byte(ref r)) => Some(l.cmp(r)),
(&Constant::Char(ref l), &Constant::Char(ref r)) => Some(l.cmp(r)),
- (&Constant::Int(ref lv, lty), &Constant::Int(ref rv, rty)) => {
- Some(match (is_negative(lty) && *lv != 0, is_negative(rty) && *rv != 0) {
- (true, true) => rv.cmp(lv),
- (false, false) => lv.cmp(rv),
- (true, false) => Less,
- (false, true) => Greater,
- })
- }
+ (&Constant::Int(0, _, _), &Constant::Int(0, _, _)) => Some(Equal),
+ (&Constant::Int(ref lv, _, Sign::Plus), &Constant::Int(ref rv, _, Sign::Plus)) => Some(lv.cmp(rv)),
+ (&Constant::Int(ref lv, _, Sign::Minus), &Constant::Int(ref rv, _, Sign::Minus)) => Some(rv.cmp(lv)),
+ (&Constant::Int(_, _, Sign::Minus), &Constant::Int(_, _, Sign::Plus)) => Some(Less),
+ (&Constant::Int(_, _, Sign::Plus), &Constant::Int(_, _, Sign::Minus)) => Some(Greater),
- (&Constant::Float(ref ls, lw), &Constant::Float(ref rs, rw)) => {
- use self::FloatWidth::*;
- if match (lw, rw) {
- (FwAny, _) | (_, FwAny) | (Fw32, Fw32) | (Fw64, Fw64) => true,
- _ => false,
- } {
- match (ls.parse::<f64>(), rs.parse::<f64>()) {
- (Ok(ref l), Ok(ref r)) => l.partial_cmp(r),
- _ => None,
- }
- } else {
- None
+ (&Constant::Float(ref ls, _), &Constant::Float(ref rs, _)) => {
+ match (ls.parse::<f64>(), rs.parse::<f64>()) {
+ (Ok(ref l), Ok(ref r)) => l.partial_cmp(r),
+ _ => None,
}
}
(&Constant::Bool(ref l), &Constant::Bool(ref r)) => Some(l.cmp(r)),
use self::Constant::*;
match o {
Bool(b) => Some(Bool(!b)),
- Int(::std::u64::MAX, SignedIntLit(_, Plus)) => None,
- Int(value, SignedIntLit(ity, Plus)) => Some(Int(value + 1, SignedIntLit(ity, Minus))),
- Int(0, SignedIntLit(ity, Minus)) => Some(Int(1, SignedIntLit(ity, Minus))),
- Int(value, SignedIntLit(ity, Minus)) => Some(Int(value - 1, SignedIntLit(ity, Plus))),
- Int(value, UnsignedIntLit(ity)) => {
- Int(::std::u64::MAX, LitIntType::Signed(_), Sign::Plus) => None,
- Int(value, LitIntType::Signed(ity), Sign::Plus) => Some(Int(value + 1, LitIntType::Signed(ity), Sign::Minus)),
++ Int(value, LitIntType::Signed(ity), Sign::Plus) if value != ::std::u64::MAX => Some(Int(value + 1, LitIntType::Signed(ity), Sign::Minus)),
+ Int(0, LitIntType::Signed(ity), Sign::Minus) => Some(Int(1, LitIntType::Signed(ity), Sign::Minus)),
+ Int(value, LitIntType::Signed(ity), Sign::Minus) => Some(Int(value - 1, LitIntType::Signed(ity), Sign::Plus)),
+ Int(value, LitIntType::Unsigned(ity), Sign::Plus) => {
let mask = match ity {
- UintTy::TyU8 => ::std::u8::MAX as u64,
- UintTy::TyU16 => ::std::u16::MAX as u64,
- UintTy::TyU32 => ::std::u32::MAX as u64,
- UintTy::TyU64 => ::std::u64::MAX,
- UintTy::TyUs => {
+ UintTy::U8 => ::std::u8::MAX as u64,
+ UintTy::U16 => ::std::u16::MAX as u64,
+ UintTy::U32 => ::std::u32::MAX as u64,
+ UintTy::U64 => ::std::u64::MAX,
+ UintTy::Us => {
return None;
} // refuse to guess
};
--- /dev/null
- use syntax::ast::Lit_;
- use syntax::ast;
+use reexport::*;
+use rustc::front::map::Node;
+use rustc::lint::{LintContext, LateContext, Level, Lint};
+use rustc::middle::def_id::DefId;
+use rustc::middle::{cstore, def, infer, ty, traits};
+use rustc::session::Session;
+use rustc_front::hir::*;
+use std::borrow::Cow;
+use std::mem;
+use std::ops::{Deref, DerefMut};
+use std::str::FromStr;
- if let Lit_::LitInt(v, _) = spanned.node {
++use syntax::ast::{LitKind, self};
+use syntax::codemap::{ExpnInfo, Span, ExpnFormat};
+use syntax::errors::DiagnosticBuilder;
+use syntax::ptr::P;
+
+mod hir;
+pub use self::hir::{SpanlessEq, SpanlessHash};
+pub type MethodArgs = HirVec<P<Expr>>;
+
+// module DefPaths for certain structs/enums we check for
+pub const BEGIN_UNWIND: [&'static str; 3] = ["std", "rt", "begin_unwind"];
+pub const BOX_NEW_PATH: [&'static str; 4] = ["std", "boxed", "Box", "new"];
+pub const BTREEMAP_ENTRY_PATH: [&'static str; 4] = ["collections", "btree", "map", "Entry"];
+pub const BTREEMAP_PATH: [&'static str; 4] = ["collections", "btree", "map", "BTreeMap"];
+pub const CLONE_PATH: [&'static str; 3] = ["clone", "Clone", "clone"];
+pub const CLONE_TRAIT_PATH: [&'static str; 2] = ["clone", "Clone"];
+pub const COW_PATH: [&'static str; 3] = ["collections", "borrow", "Cow"];
+pub const DEBUG_FMT_METHOD_PATH: [&'static str; 4] = ["std", "fmt", "Debug", "fmt"];
+pub const DEFAULT_TRAIT_PATH: [&'static str; 3] = ["core", "default", "Default"];
+pub const DROP_PATH: [&'static str; 3] = ["core", "mem", "drop"];
+pub const FMT_ARGUMENTV1_NEW_PATH: [&'static str; 4] = ["std", "fmt", "ArgumentV1", "new"];
+pub const HASHMAP_ENTRY_PATH: [&'static str; 5] = ["std", "collections", "hash", "map", "Entry"];
+pub const HASHMAP_PATH: [&'static str; 5] = ["std", "collections", "hash", "map", "HashMap"];
+pub const HASH_PATH: [&'static str; 2] = ["hash", "Hash"];
+pub const IO_PRINT_PATH: [&'static str; 3] = ["std", "io", "_print"];
+pub const LL_PATH: [&'static str; 3] = ["collections", "linked_list", "LinkedList"];
+pub const MUTEX_PATH: [&'static str; 4] = ["std", "sync", "mutex", "Mutex"];
+pub const OPEN_OPTIONS_PATH: [&'static str; 3] = ["std", "fs", "OpenOptions"];
+pub const OPTION_PATH: [&'static str; 3] = ["core", "option", "Option"];
+pub const REGEX_NEW_PATH: [&'static str; 3] = ["regex", "Regex", "new"];
+pub const RESULT_PATH: [&'static str; 3] = ["core", "result", "Result"];
+pub const STRING_PATH: [&'static str; 3] = ["collections", "string", "String"];
+pub const VEC_FROM_ELEM_PATH: [&'static str; 3] = ["std", "vec", "from_elem"];
+pub const VEC_PATH: [&'static str; 3] = ["collections", "vec", "Vec"];
+
+/// Produce a nested chain of if-lets and ifs from the patterns:
+///
+/// if_let_chain! {
+/// [
+/// let Some(y) = x,
+/// y.len() == 2,
+/// let Some(z) = y,
+/// ],
+/// {
+/// block
+/// }
+/// }
+///
+/// becomes
+///
+/// if let Some(y) = x {
+/// if y.len() == 2 {
+/// if let Some(z) = y {
+/// block
+/// }
+/// }
+/// }
+#[macro_export]
+macro_rules! if_let_chain {
+ ([let $pat:pat = $expr:expr, $($tt:tt)+], $block:block) => {
+ if let $pat = $expr {
+ if_let_chain!{ [$($tt)+], $block }
+ }
+ };
+ ([let $pat:pat = $expr:expr], $block:block) => {
+ if let $pat = $expr {
+ $block
+ }
+ };
+ ([$expr:expr, $($tt:tt)+], $block:block) => {
+ if $expr {
+ if_let_chain!{ [$($tt)+], $block }
+ }
+ };
+ ([$expr:expr], $block:block) => {
+ if $expr {
+ $block
+ }
+ };
+}
+
+/// Returns true if the two spans come from differing expansions (i.e. one is from a macro and one
+/// isn't).
+pub fn differing_macro_contexts(sp1: Span, sp2: Span) -> bool {
+ sp1.expn_id != sp2.expn_id
+}
+/// Returns true if this `expn_info` was expanded by any macro.
+pub fn in_macro<T: LintContext>(cx: &T, span: Span) -> bool {
+ cx.sess().codemap().with_expn_info(span.expn_id, |info| info.is_some())
+}
+
+/// Returns true if the macro that expanded the crate was outside of the current crate or was a
+/// compiler plugin.
+pub fn in_external_macro<T: LintContext>(cx: &T, span: Span) -> bool {
+ /// Invokes in_macro with the expansion info of the given span slightly heavy, try to use this
+ /// after other checks have already happened.
+ fn in_macro_ext<T: LintContext>(cx: &T, opt_info: Option<&ExpnInfo>) -> bool {
+ // no ExpnInfo = no macro
+ opt_info.map_or(false, |info| {
+ if let ExpnFormat::MacroAttribute(..) = info.callee.format {
+ // these are all plugins
+ return true;
+ }
+ // no span for the callee = external macro
+ info.callee.span.map_or(true, |span| {
+ // no snippet = external macro or compiler-builtin expansion
+ cx.sess().codemap().span_to_snippet(span).ok().map_or(true, |code| !code.starts_with("macro_rules"))
+ })
+ })
+ }
+
+ cx.sess().codemap().with_expn_info(span.expn_id, |info| in_macro_ext(cx, info))
+}
+
+/// Check if a `DefId`'s path matches the given absolute type path usage.
+///
+/// # Examples
+/// ```
+/// match_def_path(cx, id, &["core", "option", "Option"])
+/// ```
+pub fn match_def_path(cx: &LateContext, def_id: DefId, path: &[&str]) -> bool {
+ cx.tcx.with_path(def_id, |iter| {
+ iter.zip(path)
+ .all(|(nm, p)| nm.name().as_str() == *p)
+ })
+}
+
+/// Check if type is struct or enum type with given def path.
+pub fn match_type(cx: &LateContext, ty: ty::Ty, path: &[&str]) -> bool {
+ match ty.sty {
+ ty::TyEnum(ref adt, _) | ty::TyStruct(ref adt, _) => match_def_path(cx, adt.did, path),
+ _ => false,
+ }
+}
+
+/// Check if the method call given in `expr` belongs to given type.
+pub fn match_impl_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool {
+ let method_call = ty::MethodCall::expr(expr.id);
+
+ let trt_id = cx.tcx
+ .tables
+ .borrow()
+ .method_map
+ .get(&method_call)
+ .and_then(|callee| cx.tcx.impl_of_method(callee.def_id));
+ if let Some(trt_id) = trt_id {
+ match_def_path(cx, trt_id, path)
+ } else {
+ false
+ }
+}
+
+/// Check if the method call given in `expr` belongs to given trait.
+pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool {
+ let method_call = ty::MethodCall::expr(expr.id);
+
+ let trt_id = cx.tcx
+ .tables
+ .borrow()
+ .method_map
+ .get(&method_call)
+ .and_then(|callee| cx.tcx.trait_of_item(callee.def_id));
+ if let Some(trt_id) = trt_id {
+ match_def_path(cx, trt_id, path)
+ } else {
+ false
+ }
+}
+
+/// Match a `Path` against a slice of segment string literals.
+///
+/// # Examples
+/// ```
+/// match_path(path, &["std", "rt", "begin_unwind"])
+/// ```
+pub fn match_path(path: &Path, segments: &[&str]) -> bool {
+ path.segments.iter().rev().zip(segments.iter().rev()).all(|(a, b)| a.identifier.name.as_str() == *b)
+}
+
+/// Match a `Path` against a slice of segment string literals, e.g.
+///
+/// # Examples
+/// ```
+/// match_path(path, &["std", "rt", "begin_unwind"])
+/// ```
+pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
+ path.segments.iter().rev().zip(segments.iter().rev()).all(|(a, b)| a.identifier.name.as_str() == *b)
+}
+
+/// Get the definition associated to a path.
+/// TODO: investigate if there is something more efficient for that.
+pub fn path_to_def(cx: &LateContext, path: &[&str]) -> Option<cstore::DefLike> {
+ let cstore = &cx.tcx.sess.cstore;
+
+ let crates = cstore.crates();
+ let krate = crates.iter().find(|&&krate| cstore.crate_name(krate) == path[0]);
+ if let Some(krate) = krate {
+ let mut items = cstore.crate_top_level_items(*krate);
+ let mut path_it = path.iter().skip(1).peekable();
+
+ loop {
+ let segment = match path_it.next() {
+ Some(segment) => segment,
+ None => return None,
+ };
+
+ for item in &mem::replace(&mut items, vec![]) {
+ if item.name.as_str() == *segment {
+ if path_it.peek().is_none() {
+ return Some(item.def);
+ }
+
+ let def_id = match item.def {
+ cstore::DefLike::DlDef(def) => def.def_id(),
+ cstore::DefLike::DlImpl(def_id) => def_id,
+ _ => panic!("Unexpected {:?}", item.def),
+ };
+
+ items = cstore.item_children(def_id);
+ break;
+ }
+ }
+ }
+ } else {
+ None
+ }
+}
+
+/// Convenience function to get the `DefId` of a trait by path.
+pub fn get_trait_def_id(cx: &LateContext, path: &[&str]) -> Option<DefId> {
+ let def = match path_to_def(cx, path) {
+ Some(def) => def,
+ None => return None,
+ };
+
+ match def {
+ cstore::DlDef(def::Def::Trait(trait_id)) => Some(trait_id),
+ _ => None,
+ }
+}
+
+/// Check whether a type implements a trait.
+/// See also `get_trait_def_id`.
+pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, trait_id: DefId,
+ ty_params: Option<Vec<ty::Ty<'tcx>>>)
+ -> bool {
+ cx.tcx.populate_implementations_for_trait_if_necessary(trait_id);
+
+ let infcx = infer::new_infer_ctxt(cx.tcx, &cx.tcx.tables, None);
+ let obligation = traits::predicate_for_trait_def(cx.tcx,
+ traits::ObligationCause::dummy(),
+ trait_id,
+ 0,
+ ty,
+ ty_params.unwrap_or_default());
+
+ traits::SelectionContext::new(&infcx).evaluate_obligation_conservatively(&obligation)
+}
+
+/// Match an `Expr` against a chain of methods, and return the matched `Expr`s.
+///
+/// For example, if `expr` represents the `.baz()` in `foo.bar().baz()`,
+/// `matched_method_chain(expr, &["bar", "baz"])` will return a `Vec` containing the `Expr`s for
+/// `.bar()` and `.baz()`
+pub fn method_chain_args<'a>(expr: &'a Expr, methods: &[&str]) -> Option<Vec<&'a MethodArgs>> {
+ let mut current = expr;
+ let mut matched = Vec::with_capacity(methods.len());
+ for method_name in methods.iter().rev() {
+ // method chains are stored last -> first
+ if let ExprMethodCall(ref name, _, ref args) = current.node {
+ if name.node.as_str() == *method_name {
+ matched.push(args); // build up `matched` backwards
+ current = &args[0] // go to parent expression
+ } else {
+ return None;
+ }
+ } else {
+ return None;
+ }
+ }
+ matched.reverse(); // reverse `matched`, so that it is in the same order as `methods`
+ Some(matched)
+}
+
+
+/// Get the name of the item the expression is in, if available.
+pub fn get_item_name(cx: &LateContext, expr: &Expr) -> Option<Name> {
+ let parent_id = cx.tcx.map.get_parent(expr.id);
+ match cx.tcx.map.find(parent_id) {
+ Some(Node::NodeItem(&Item{ ref name, .. })) |
+ Some(Node::NodeTraitItem(&TraitItem{ ref name, .. })) |
+ Some(Node::NodeImplItem(&ImplItem{ ref name, .. })) => Some(*name),
+ _ => None,
+ }
+}
+
+/// Checks if a `let` decl is from a `for` loop desugaring.
+pub fn is_from_for_desugar(decl: &Decl) -> bool {
+ if_let_chain! {
+ [
+ let DeclLocal(ref loc) = decl.node,
+ let Some(ref expr) = loc.init,
+ let ExprMatch(_, _, MatchSource::ForLoopDesugar) = expr.node
+ ],
+ { return true; }
+ };
+ false
+}
+
+
+/// Convert a span to a code snippet if available, otherwise use default.
+///
+/// # Example
+/// ```
+/// snippet(cx, expr.span, "..")
+/// ```
+pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
+ cx.sess().codemap().span_to_snippet(span).map(From::from).unwrap_or_else(|_| Cow::Borrowed(default))
+}
+
+/// Convert a span to a code snippet. Returns `None` if not available.
+pub fn snippet_opt<T: LintContext>(cx: &T, span: Span) -> Option<String> {
+ cx.sess().codemap().span_to_snippet(span).ok()
+}
+
+/// Convert a span (from a block) to a code snippet if available, otherwise use default.
+/// This trims the code of indentation, except for the first line. Use it for blocks or block-like
+/// things which need to be printed as such.
+///
+/// # Example
+/// ```
+/// snippet(cx, expr.span, "..")
+/// ```
+pub fn snippet_block<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
+ let snip = snippet(cx, span, default);
+ trim_multiline(snip, true)
+}
+
+/// Like `snippet_block`, but add braces if the expr is not an `ExprBlock`.
+/// Also takes an `Option<String>` which can be put inside the braces.
+pub fn expr_block<'a, T: LintContext>(cx: &T, expr: &Expr, option: Option<String>, default: &'a str) -> Cow<'a, str> {
+ let code = snippet_block(cx, expr.span, default);
+ let string = option.unwrap_or_default();
+ if let ExprBlock(_) = expr.node {
+ Cow::Owned(format!("{}{}", code, string))
+ } else if string.is_empty() {
+ Cow::Owned(format!("{{ {} }}", code))
+ } else {
+ Cow::Owned(format!("{{\n{};\n{}\n}}", code, string))
+ }
+}
+
+/// Trim indentation from a multiline string with possibility of ignoring the first line.
+pub fn trim_multiline(s: Cow<str>, ignore_first: bool) -> Cow<str> {
+ let s_space = trim_multiline_inner(s, ignore_first, ' ');
+ let s_tab = trim_multiline_inner(s_space, ignore_first, '\t');
+ trim_multiline_inner(s_tab, ignore_first, ' ')
+}
+
+fn trim_multiline_inner(s: Cow<str>, ignore_first: bool, ch: char) -> Cow<str> {
+ let x = s.lines()
+ .skip(ignore_first as usize)
+ .filter_map(|l| {
+ if l.len() > 0 {
+ // ignore empty lines
+ Some(l.char_indices()
+ .find(|&(_, x)| x != ch)
+ .unwrap_or((l.len(), ch))
+ .0)
+ } else {
+ None
+ }
+ })
+ .min()
+ .unwrap_or(0);
+ if x > 0 {
+ Cow::Owned(s.lines()
+ .enumerate()
+ .map(|(i, l)| {
+ if (ignore_first && i == 0) || l.len() == 0 {
+ l
+ } else {
+ l.split_at(x).1
+ }
+ })
+ .collect::<Vec<_>>()
+ .join("\n"))
+ } else {
+ s
+ }
+}
+
+/// Get a parent expressions if any – this is useful to constrain a lint.
+pub fn get_parent_expr<'c>(cx: &'c LateContext, e: &Expr) -> Option<&'c Expr> {
+ let map = &cx.tcx.map;
+ let node_id: NodeId = e.id;
+ let parent_id: NodeId = map.get_parent_node(node_id);
+ if node_id == parent_id {
+ return None;
+ }
+ map.find(parent_id).and_then(|node| {
+ if let Node::NodeExpr(parent) = node {
+ Some(parent)
+ } else {
+ None
+ }
+ })
+}
+
+pub fn get_enclosing_block<'c>(cx: &'c LateContext, node: NodeId) -> Option<&'c Block> {
+ let map = &cx.tcx.map;
+ let enclosing_node = map.get_enclosing_scope(node)
+ .and_then(|enclosing_id| map.find(enclosing_id));
+ if let Some(node) = enclosing_node {
+ match node {
+ Node::NodeBlock(ref block) => Some(block),
+ Node::NodeItem(&Item{ node: ItemFn(_, _, _, _, _, ref block), .. }) => Some(block),
+ _ => None,
+ }
+ } else {
+ None
+ }
+}
+
+pub struct DiagnosticWrapper<'a>(pub DiagnosticBuilder<'a>);
+
+impl<'a> Drop for DiagnosticWrapper<'a> {
+ fn drop(&mut self) {
+ self.0.emit();
+ }
+}
+
+impl<'a> DerefMut for DiagnosticWrapper<'a> {
+ fn deref_mut(&mut self) -> &mut DiagnosticBuilder<'a> {
+ &mut self.0
+ }
+}
+
+impl<'a> Deref for DiagnosticWrapper<'a> {
+ type Target = DiagnosticBuilder<'a>;
+ fn deref(&self) -> &DiagnosticBuilder<'a> {
+ &self.0
+ }
+}
+
+pub fn span_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str) -> DiagnosticWrapper<'a> {
+ let mut db = cx.struct_span_lint(lint, sp, msg);
+ if cx.current_level(lint) != Level::Allow {
+ db.fileline_help(sp,
+ &format!("for further information visit https://github.com/Manishearth/rust-clippy/wiki#{}",
+ lint.name_lower()));
+ }
+ DiagnosticWrapper(db)
+}
+
+pub fn span_help_and_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, help: &str)
+ -> DiagnosticWrapper<'a> {
+ let mut db = cx.struct_span_lint(lint, span, msg);
+ if cx.current_level(lint) != Level::Allow {
+ db.fileline_help(span,
+ &format!("{}\nfor further information visit \
+ https://github.com/Manishearth/rust-clippy/wiki#{}",
+ help,
+ lint.name_lower()));
+ }
+ DiagnosticWrapper(db)
+}
+
+pub fn span_note_and_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, note_span: Span,
+ note: &str)
+ -> DiagnosticWrapper<'a> {
+ let mut db = cx.struct_span_lint(lint, span, msg);
+ if cx.current_level(lint) != Level::Allow {
+ if note_span == span {
+ db.fileline_note(note_span, note);
+ } else {
+ db.span_note(note_span, note);
+ }
+ db.fileline_help(span,
+ &format!("for further information visit https://github.com/Manishearth/rust-clippy/wiki#{}",
+ lint.name_lower()));
+ }
+ DiagnosticWrapper(db)
+}
+
+pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
+ -> DiagnosticWrapper<'a>
+ where F: FnOnce(&mut DiagnosticWrapper)
+{
+ let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, sp, msg));
+ if cx.current_level(lint) != Level::Allow {
+ f(&mut db);
+ db.fileline_help(sp,
+ &format!("for further information visit https://github.com/Manishearth/rust-clippy/wiki#{}",
+ lint.name_lower()));
+ }
+ db
+}
+
+/// Return the base type for references and raw pointers.
+pub fn walk_ptrs_ty(ty: ty::Ty) -> ty::Ty {
+ match ty.sty {
+ ty::TyRef(_, ref tm) | ty::TyRawPtr(ref tm) => walk_ptrs_ty(tm.ty),
+ _ => ty,
+ }
+}
+
+/// Return the base type for references and raw pointers, and count reference depth.
+pub fn walk_ptrs_ty_depth(ty: ty::Ty) -> (ty::Ty, usize) {
+ fn inner(ty: ty::Ty, depth: usize) -> (ty::Ty, usize) {
+ match ty.sty {
+ ty::TyRef(_, ref tm) | ty::TyRawPtr(ref tm) => inner(tm.ty, depth + 1),
+ _ => (ty, depth),
+ }
+ }
+ inner(ty, 0)
+}
+
+/// Check whether the given expression is a constant literal of the given value.
+pub fn is_integer_literal(expr: &Expr, value: u64) -> bool {
+ // FIXME: use constant folding
+ if let ExprLit(ref spanned) = expr.node {
- if let ast::MetaNameValue(ref key, ref value) = attr.value.node {
++ if let LitKind::Int(v, _) = spanned.node {
+ return v == value;
+ }
+ }
+ false
+}
+
+pub fn is_adjusted(cx: &LateContext, e: &Expr) -> bool {
+ cx.tcx.tables.borrow().adjustments.get(&e.id).is_some()
+}
+
+pub struct LimitStack {
+ stack: Vec<u64>,
+}
+
+impl Drop for LimitStack {
+ fn drop(&mut self) {
+ assert_eq!(self.stack.len(), 1);
+ }
+}
+
+impl LimitStack {
+ pub fn new(limit: u64) -> LimitStack {
+ LimitStack { stack: vec![limit] }
+ }
+ pub fn limit(&self) -> u64 {
+ *self.stack.last().expect("there should always be a value in the stack")
+ }
+ pub fn push_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
+ let stack = &mut self.stack;
+ parse_attrs(sess, attrs, name, |val| stack.push(val));
+ }
+ pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
+ let stack = &mut self.stack;
+ parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
+ }
+}
+
+fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'static str, mut f: F) {
+ for attr in attrs {
+ let attr = &attr.node;
+ if attr.is_sugared_doc {
+ continue;
+ }
- if let Lit_::LitStr(ref s, _) = value.node {
++ if let ast::MetaItemKind::NameValue(ref key, ref value) = attr.value.node {
+ if *key == name {
++ if let LitKind::Str(ref s, _) = value.node {
+ if let Ok(value) = FromStr::from_str(s) {
+ f(value)
+ } else {
+ sess.span_err(value.span, "not a number");
+ }
+ } else {
+ unreachable!()
+ }
+ }
+ }
+ }
+}
+
+/// Return the pre-expansion span if is this comes from an expansion of the macro `name`.
+pub fn is_expn_of(cx: &LateContext, mut span: Span, name: &str) -> Option<Span> {
+ loop {
+ let span_name_span = cx.tcx.sess.codemap().with_expn_info(span.expn_id, |expn| {
+ expn.map(|ei| {
+ (ei.callee.name(), ei.call_site)
+ })
+ });
+
+ match span_name_span {
+ Some((mac_name, new_span)) if mac_name.as_str() == name => return Some(new_span),
+ None => return None,
+ Some((_, new_span)) => span = new_span,
+ }
+ }
+}
projects / rust.git / commitdiff