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_trait_where_clauses(fcx, item.span, trait_def_id);
+ self.check_where_clauses(fcx, item.span, trait_def_id);
vec![]
});
}
fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
span: Span,
def_id: DefId) {
- self.inner_check_where_clauses(fcx, span, def_id, false)
- }
-
- fn check_trait_where_clauses<'fcx, 'tcx>(&mut self,
- fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
- span: Span,
- def_id: DefId) {
- self.inner_check_where_clauses(fcx, span, def_id, true)
- }
-
- /// Checks where clauses and inline bounds that are declared on def_id.
- fn inner_check_where_clauses<'fcx, 'tcx>(&mut self,
- fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
- span: Span,
- def_id: DefId,
- is_trait: bool)
- {
use ty::subst::Subst;
use rustc::ty::TypeFoldable;
let mut substituted_predicates = Vec::new();
let generics = self.tcx.generics_of(def_id);
- let defaulted_params = generics.types.iter()
- .filter(|def| def.has_default &&
- def.index >= generics.parent_count() as u32);
- for param_def in defaulted_params {
- // Defaults must be well-formed.
- let d = param_def.def_id;
- fcx.register_wf_obligation(fcx.tcx.type_of(d), fcx.tcx.def_span(d), self.code.clone());
- // Check the clauses are well-formed when the param is substituted by it's default.
- // In trait definitions, the predicate `Self: Trait` is problematic.
- // Therefore we skip such predicates. This means we check less than we could.
- for pred in predicates.predicates.iter().filter(|p| !(is_trait && p.has_self_ty())) {
- let mut skip = true;
- let substs = ty::subst::Substs::for_item(fcx.tcx, def_id, |def, _| {
- // All regions are identity.
- fcx.tcx.mk_region(ty::ReEarlyBound(def.to_early_bound_region_data()))
- }, |def, _| {
- let identity_substs = fcx.tcx.mk_param_from_def(def);
- if def.index != param_def.index {
- identity_substs
- } else {
- let sized = fcx.tcx.lang_items().sized_trait();
- let pred_is_sized = match pred {
- ty::Predicate::Trait(p) => Some(p.def_id()) == sized,
- _ => false,
- };
- let default_ty = fcx.tcx.type_of(def.def_id);
- let default_is_self = match default_ty.sty {
- ty::TyParam(ref p) => p.is_self(),
- _ => false
- };
- // In trait defs, skip `Self: Sized` when `Self` is the default.
- if is_trait && pred_is_sized && default_is_self {
- identity_substs
- } else {
- skip = false;
- default_ty
- }
+ let is_our_default = |def: &ty::TypeParameterDef|
+ def.has_default && def.index >= generics.parent_count() as u32;
+
+ // Check that concrete defaults are well-formed. See test `type-check-defaults.rs`.
+ // For example this forbids the declaration:
+ // struct Foo<T = Vec<[u32]>> { .. }
+ // Here the default `Vec<[u32]>` is not WF because `[u32]: Sized` does not hold.
+ for d in generics.types.iter().cloned().filter(is_our_default).map(|p| p.def_id) {
+ let ty = fcx.tcx.type_of(d);
+ // ignore dependent defaults -- that is, where the default of one type
+ // 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());
+ }
+ }
+
+ // Check that trait predicates are WF when params are substituted by their defaults.
+ // We don't want to overly constrain the predicates that may be written but we want to
+ // catch cases where a default my never be applied such as `struct Foo<T: Copy = String>`.
+ // Therefore we check if a predicate which contains a single type param
+ // with a concrete default is WF with that default substituted.
+ // For more examples see tests `defaults-well-formedness.rs` and `type-check-defaults.rs`.
+ //
+ // First we build the defaulted substitution.
+ let substs = ty::subst::Substs::for_item(fcx.tcx, def_id, |def, _| {
+ // All regions are identity.
+ fcx.tcx.mk_region(ty::ReEarlyBound(def.to_early_bound_region_data()))
+ }, |def, _| {
+ // If the param has a default,
+ if is_our_default(def) {
+ let default_ty = fcx.tcx.type_of(def.def_id);
+ // and it's not a dependent default
+ if !default_ty.needs_subst() {
+ // then substitute with the default.
+ return default_ty;
}
- });
- if skip { continue; }
- substituted_predicates.push(match pred {
- // In trait predicates, substitute defaults only for the LHS.
- ty::Predicate::Trait(t_pred) => {
- let trait_ref = t_pred.map_bound(|t_pred| {
- let mut trait_subs = t_pred.trait_ref.substs.to_vec();
- trait_subs[0] = t_pred.self_ty().subst(fcx.tcx, substs).into();
- ty::TraitRef::new(t_pred.def_id(), fcx.tcx.intern_substs(&trait_subs))
- });
- ty::Predicate::Trait(trait_ref.to_poly_trait_predicate())
+ }
+ // Mark unwanted params as err.
+ fcx.tcx.types.err
+ });
+ // Now we build the substituted predicates.
+ for &pred in predicates.predicates.iter() {
+ struct CountParams { params: FxHashSet<u32> }
+ impl<'tcx> ty::fold::TypeVisitor<'tcx> for CountParams {
+ fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {
+ match t.sty {
+ ty::TyParam(p) => {
+ self.params.insert(p.idx);
+ t.super_visit_with(self)
+ }
+ _ => t.super_visit_with(self)
}
- _ => pred.subst(fcx.tcx, substs)
- });
+ }
+ }
+ let mut param_count = CountParams { params: FxHashSet() };
+ pred.visit_with(&mut param_count);
+ let substituted_pred = pred.subst(fcx.tcx, substs);
+ // Don't check non-defaulted params, dependent defaults or preds with multiple params.
+ if substituted_pred.references_error() || param_count.params.len() > 1 {
+ continue;
+ }
+ // Avoid duplication of predicates that contain no parameters, for example.
+ if !predicates.predicates.contains(&substituted_pred) {
+ substituted_predicates.push(substituted_pred);
}
}
let is_self_ty = |ty| fcx.infcx.can_eq(fcx.param_env, self_ty, ty).is_ok();
let self_kind = ExplicitSelf::determine(self_arg_ty, is_self_ty);
- if !fcx.tcx.sess.features.borrow().arbitrary_self_types {
+ if !fcx.tcx.features().arbitrary_self_types {
match self_kind {
ExplicitSelf::ByValue |
ExplicitSelf::ByReference(_, _) |
projects / rust.git / blobdiff