}
pub struct MissingDoc {
- /// Stack of IDs of struct definitions.
- struct_def_stack: Vec<ast::NodeId>,
-
- /// True if inside variant definition
- in_variant: bool,
-
/// Stack of whether #[doc(hidden)] is set
/// at each level which has lint attributes.
doc_hidden_stack: Vec<bool>,
impl MissingDoc {
pub fn new() -> MissingDoc {
MissingDoc {
- struct_def_stack: vec![],
- in_variant: false,
doc_hidden_stack: vec![false],
private_traits: HashSet::new(),
}
self.doc_hidden_stack.pop().expect("empty doc_hidden_stack");
}
- fn check_struct_def(&mut self,
- _: &LateContext,
- _: &hir::VariantData,
- _: ast::Name,
- _: &hir::Generics,
- item_id: ast::NodeId) {
- self.struct_def_stack.push(item_id);
- }
-
- fn check_struct_def_post(&mut self,
- _: &LateContext,
- _: &hir::VariantData,
- _: ast::Name,
- _: &hir::Generics,
- item_id: ast::NodeId) {
- let popped = self.struct_def_stack.pop().expect("empty struct_def_stack");
- assert!(popped == item_id);
- }
-
fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) {
self.check_missing_docs_attrs(cx, None, &krate.attrs, krate.span, "crate");
}
fn check_struct_field(&mut self, cx: &LateContext, sf: &hir::StructField) {
if !sf.is_positional() {
- if sf.vis == hir::Public || self.in_variant {
- let cur_struct_def = *self.struct_def_stack
- .last()
- .expect("empty struct_def_stack");
- self.check_missing_docs_attrs(cx,
- Some(cur_struct_def),
- &sf.attrs,
- sf.span,
- "a struct field")
- }
+ self.check_missing_docs_attrs(cx,
+ Some(sf.id),
+ &sf.attrs,
+ sf.span,
+ "a struct field")
}
}
&v.node.attrs,
v.span,
"a variant");
- assert!(!self.in_variant);
- self.in_variant = true;
- }
-
- fn check_variant_post(&mut self, _: &LateContext, _: &hir::Variant, _: &hir::Generics) {
- assert!(self.in_variant);
- self.in_variant = false;
}
}
if def.has_dtor(cx.tcx) {
return;
}
- let parameter_environment = cx.tcx.empty_parameter_environment();
- // FIXME (@jroesch) should probably inver this so that the parameter env still impls this
- // method
- if !ty.moves_by_default(cx.tcx, ¶meter_environment, item.span) {
+ let param_env = ty::ParamEnv::empty(Reveal::UserFacing);
+ if !ty.moves_by_default(cx.tcx, param_env, item.span) {
return;
}
- if parameter_environment.can_type_implement_copy(cx.tcx, ty, item.span).is_ok() {
+ if param_env.can_type_implement_copy(cx.tcx, ty, item.span).is_ok() {
cx.span_lint(MISSING_COPY_IMPLEMENTATIONS,
item.span,
"type could implement `Copy`; consider adding `impl \
-> bool {
use rustc::ty::adjustment::*;
- // Check for method calls and overloaded operators.
- let opt_m = cx.tables.method_map.get(&ty::MethodCall::expr(id)).cloned();
- if let Some(m) = opt_m {
- if method_call_refers_to_method(cx.tcx, method, m.def_id, m.substs, id) {
- return true;
- }
- }
+ // Ignore non-expressions.
+ let expr = if let hir_map::NodeExpr(e) = cx.tcx.hir.get(id) {
+ e
+ } else {
+ return false;
+ };
// Check for overloaded autoderef method calls.
- let opt_adj = cx.tables.adjustments.get(&id).cloned();
- if let Some(Adjustment { kind: Adjust::DerefRef { autoderefs, .. }, .. }) = opt_adj {
- for i in 0..autoderefs {
- let method_call = ty::MethodCall::autoderef(id, i as u32);
- if let Some(m) = cx.tables.method_map.get(&method_call).cloned() {
- if method_call_refers_to_method(cx.tcx, method, m.def_id, m.substs, id) {
- return true;
- }
+ let mut source = cx.tables.expr_ty(expr);
+ for adjustment in cx.tables.expr_adjustments(expr) {
+ if let Adjust::Deref(Some(deref)) = adjustment.kind {
+ let (def_id, substs) = deref.method_call(cx.tcx, source);
+ if method_call_refers_to_method(cx.tcx, method, def_id, substs, id) {
+ return true;
}
}
+ source = adjustment.target;
+ }
+
+ // Check for method calls and overloaded operators.
+ if cx.tables.is_method_call(expr) {
+ let def_id = cx.tables.type_dependent_defs[&id].def_id();
+ let substs = cx.tables.node_substs(id);
+ if method_call_refers_to_method(cx.tcx, method, def_id, substs, id) {
+ return true;
+ }
}
// Check for calls to methods via explicit paths (e.g. `T::method()`).
- match cx.tcx.hir.get(id) {
- hir_map::NodeExpr(&hir::Expr { node: hir::ExprCall(ref callee, _), .. }) => {
+ match expr.node {
+ hir::ExprCall(ref callee, _) => {
let def = if let hir::ExprPath(ref qpath) = callee.node {
cx.tables.qpath_def(qpath, callee.id)
} else {
};
match def {
Def::Method(def_id) => {
- let substs = cx.tables.node_id_item_substs(callee.id)
- .unwrap_or_else(|| cx.tcx.intern_substs(&[]));
+ let substs = cx.tables.node_substs(callee.id);
method_call_refers_to_method(
cx.tcx, method, def_id, substs, id)
}
traits::Obligation::new(traits::ObligationCause::misc(span, expr_id),
trait_ref.to_poly_trait_predicate());
- let param_env = tcx.parameter_environment(method.def_id);
- tcx.infer_ctxt(param_env, Reveal::UserFacing).enter(|infcx| {
+ let param_env = tcx.param_env(method.def_id);
+ tcx.infer_ctxt(param_env).enter(|infcx| {
let mut selcx = traits::SelectionContext::new(&infcx);
match selcx.select(&obligation) {
// The method comes from a `T: Trait` bound.
it.name);
cx.span_lint(PRIVATE_NO_MANGLE_FNS, it.span, &msg);
}
- if generics.is_parameterized() {
+ if generics.is_type_parameterized() {
cx.span_lint(NO_MANGLE_GENERIC_ITEMS,
it.span,
- "generic functions must be mangled");
+ "functions generic over types must be mangled");
}
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnionsWithDropFields {
fn check_item(&mut self, ctx: &LateContext, item: &hir::Item) {
if let hir::ItemUnion(ref vdata, _) = item.node {
- let param_env = &ctx.tcx.parameter_environment(ctx.tcx.hir.local_def_id(item.id));
+ let item_def_id = ctx.tcx.hir.local_def_id(item.id);
+ let param_env = ctx.tcx.param_env(item_def_id);
for field in vdata.fields() {
let field_ty = ctx.tcx.type_of(ctx.tcx.hir.local_def_id(field.id));
if field_ty.needs_drop(ctx.tcx, param_env) {