diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 3668fc46ddc27..39e757c52ff29 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -185,10 +185,7 @@ 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); - let predicates = fcx.tcx.predicates_of(item.def_id) - .instantiate_identity(fcx.tcx); - let predicates = fcx.normalize_associated_types_in(span, &predicates); - this.check_fn_or_method(fcx, span, sig, &predicates, + this.check_fn_or_method(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); @@ -272,9 +269,7 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> { } } - let predicates = fcx.tcx.predicates_of(def_id).instantiate_identity(fcx.tcx); - let predicates = fcx.normalize_associated_types_in(item.span, &predicates); - this.check_where_clauses(fcx, item.span, &predicates); + self.check_where_clauses(fcx, item.span, def_id); vec![] // no implied bounds in a struct def'n }); @@ -282,10 +277,8 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> { 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, this| { - let predicates = fcx.tcx.predicates_of(trait_def_id).instantiate_identity(fcx.tcx); - let predicates = fcx.normalize_associated_types_in(item.span, &predicates); - this.check_where_clauses(fcx, item.span, &predicates); + self.for_item(item).with_fcx(|fcx, _| { + self.check_where_clauses(fcx, item.span, trait_def_id); vec![] }); } @@ -295,12 +288,8 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> { 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 predicates = fcx.tcx.predicates_of(def_id).instantiate_identity(fcx.tcx); - let predicates = fcx.normalize_associated_types_in(item.span, &predicates); - let mut implied_bounds = vec![]; - this.check_fn_or_method(fcx, item.span, sig, &predicates, + this.check_fn_or_method(fcx, item.span, sig, def_id, &mut implied_bounds); implied_bounds }) @@ -354,19 +343,96 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> { } } - let predicates = fcx.tcx.predicates_of(item_def_id).instantiate_identity(fcx.tcx); - let predicates = fcx.normalize_associated_types_in(item.span, &predicates); - this.check_where_clauses(fcx, item.span, &predicates); + this.check_where_clauses(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, fcx: &FnCtxt<'fcx, 'gcx, 'tcx>, span: Span, - predicates: &ty::InstantiatedPredicates<'tcx>) - { + def_id: DefId) { + use ty::subst::Subst; + use rustc::ty::TypeFoldable; + + let mut predicates = fcx.tcx.predicates_of(def_id); + let mut substituted_predicates = Vec::new(); + + let generics = self.tcx.generics_of(def_id); + 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> { .. } + // 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., ). 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`. + // 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; + } + } + // 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 } + 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) + } + } + } + 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); + } + } + + predicates.predicates.extend(substituted_predicates); + let predicates = predicates.instantiate_identity(fcx.tcx); + let predicates = fcx.normalize_associated_types_in(span, &predicates); + let obligations = predicates.predicates .iter() @@ -385,7 +451,6 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> { fcx: &FnCtxt<'fcx, 'gcx, 'tcx>, span: Span, sig: ty::PolyFnSig<'tcx>, - predicates: &ty::InstantiatedPredicates<'tcx>, def_id: DefId, implied_bounds: &mut Vec>) { @@ -402,7 +467,7 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> { // FIXME(#25759) return types should not be implied bounds implied_bounds.push(sig.output()); - self.check_where_clauses(fcx, span, predicates); + self.check_where_clauses(fcx, span, def_id); } fn check_method_receiver<'fcx, 'tcx>(&mut self, diff --git a/src/test/run-pass/defaults-well-formedness.rs b/src/test/run-pass/defaults-well-formedness.rs new file mode 100644 index 0000000000000..f359467909553 --- /dev/null +++ b/src/test/run-pass/defaults-well-formedness.rs @@ -0,0 +1,30 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +trait Trait {} +struct Foo(U, V) where U: Trait; + +trait Marker {} +struct TwoParams(T, U); +impl Marker for TwoParams {} + +// Clauses with more than 1 param are not checked. +struct IndividuallyBogus(TwoParams) where TwoParams: Marker; +struct BogusTogether(T, U) where TwoParams: Marker; +// Clauses with non-defaulted params are not checked. +struct NonDefaultedInClause(TwoParams) where TwoParams: Marker; +struct DefaultedLhs(U, V) where V: Trait; +// Dependent defaults are not checked. +struct Dependent(T, U) where U: Copy; +trait SelfBound {} +// Not even for well-formedness. +struct WellFormedProjection::Item>(A, T); + +fn main() {} diff --git a/src/test/run-pass/type-macros-simple.rs b/src/test/run-pass/type-macros-simple.rs index c61133f795b34..67b1d2c06e314 100644 --- a/src/test/run-pass/type-macros-simple.rs +++ b/src/test/run-pass/type-macros-simple.rs @@ -34,3 +34,4 @@ fn issue_36540() { } trait Trait {} +impl Trait for i32 {} diff --git a/src/test/ui/type-check-defaults.rs b/src/test/ui/type-check-defaults.rs new file mode 100644 index 0000000000000..f916df5d32d04 --- /dev/null +++ b/src/test/ui/type-check-defaults.rs @@ -0,0 +1,37 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::iter::FromIterator; +use std::vec::IntoIter; +use std::ops::Add; + +struct Foo>(T, U); +struct WellFormed>(Z); +//~^ error: the trait bound `i32: std::iter::FromIterator` is not satisfied [E0277] +struct WellFormedNoBounds>(Z); +//~^ error: the trait bound `i32: std::iter::FromIterator` is not satisfied [E0277] + +struct Bounds(T); +//~^ error: the trait bound `std::string::String: std::marker::Copy` is not satisfied [E0277] + +struct WhereClause(T) where T: Copy; +//~^ error: the trait bound `std::string::String: std::marker::Copy` is not satisfied [E0277] + +trait TraitBound {} +//~^ error: the trait bound `std::string::String: std::marker::Copy` is not satisfied [E0277] + +trait Super { } +trait Base: Super { } +//~^ error: the trait bound `T: std::marker::Copy` is not satisfied [E0277] + +trait ProjectionPred> where T::Item : Add {} +//~^ error: cannot add `u8` to `i32` [E0277] + +fn main() { } diff --git a/src/test/ui/type-check-defaults.stderr b/src/test/ui/type-check-defaults.stderr new file mode 100644 index 0000000000000..f39b7dcb31f0c --- /dev/null +++ b/src/test/ui/type-check-defaults.stderr @@ -0,0 +1,75 @@ +error[E0277]: the trait bound `i32: std::iter::FromIterator` is not satisfied + --> $DIR/type-check-defaults.rs:16:19 + | +LL | struct WellFormed>(Z); + | ^ a collection of type `i32` cannot be built from an iterator over elements of type `i32` + | + = help: the trait `std::iter::FromIterator` is not implemented for `i32` +note: required by `Foo` + --> $DIR/type-check-defaults.rs:15:1 + | +LL | struct Foo>(T, U); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0277]: the trait bound `i32: std::iter::FromIterator` is not satisfied + --> $DIR/type-check-defaults.rs:18:27 + | +LL | struct WellFormedNoBounds>(Z); + | ^ a collection of type `i32` cannot be built from an iterator over elements of type `i32` + | + = help: the trait `std::iter::FromIterator` is not implemented for `i32` +note: required by `Foo` + --> $DIR/type-check-defaults.rs:15:1 + | +LL | struct Foo>(T, U); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0277]: the trait bound `std::string::String: std::marker::Copy` is not satisfied + --> $DIR/type-check-defaults.rs:21:1 + | +LL | struct Bounds(T); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Copy` is not implemented for `std::string::String` + | + = note: required by `std::marker::Copy` + +error[E0277]: the trait bound `std::string::String: std::marker::Copy` is not satisfied + --> $DIR/type-check-defaults.rs:24:1 + | +LL | struct WhereClause(T) where T: Copy; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Copy` is not implemented for `std::string::String` + | + = note: required by `std::marker::Copy` + +error[E0277]: the trait bound `std::string::String: std::marker::Copy` is not satisfied + --> $DIR/type-check-defaults.rs:27:1 + | +LL | trait TraitBound {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Copy` is not implemented for `std::string::String` + | + = note: required by `std::marker::Copy` + +error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied + --> $DIR/type-check-defaults.rs:31:1 + | +LL | trait Base: Super { } + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Copy` is not implemented for `T` + | + = help: consider adding a `where T: std::marker::Copy` bound +note: required by `Super` + --> $DIR/type-check-defaults.rs:30:1 + | +LL | trait Super { } + | ^^^^^^^^^^^^^^^^^^^^ + +error[E0277]: cannot add `u8` to `i32` + --> $DIR/type-check-defaults.rs:34:1 + | +LL | trait ProjectionPred> where T::Item : Add {} + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `i32 + u8` + | + = help: the trait `std::ops::Add` is not implemented for `i32` + = note: required by `std::ops::Add` + +error: aborting due to 7 previous errors + +If you want more information on this error, try using "rustc --explain E0277"