rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Rollup merge of #48939 - wesleywiser:incr_query_wf_checking, r=michaelwoerister

Browse Source 
Querify WF-checking so it can be cached

r? @michaelwoerister
This commit is contained in:
kennytm
2018-03-22 17:51:19 +08:00
parent d67084215d b418b7ba0f
commit b7ee149c47
5 changed files with 593 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/librustc/dep_graph/dep_node.rs
View File

@@ -579,6 +579,9 @@ define_dep_nodes!( <'tcx>
[] GetPanicStrategy(CrateNum),
[] IsNoBuiltins(CrateNum),
[] ImplDefaultness(DefId),
[] CheckItemWellFormed(DefId),
[] CheckTraitItemWellFormed(DefId),
[] CheckImplItemWellFormed(DefId),
[] ReachableNonGenerics(CrateNum),
[] NativeLibraries(CrateNum),
[] PluginRegistrarFn(CrateNum),

4
src/librustc/ty/maps/mod.rs
View File

@@ -299,6 +299,10 @@ define_maps! { <'tcx>
[] fn impl_defaultness: ImplDefaultness(DefId) -> hir::Defaultness,
[] fn check_item_well_formed: CheckItemWellFormed(DefId) -> (),
[] fn check_trait_item_well_formed: CheckTraitItemWellFormed(DefId) -> (),
[] fn check_impl_item_well_formed: CheckImplItemWellFormed(DefId) -> (),
// The DefIds of all non-generic functions and statics in the given crate
// that can be reached from outside the crate.
//

3
src/librustc/ty/maps/plumbing.rs
View File

@@ -871,6 +871,9 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>,
DepKind::GetPanicStrategy => { force!(panic_strategy, krate!()); }
DepKind::IsNoBuiltins => { force!(is_no_builtins, krate!()); }
DepKind::ImplDefaultness => { force!(impl_defaultness, def_id!()); }
DepKind::CheckItemWellFormed => { force!(check_item_well_formed, def_id!()); }
DepKind::CheckTraitItemWellFormed => { force!(check_trait_item_well_formed, def_id!()); }
DepKind::CheckImplItemWellFormed => { force!(check_impl_item_well_formed, def_id!()); }
DepKind::ReachableNonGenerics => { force!(reachable_non_generics, krate!()); }
DepKind::NativeLibraries => { force!(native_libraries, krate!()); }
DepKind::PluginRegistrarFn => { force!(plugin_registrar_fn, krate!()); }

15
src/librustc_typeck/check/mod.rs
View File

@@ -718,6 +718,18 @@ fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum
})?)
}
fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
wfcheck::check_item_well_formed(tcx, def_id);
}
fn check_trait_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
wfcheck::check_trait_item(tcx, def_id);
}
fn check_impl_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
wfcheck::check_impl_item(tcx, def_id);
}
pub fn provide(providers: &mut Providers) {
*providers = Providers {
typeck_item_bodies,
@@ -725,6 +737,9 @@ pub fn provide(providers: &mut Providers) {
has_typeck_tables,
adt_destructor,
used_trait_imports,
check_item_well_formed,
check_trait_item_well_formed,
check_impl_item_well_formed,
..*providers
};
}

280
src/librustc_typeck/check/wfcheck.rs
View File

@@ -26,17 +26,11 @@ use errors::{DiagnosticBuilder, DiagnosticId};
use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
use rustc::hir;
pub struct CheckTypeWellFormedVisitor<'a, 'tcx:'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
code: ObligationCauseCode<'tcx>,
}
/// Helper type of a temporary returned by .for_item(...).
/// Necessary because we can't write the following bound:
/// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(FnCtxt<'b, 'gcx, 'tcx>).
struct CheckWfFcxBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
inherited: super::InheritedBuilder<'a, 'gcx, 'tcx>,
code: ObligationCauseCode<'gcx>,
id: ast::NodeId,
span: Span,
param_env: ty::ParamEnv<'tcx>,
@@ -45,49 +39,38 @@ struct CheckWfFcxBuilder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
impl<'a, 'gcx, 'tcx> CheckWfFcxBuilder<'a, 'gcx, 'tcx> {
fn with_fcx<F>(&'tcx mut self, f: F) where
F: for<'b> FnOnce(&FnCtxt<'b, 'gcx, 'tcx>,
&mut CheckTypeWellFormedVisitor<'b, 'gcx>) -> Vec<Ty<'tcx>>
TyCtxt<'b, 'gcx, 'gcx>) -> Vec<Ty<'tcx>>
{
let code = self.code.clone();
let id = self.id;
let span = self.span;
let param_env = self.param_env;
self.inherited.enter(|inh| {
let fcx = FnCtxt::new(&inh, param_env, id);
let wf_tys = f(&fcx, &mut CheckTypeWellFormedVisitor {
tcx: fcx.tcx.global_tcx(),
code,
});
let wf_tys = f(&fcx, fcx.tcx.global_tcx());
fcx.select_all_obligations_or_error();
fcx.regionck_item(id, span, &wf_tys);
});
}
}
impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
pub fn new(tcx: TyCtxt<'a, 'gcx, 'gcx>)
-> CheckTypeWellFormedVisitor<'a, 'gcx> {
CheckTypeWellFormedVisitor {
tcx,
code: ObligationCauseCode::MiscObligation
}
}
/// Checks that the field types (in a struct def'n) or argument types (in an enum def'n) are
/// well-formed, meaning that they do not require any constraints not declared in the struct
/// definition itself. For example, this definition would be illegal:
///
/// struct Ref<'a, T> { x: &'a T }
///
/// because the type did not declare that `T:'a`.
///
/// We do this check as a pre-pass before checking fn bodies because if these constraints are
/// not included it frequently leads to confusing errors in fn bodies. So it's better to check
/// the types first.
pub fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
let item = tcx.hir.expect_item(node_id);
/// Checks that the field types (in a struct def'n) or argument types (in an enum def'n) are
/// well-formed, meaning that they do not require any constraints not declared in the struct
/// definition itself. For example, this definition would be illegal:
///
/// struct Ref<'a, T> { x: &'a T }
///
/// because the type did not declare that `T:'a`.
///
/// We do this check as a pre-pass before checking fn bodies because if these constraints are
/// not included it frequently leads to confusing errors in fn bodies. So it's better to check
/// the types first.
fn check_item_well_formed(&mut self, item: &hir::Item) {
let tcx = self.tcx;
debug!("check_item_well_formed(it.id={}, it.name={})",
item.id,
tcx.item_path_str(tcx.hir.local_def_id(item.id)));
tcx.item_path_str(def_id));
match item.node {
// Right now we check that every default trait implementation
@@ -114,7 +97,7 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
tcx.sess.span_err(item.span, "impls of auto traits cannot be default");
}
if polarity == hir::ImplPolarity::Positive {
self.check_impl(item, self_ty, trait_ref);
check_impl(tcx, item, self_ty, trait_ref);
} else {
// FIXME(#27579) what amount of WF checking do we need for neg impls?
if trait_ref.is_some() && !is_auto {
@@ -125,48 +108,70 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
}
}
hir::ItemFn(..) => {
self.check_item_fn(item);
check_item_fn(tcx, item);
}
hir::ItemStatic(..) => {
self.check_item_type(item);
check_item_type(tcx, item);
}
hir::ItemConst(..) => {
self.check_item_type(item);
check_item_type(tcx, item);
}
hir::ItemStruct(ref struct_def, ref ast_generics) => {
self.check_type_defn(item, false, |fcx| {
check_type_defn(tcx, item, false, |fcx| {
vec![fcx.non_enum_variant(struct_def)]
});
self.check_variances_for_type_defn(item, ast_generics);
check_variances_for_type_defn(tcx, item, ast_generics);
}
hir::ItemUnion(ref struct_def, ref ast_generics) => {
self.check_type_defn(item, true, |fcx| {
check_type_defn(tcx, item, true, |fcx| {
vec![fcx.non_enum_variant(struct_def)]
});
self.check_variances_for_type_defn(item, ast_generics);
check_variances_for_type_defn(tcx, item, ast_generics);
}
hir::ItemEnum(ref enum_def, ref ast_generics) => {
self.check_type_defn(item, true, |fcx| {
check_type_defn(tcx, item, true, |fcx| {
fcx.enum_variants(enum_def)
});
self.check_variances_for_type_defn(item, ast_generics);
check_variances_for_type_defn(tcx, item, ast_generics);
}
hir::ItemTrait(..) => {
self.check_trait(item);
check_trait(tcx, item);
}
_ => {}
}
}
}
fn check_associated_item(&mut self,
pub fn check_trait_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
let trait_item = tcx.hir.expect_trait_item(node_id);
let method_sig = match trait_item.node {
hir::TraitItemKind::Method(ref sig, _) => Some(sig),
_ => None
};
check_associated_item(tcx, trait_item.id, trait_item.span, method_sig);
}
pub fn check_impl_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) {
let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
let impl_item = tcx.hir.expect_impl_item(node_id);
let method_sig = match impl_item.node {
hir::ImplItemKind::Method(ref sig, _) => Some(sig),
_ => None
};
check_associated_item(tcx, impl_item.id, impl_item.span, method_sig);
}
fn check_associated_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
item_id: ast::NodeId,
span: Span,
sig_if_method: Option<&hir::MethodSig>) {
let code = self.code.clone();
self.for_id(item_id, span).with_fcx(|fcx, this| {
let code = ObligationCauseCode::MiscObligation;
for_id(tcx, item_id, span).with_fcx(|fcx, tcx| {
let item = fcx.tcx.associated_item(fcx.tcx.hir.local_def_id(item_id));
let (mut implied_bounds, self_ty) = match item.container {
@@ -185,10 +190,10 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
reject_shadowing_type_parameters(fcx.tcx, item.def_id);
let sig = fcx.tcx.fn_sig(item.def_id);
let sig = fcx.normalize_associated_types_in(span, &sig);
this.check_fn_or_method(fcx, span, sig,
check_fn_or_method(tcx, fcx, span, sig,
item.def_id, &mut implied_bounds);
let sig_if_method = sig_if_method.expect("bad signature for method");
this.check_method_receiver(fcx, sig_if_method, &item, self_ty);
check_method_receiver(fcx, sig_if_method, &item, self_ty);
}
ty::AssociatedKind::Type => {
if item.defaultness.has_value() {
@@ -201,30 +206,30 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
implied_bounds
})
}
}
fn for_item<'tcx>(&self, item: &hir::Item)
fn for_item<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, item: &hir::Item)
-> CheckWfFcxBuilder<'a, 'gcx, 'tcx> {
self.for_id(item.id, item.span)
}
for_id(tcx, item.id, item.span)
}
fn for_id<'tcx>(&self, id: ast::NodeId, span: Span)
fn for_id<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, id: ast::NodeId, span: Span)
-> CheckWfFcxBuilder<'a, 'gcx, 'tcx> {
let def_id = self.tcx.hir.local_def_id(id);
let def_id = tcx.hir.local_def_id(id);
CheckWfFcxBuilder {
inherited: Inherited::build(self.tcx, def_id),
code: self.code.clone(),
inherited: Inherited::build(tcx, def_id),
id,
span,
param_env: self.tcx.param_env(def_id),
}
param_env: tcx.param_env(def_id),
}
}
/// In a type definition, we check that to ensure that the types of the fields are well-formed.
fn check_type_defn<F>(&mut self, item: &hir::Item, all_sized: bool, mut lookup_fields: F)
where F: for<'fcx, 'tcx> FnMut(&FnCtxt<'fcx, 'gcx, 'tcx>) -> Vec<AdtVariant<'tcx>>
{
self.for_item(item).with_fcx(|fcx, this| {
/// In a type definition, we check that to ensure that the types of the fields are well-formed.
fn check_type_defn<'a, 'tcx, F>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
item: &hir::Item, all_sized: bool, mut lookup_fields: F)
where F: for<'fcx, 'gcx, 'tcx2> FnMut(&FnCtxt<'fcx, 'gcx, 'tcx2>) -> Vec<AdtVariant<'tcx2>>
{
for_item(tcx, item).with_fcx(|fcx, fcx_tcx| {
let variants = lookup_fields(fcx);
let def_id = fcx.tcx.hir.local_def_id(item.id);
let packed = fcx.tcx.adt_def(def_id).repr.packed();
@@ -235,11 +240,11 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
let needs_drop_copy = || {
packed && {
let ty = variant.fields.last().unwrap().ty;
let ty = fcx.tcx.erase_regions(&ty).lift_to_tcx(this.tcx)
let ty = fcx.tcx.erase_regions(&ty).lift_to_tcx(fcx_tcx)
.unwrap_or_else(|| {
span_bug!(item.span, "inference variables in {:?}", ty)
});
ty.needs_drop(this.tcx, this.tcx.param_env(def_id))
ty.needs_drop(fcx_tcx, fcx_tcx.param_env(def_id))
}
};
let unsized_len = if
@@ -265,59 +270,60 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
// All field types must be well-formed.
for field in &variant.fields {
fcx.register_wf_obligation(field.ty, field.span, this.code.clone())
fcx.register_wf_obligation(field.ty, field.span,
ObligationCauseCode::MiscObligation)
}
}
self.check_where_clauses(fcx, item.span, def_id);
check_where_clauses(tcx, fcx, item.span, def_id);
vec![] // no implied bounds in a struct def'n
});
}
}
fn check_trait(&mut self, item: &hir::Item) {
let trait_def_id = self.tcx.hir.local_def_id(item.id);
self.for_item(item).with_fcx(|fcx, _| {
self.check_where_clauses(fcx, item.span, trait_def_id);
fn check_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item: &hir::Item) {
let trait_def_id = tcx.hir.local_def_id(item.id);
for_item(tcx, item).with_fcx(|fcx, _| {
check_where_clauses(tcx, fcx, item.span, trait_def_id);
vec![]
});
}
}
fn check_item_fn(&mut self, item: &hir::Item) {
self.for_item(item).with_fcx(|fcx, this| {
fn check_item_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item: &hir::Item) {
for_item(tcx, item).with_fcx(|fcx, tcx| {
let def_id = fcx.tcx.hir.local_def_id(item.id);
let sig = fcx.tcx.fn_sig(def_id);
let sig = fcx.normalize_associated_types_in(item.span, &sig);
let mut implied_bounds = vec![];
this.check_fn_or_method(fcx, item.span, sig,
check_fn_or_method(tcx, fcx, item.span, sig,
def_id, &mut implied_bounds);
implied_bounds
})
}
}
fn check_item_type(&mut self,
fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
item: &hir::Item)
{
{
debug!("check_item_type: {:?}", item);
self.for_item(item).with_fcx(|fcx, this| {
for_item(tcx, item).with_fcx(|fcx, _this| {
let ty = fcx.tcx.type_of(fcx.tcx.hir.local_def_id(item.id));
let item_ty = fcx.normalize_associated_types_in(item.span, &ty);
fcx.register_wf_obligation(item_ty, item.span, this.code.clone());
fcx.register_wf_obligation(item_ty, item.span, ObligationCauseCode::MiscObligation);
vec![] // no implied bounds in a const etc
});
}
}
fn check_impl(&mut self,
fn check_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
item: &hir::Item,
ast_self_ty: &hir::Ty,
ast_trait_ref: &Option<hir::TraitRef>)
{
{
debug!("check_impl: {:?}", item);
self.for_item(item).with_fcx(|fcx, this| {
for_item(tcx, item).with_fcx(|fcx, tcx| {
let item_def_id = fcx.tcx.hir.local_def_id(item.id);
match *ast_trait_ref {
@@ -339,18 +345,19 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
None => {
let self_ty = fcx.tcx.type_of(item_def_id);
let self_ty = fcx.normalize_associated_types_in(item.span, &self_ty);
fcx.register_wf_obligation(self_ty, ast_self_ty.span, this.code.clone());
fcx.register_wf_obligation(self_ty, ast_self_ty.span,
ObligationCauseCode::MiscObligation);
}
}
this.check_where_clauses(fcx, item.span, item_def_id);
check_where_clauses(tcx, fcx, item.span, item_def_id);
fcx.impl_implied_bounds(item_def_id, item.span)
});
}
}
/// Checks where clauses and inline bounds that are declared on def_id.
fn check_where_clauses<'fcx, 'tcx>(&mut self,
/// Checks where clauses and inline bounds that are declared on def_id.
fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
span: Span,
def_id: DefId) {
@@ -360,7 +367,7 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
let mut predicates = fcx.tcx.predicates_of(def_id);
let mut substituted_predicates = Vec::new();
let generics = self.tcx.generics_of(def_id);
let generics = tcx.generics_of(def_id);
let is_our_default = |def: &ty::TypeParameterDef|
def.has_default && def.index >= generics.parent_count() as u32;
@@ -374,7 +381,8 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
// parameter includes another (e.g., <T, U = T>). In those cases, we can't
// be sure if it will error or not as user might always specify the other.
if !ty.needs_subst() {
fcx.register_wf_obligation(ty, fcx.tcx.def_span(d), self.code.clone());
fcx.register_wf_obligation(ty, fcx.tcx.def_span(d),
ObligationCauseCode::MiscObligation);
}
}
@@ -445,37 +453,36 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
for obligation in obligations {
fcx.register_predicate(obligation);
}
}
}
fn check_fn_or_method<'fcx, 'tcx>(&mut self,
fn check_fn_or_method<'a, 'fcx, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
span: Span,
sig: ty::PolyFnSig<'tcx>,
def_id: DefId,
implied_bounds: &mut Vec<Ty<'tcx>>)
{
{
let sig = fcx.normalize_associated_types_in(span, &sig);
let sig = fcx.tcx.liberate_late_bound_regions(def_id, &sig);
for input_ty in sig.inputs() {
fcx.register_wf_obligation(&input_ty, span, self.code.clone());
fcx.register_wf_obligation(&input_ty, span, ObligationCauseCode::MiscObligation);
}
implied_bounds.extend(sig.inputs());
fcx.register_wf_obligation(sig.output(), span, self.code.clone());
fcx.register_wf_obligation(sig.output(), span, ObligationCauseCode::MiscObligation);
// FIXME(#25759) return types should not be implied bounds
implied_bounds.push(sig.output());
self.check_where_clauses(fcx, span, def_id);
}
check_where_clauses(tcx, fcx, span, def_id);
}
fn check_method_receiver<'fcx, 'tcx>(&mut self,
fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
fn check_method_receiver<'fcx, 'gcx, 'tcx>(fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
method_sig: &hir::MethodSig,
method: &ty::AssociatedItem,
self_ty: Ty<'tcx>)
{
{
// check that the method has a valid receiver type, given the type `Self`
debug!("check_method_receiver({:?}, self_ty={:?})",
method, self_ty);
@@ -564,21 +571,21 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
}
}
}
}
}
fn check_variances_for_type_defn(&self,
fn check_variances_for_type_defn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
item: &hir::Item,
ast_generics: &hir::Generics)
{
let item_def_id = self.tcx.hir.local_def_id(item.id);
let ty = self.tcx.type_of(item_def_id);
if self.tcx.has_error_field(ty) {
{
let item_def_id = tcx.hir.local_def_id(item.id);
let ty = tcx.type_of(item_def_id);
if tcx.has_error_field(ty) {
return;
}
let ty_predicates = self.tcx.predicates_of(item_def_id);
let ty_predicates = tcx.predicates_of(item_def_id);
assert_eq!(ty_predicates.parent, None);
let variances = self.tcx.variances_of(item_def_id);
let variances = tcx.variances_of(item_def_id);
let mut constrained_parameters: FxHashSet<_> =
variances.iter().enumerate()
@@ -586,7 +593,7 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
.map(|(index, _)| Parameter(index as u32))
.collect();
identify_constrained_type_params(self.tcx,
identify_constrained_type_params(tcx,
ty_predicates.predicates.as_slice(),
None,
&mut constrained_parameters);
@@ -600,30 +607,29 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
hir::GenericParam::Lifetime(ref ld) => (ld.lifetime.span, ld.lifetime.name.name()),
hir::GenericParam::Type(ref tp) => (tp.span, tp.name),
};
self.report_bivariance(span, name);
}
report_bivariance(tcx, span, name);
}
}
fn report_bivariance(&self,
fn report_bivariance<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
span: Span,
param_name: ast::Name)
{
let mut err = error_392(self.tcx, span, param_name);
{
let mut err = error_392(tcx, span, param_name);
let suggested_marker_id = self.tcx.lang_items().phantom_data();
let suggested_marker_id = tcx.lang_items().phantom_data();
match suggested_marker_id {
Some(def_id) => {
err.help(
&format!("consider removing `{}` or using a marker such as `{}`",
param_name,
self.tcx.item_path_str(def_id)));
tcx.item_path_str(def_id)));
}
None => {
// no lang items, no help!
}
}
err.emit();
}
}
fn reject_shadowing_type_parameters(tcx: TyCtxt, def_id: DefId) {
@@ -648,6 +654,19 @@ fn reject_shadowing_type_parameters(tcx: TyCtxt, def_id: DefId) {
}
}
pub struct CheckTypeWellFormedVisitor<'a, 'tcx: 'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
}
impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
pub fn new(tcx: TyCtxt<'a, 'gcx, 'gcx>)
-> CheckTypeWellFormedVisitor<'a, 'gcx> {
CheckTypeWellFormedVisitor {
tcx,
}
}
}
impl<'a, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'a, 'tcx> {
fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'v> {
NestedVisitorMap::None
@@ -655,27 +674,22 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &hir::Item) {
debug!("visit_item: {:?}", i);
self.check_item_well_formed(i);
let def_id = self.tcx.hir.local_def_id(i.id);
ty::maps::queries::check_item_well_formed::ensure(self.tcx, def_id);
intravisit::walk_item(self, i);
}
fn visit_trait_item(&mut self, trait_item: &'v hir::TraitItem) {
debug!("visit_trait_item: {:?}", trait_item);
let method_sig = match trait_item.node {
hir::TraitItemKind::Method(ref sig, _) => Some(sig),
_ => None
};
self.check_associated_item(trait_item.id, trait_item.span, method_sig);
let def_id = self.tcx.hir.local_def_id(trait_item.id);
ty::maps::queries::check_trait_item_well_formed::ensure(self.tcx, def_id);
intravisit::walk_trait_item(self, trait_item)
}
fn visit_impl_item(&mut self, impl_item: &'v hir::ImplItem) {
debug!("visit_impl_item: {:?}", impl_item);
let method_sig = match impl_item.node {
hir::ImplItemKind::Method(ref sig, _) => Some(sig),
_ => None
};
self.check_associated_item(impl_item.id, impl_item.span, method_sig);
let def_id = self.tcx.hir.local_def_id(impl_item.id);
ty::maps::queries::check_impl_item_well_formed::ensure(self.tcx, def_id);
intravisit::walk_impl_item(self, impl_item)
}
}