From 4561607403e1595d5ecbf36716711bc0076506f0 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 09:41:05 -0400 Subject: [PATCH 01/38] Don't report a hard error if there are inference failures until after we check casts, because sometimes casts can influence inference, unfortunately. We do re-run `select_all_trait_obligations` during regionck anyhow. --- src/librustc_typeck/check/mod.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 6221134afd38a..86d6d404fb080 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -445,9 +445,8 @@ fn check_bare_fn<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, fcx.select_all_obligations_and_apply_defaults(); upvar::closure_analyze_fn(&fcx, fn_id, decl, body); - fcx.select_all_obligations_or_error(); + fcx.select_obligations_where_possible(); fcx.check_casts(); - fcx.select_all_obligations_or_error(); // Casts can introduce new obligations. regionck::regionck_fn(&fcx, fn_id, fn_span, decl, body); From 928955296e28cea5045fb726d6e3fb47780f8c48 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 6 Aug 2015 14:27:21 -0400 Subject: [PATCH 02/38] Define the `wf` and `outlives` relation separately, unlike the existing `implicator`. These definitions are also in accordance with RFC 1214 (or more so), and hence somewhat different from the implicator. This commit also modifies the implicator to remove the older rules for projections, which can easily trigger infinite loops. --- src/librustc/lib.rs | 2 + src/librustc/middle/free_region.rs | 21 +- src/librustc/middle/implicator.rs | 51 +-- src/librustc/middle/outlives.rs | 191 ++++++++++ src/librustc/middle/ty.rs | 66 +++- src/librustc/middle/wf.rs | 546 +++++++++++++++++++++++++++++ src/librustc_typeck/astconv.rs | 2 +- 7 files changed, 817 insertions(+), 62 deletions(-) create mode 100644 src/librustc/middle/outlives.rs create mode 100644 src/librustc/middle/wf.rs diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 6b53f835be592..f48a28965c685 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -130,6 +130,7 @@ pub mod middle { pub mod lang_items; pub mod liveness; pub mod mem_categorization; + pub mod outlives; pub mod pat_util; pub mod privacy; pub mod reachable; @@ -144,6 +145,7 @@ pub mod middle { pub mod ty_match; pub mod ty_relate; pub mod ty_walk; + pub mod wf; pub mod weak_lang_items; } diff --git a/src/librustc/middle/free_region.rs b/src/librustc/middle/free_region.rs index 102cd001a296a..9a5f03672316a 100644 --- a/src/librustc/middle/free_region.rs +++ b/src/librustc/middle/free_region.rs @@ -10,7 +10,7 @@ //! This file defines -use middle::implicator::Implication; +use middle::wf::ImpliedBound; use middle::ty::{self, FreeRegion}; use util::common::can_reach; use util::nodemap::{FnvHashMap, FnvHashSet}; @@ -30,18 +30,19 @@ impl FreeRegionMap { FreeRegionMap { map: FnvHashMap(), statics: FnvHashSet() } } - pub fn relate_free_regions_from_implications<'tcx>(&mut self, - implications: &[Implication<'tcx>]) + pub fn relate_free_regions_from_implied_bounds<'tcx>(&mut self, + implied_bounds: &[ImpliedBound<'tcx>]) { - for implication in implications { - debug!("implication: {:?}", implication); - match *implication { - Implication::RegionSubRegion(_, ty::ReFree(free_a), ty::ReFree(free_b)) => { + debug!("relate_free_regions_from_implied_bounds()"); + for implied_bound in implied_bounds { + debug!("implied bound: {:?}", implied_bound); + match *implied_bound { + ImpliedBound::RegionSubRegion(ty::ReFree(free_a), ty::ReFree(free_b)) => { self.relate_free_regions(free_a, free_b); } - Implication::RegionSubRegion(..) | - Implication::RegionSubGeneric(..) | - Implication::Predicate(..) => { + ImpliedBound::RegionSubRegion(..) | + ImpliedBound::RegionSubParam(..) | + ImpliedBound::RegionSubProjection(..) => { } } } diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index 84fc2f7b2e540..21f09574a3fc8 100644 --- a/src/librustc/middle/implicator.rs +++ b/src/librustc/middle/implicator.rs @@ -278,9 +278,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { for predicate in predicates.predicates.as_slice() { match *predicate { - ty::Predicate::Trait(ref data) => { - self.accumulate_from_assoc_types_transitive(data); - } + ty::Predicate::Trait(..) => { } ty::Predicate::Equate(..) => { } ty::Predicate::Projection(..) => { } ty::Predicate::RegionOutlives(ref data) => { @@ -349,53 +347,6 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { } } - /// Given that there is a requirement that `Foo : 'a`, where - /// `Foo` is declared like `struct Foo where T : SomeTrait`, - /// this code finds all the associated types defined in - /// `SomeTrait` (and supertraits) and adds a requirement that `::N : 'a` (where `N` is some associated type - /// defined in `SomeTrait`). This rule only applies to - /// trait-bounds that are not higher-ranked, because we cannot - /// project out of a HRTB. This rule helps code using associated - /// types to compile, see Issue #22246 for an example. - fn accumulate_from_assoc_types_transitive(&mut self, - data: &ty::PolyTraitPredicate<'tcx>) - { - debug!("accumulate_from_assoc_types_transitive({:?})", - data); - - for poly_trait_ref in traits::supertraits(self.tcx(), data.to_poly_trait_ref()) { - match self.tcx().no_late_bound_regions(&poly_trait_ref) { - Some(trait_ref) => { self.accumulate_from_assoc_types(trait_ref); } - None => { } - } - } - } - - fn accumulate_from_assoc_types(&mut self, - trait_ref: ty::TraitRef<'tcx>) - { - debug!("accumulate_from_assoc_types({:?})", - trait_ref); - - let trait_def_id = trait_ref.def_id; - let trait_def = self.tcx().lookup_trait_def(trait_def_id); - let assoc_type_projections: Vec<_> = - trait_def.associated_type_names - .iter() - .map(|&name| self.tcx().mk_projection(trait_ref.clone(), name)) - .collect(); - debug!("accumulate_from_assoc_types: assoc_type_projections={:?}", - assoc_type_projections); - let tys = match self.fully_normalize(&assoc_type_projections) { - Ok(tys) => { tys } - Err(ErrorReported) => { return; } - }; - for ty in tys { - self.accumulate_from_ty(ty); - } - } - fn accumulate_from_object_ty(&mut self, ty: Ty<'tcx>, region_bound: ty::Region, diff --git a/src/librustc/middle/outlives.rs b/src/librustc/middle/outlives.rs new file mode 100644 index 0000000000000..fa2b78b330d8b --- /dev/null +++ b/src/librustc/middle/outlives.rs @@ -0,0 +1,191 @@ +// Copyright 2012 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. + +// The outlines relation `T: 'a` or `'a: 'b`. + +use middle::infer::InferCtxt; +use middle::ty::{self, RegionEscape, Ty}; + +#[derive(Debug)] +pub enum Component<'tcx> { + Region(ty::Region), + Param(ty::ParamTy), + UnresolvedInferenceVariable(ty::InferTy), + + // Projections like `T::Foo` are tricky because a constraint like + // `T::Foo: 'a` can be satisfied in so many ways. There may be a + // where-clause that says `T::Foo: 'a`, or the defining trait may + // include a bound like `type Foo: 'static`, or -- in the most + // conservative way -- we can prove that `T: 'a` (more generally, + // that all components in the projection outlive `'a`). This code + // is not in a position to judge which is the best technique, so + // we just product the projection as a component and leave it to + // the consumer to decide (but see `EscapingProjection` below). + Projection(ty::ProjectionTy<'tcx>), + + // In the case where a projection has escaping regions -- meaning + // regions bound within the type itself -- we always use + // the most conservative rule, which requires that all components + // outlive the bound. So for example if we had a type like this: + // + // for<'a> Trait1< >::Foo > + // ~~~~~~~~~~~~~~~~~~~~~~~~~ + // + // then the inner projection (underlined) has an escaping region + // `'a`. We consider that outer trait `'c` to meet a bound if `'b` + // outlives `'b: 'c`, and we don't consider whether the trait + // declares that `Foo: 'static` etc. Therefore, we just return the + // free components of such a projection (in this case, `'b`). + // + // However, in the future, we may want to get smarter, and + // actually return a "higher-ranked projection" here. Therefore, + // we mark that these components are part of an escaping + // projection, so that implied bounds code can avoid relying on + // them. This gives us room to improve the regionck reasoning in + // the future without breaking backwards compat. + EscapingProjection(Vec>), + + RFC1214(Vec>), +} + +/// Returns all the things that must outlive `'a` for the condition +/// `ty0: 'a` to hold. +pub fn components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, + ty0: Ty<'tcx>) + -> Vec> { + let mut components = vec![]; + compute_components(infcx, ty0, &mut components); + debug!("outlives({:?}) = {:?}", ty0, components); + components +} + +fn compute_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, + ty0: Ty<'tcx>, + out: &mut Vec>) { + // Descend through the types, looking for the various "base" + // components and collecting them into `out`. This is not written + // with `collect()` because of the need to sometimes skip subtrees + // in the `subtys` iterator (e.g., when encountering a + // projection). + let mut subtys = ty0.walk(); + while let Some(ty) = subtys.next() { + match ty.sty { + ty::TyClosure(_, ref substs) => { + // FIXME(#27086). We do not accumulate from substs, since they + // don't represent reachable data. This means that, in + // practice, some of the lifetime parameters might not + // be in scope when the body runs, so long as there is + // no reachable data with that lifetime. For better or + // worse, this is consistent with fn types, however, + // which can also encapsulate data in this fashion + // (though it's somewhat harder, and typically + // requires virtual dispatch). + // + // Note that changing this (in a naive way, at least) + // causes regressions for what appears to be perfectly + // reasonable code like this: + // + // ``` + // fn foo<'a>(p: &Data<'a>) { + // bar(|q: &mut Parser| q.read_addr()) + // } + // fn bar(p: Box) { + // } + // ``` + // + // Note that `p` (and `'a`) are not used in the + // closure at all, but to meet the requirement that + // the closure type `C: 'static` (so it can be coerced + // to the object type), we get the requirement that + // `'a: 'static` since `'a` appears in the closure + // type `C`. + // + // A smarter fix might "prune" unused `func_substs` -- + // this would avoid breaking simple examples like + // this, but would still break others (which might + // indeed be invalid, depending on your POV). Pruning + // would be a subtle process, since we have to see + // what func/type parameters are used and unused, + // taking into consideration UFCS and so forth. + + for &upvar_ty in &substs.upvar_tys { + compute_components(infcx, upvar_ty, out); + } + subtys.skip_current_subtree(); + } + ty::TyBareFn(..) | ty::TyTrait(..) => { + subtys.skip_current_subtree(); + let temp = capture_components(infcx, ty); + out.push(Component::RFC1214(temp)); + } + ty::TyParam(p) => { + out.push(Component::Param(p)); + subtys.skip_current_subtree(); + } + ty::TyProjection(ref data) => { + // For projections, we prefer to generate an + // obligation like `>::Foo: 'a`, + // because this gives the regionck more ways to prove + // that it holds. However, regionck is not (at least + // currently) prepared to deal with higher-ranked + // regions that may appear in the + // trait-ref. Therefore, if we see any higher-ranke + // regions, we simply fallback to the most restrictive + // rule, which requires that `Pi: 'a` for all `i`. + + if !data.has_escaping_regions() { + // best case: no escaping reions, so push the + // projection and skip the subtree (thus + // generating no constraints for Pi). + out.push(Component::Projection(*data)); + } else { + // fallback case: continue walking through and + // constrain Pi. + let temp = capture_components(infcx, ty); + out.push(Component::EscapingProjection(temp)); + } + subtys.skip_current_subtree(); + } + ty::TyInfer(_) => { + let ty = infcx.resolve_type_vars_if_possible(&ty); + if let ty::TyInfer(infer_ty) = ty.sty { + out.push(Component::UnresolvedInferenceVariable(infer_ty)); + } else { + compute_components(infcx, ty, out); + } + } + _ => { + // for all other types, just constrain the regions and + // keep walking to find any other types. + push_region_constraints(out, ty.regions()); + } + } + } +} + +fn capture_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, + ty: Ty<'tcx>) + -> Vec> { + let mut temp = vec![]; + push_region_constraints(&mut temp, ty.regions()); + for subty in ty.walk_shallow() { + compute_components(infcx, subty, &mut temp); + } + temp +} + +fn push_region_constraints<'tcx>(out: &mut Vec>, regions: Vec) { + for r in regions { + if !r.is_bound() { + out.push(Component::Region(r)); + } + } +} + diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 2fe1f14d521ba..7d807bf2431ff 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -1670,6 +1670,13 @@ impl Region { } } + pub fn needs_infer(&self) -> bool { + match *self { + ty::ReInfer(..) => true, + _ => false + } + } + pub fn escapes_depth(&self, depth: u32) -> bool { match *self { ty::ReLateBound(debruijn, _) => debruijn.depth > depth, @@ -2567,7 +2574,7 @@ impl<'tcx> PolyProjectionPredicate<'tcx> { /// Represents the projection of an associated type. In explicit UFCS /// form this would be written `>::N`. -#[derive(Clone, PartialEq, Eq, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub struct ProjectionTy<'tcx> { /// The trait reference `T as Trait<..>`. pub trait_ref: ty::TraitRef<'tcx>, @@ -4144,6 +4151,49 @@ impl<'tcx> TyS<'tcx> { } } + /// Returns the regions directly referenced from this type (but + /// not types reachable from this type via `walk_tys`). This + /// ignores late-bound regions binders. + pub fn regions(&self) -> Vec { + match self.sty { + TyRef(region, _) => { + vec![*region] + } + TyTrait(ref obj) => { + let mut v = vec![obj.bounds.region_bound]; + v.push_all(obj.principal.skip_binder().substs.regions().as_slice()); + v + } + TyEnum(_, substs) | + TyStruct(_, substs) => { + substs.regions().as_slice().to_vec() + } + TyClosure(_, ref substs) => { + substs.func_substs.regions().as_slice().to_vec() + } + TyProjection(ref data) => { + data.trait_ref.substs.regions().as_slice().to_vec() + } + TyBareFn(..) | + TyBool | + TyChar | + TyInt(_) | + TyUint(_) | + TyFloat(_) | + TyBox(_) | + TyStr | + TyArray(_, _) | + TySlice(_) | + TyRawPtr(_) | + TyTuple(_) | + TyParam(_) | + TyInfer(_) | + TyError => { + vec![] + } + } + } + /// Walks `ty` and any types appearing within `ty`, invoking the /// callback `f` on each type. If the callback returns false, then the /// children of the current type are ignored. @@ -6951,6 +7001,20 @@ impl<'tcx> RegionEscape for Ty<'tcx> { } } +impl<'tcx> RegionEscape for TraitTy<'tcx> { + fn has_regions_escaping_depth(&self, depth: u32) -> bool { + self.principal.has_regions_escaping_depth(depth) || + self.bounds.has_regions_escaping_depth(depth) + } +} + +impl<'tcx> RegionEscape for ExistentialBounds<'tcx> { + fn has_regions_escaping_depth(&self, depth: u32) -> bool { + self.region_bound.has_regions_escaping_depth(depth) || + self.projection_bounds.has_regions_escaping_depth(depth) + } +} + impl<'tcx> RegionEscape for Substs<'tcx> { fn has_regions_escaping_depth(&self, depth: u32) -> bool { self.types.has_regions_escaping_depth(depth) || diff --git a/src/librustc/middle/wf.rs b/src/librustc/middle/wf.rs new file mode 100644 index 0000000000000..d7808599895f5 --- /dev/null +++ b/src/librustc/middle/wf.rs @@ -0,0 +1,546 @@ +// Copyright 2012-2013 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 middle::infer::InferCtxt; +use middle::outlives::{self, Component}; +use middle::subst::Substs; +use middle::traits; +use middle::ty::{self, RegionEscape, ToPredicate, Ty}; +use std::iter::once; +use std::mem; +use std::rc::Rc; +use syntax::ast; +use syntax::codemap::Span; +use util::common::ErrorReported; + +/// Returns the set of obligations needed to make `ty` well-formed. +/// If `ty` contains unresolved inference variables, this may include +/// further WF obligations. However, if `ty` IS an unresolved +/// inference variable, returns `None`, because we are not able to +/// make any progress at all. This is to prevent "livelock" where we +/// say "$0 is WF if $0 is WF". +pub fn obligations<'a,'tcx>(infcx: &InferCtxt<'a, 'tcx>, + body_id: ast::NodeId, + ty: Ty<'tcx>, + span: Span, + rfc1214: bool) + -> Option>> +{ + let mut wf = WfPredicates { infcx: infcx, + body_id: body_id, + span: span, + out: vec![], + rfc1214: rfc1214 }; + if wf.compute(ty) { + debug!("wf::obligations({:?}, body_id={:?}) = {:?}", ty, body_id, wf.out); + let result = wf.normalize(); + debug!("wf::obligations({:?}, body_id={:?}) ~~> {:?}", ty, body_id, result); + Some(result) + } else { + None // no progress made, return None + } +} + +/// Returns the obligations that make this trait reference +/// well-formed. For example, if there is a trait `Set` defined like +/// `trait Set`, then the trait reference `Foo: Set` is WF +/// if `Bar: Eq`. +pub fn trait_obligations<'a,'tcx>(infcx: &InferCtxt<'a, 'tcx>, + body_id: ast::NodeId, + trait_ref: &ty::TraitRef<'tcx>, + span: Span, + rfc1214: bool) + -> Vec> +{ + let mut wf = WfPredicates { infcx: infcx, body_id: body_id, span: span, + out: vec![], rfc1214: rfc1214 }; + wf.compute_trait_ref(trait_ref); + wf.normalize() +} + +pub fn predicate_obligations<'a,'tcx>(infcx: &InferCtxt<'a, 'tcx>, + body_id: ast::NodeId, + predicate: &ty::Predicate<'tcx>, + span: Span, + rfc1214: bool) + -> Vec> +{ + let mut wf = WfPredicates { infcx: infcx, body_id: body_id, span: span, + out: vec![], rfc1214: rfc1214 }; + + // (*) ok to skip binders, because wf code is prepared for it + match *predicate { + ty::Predicate::Trait(ref t) => { + wf.compute_trait_ref(&t.skip_binder().trait_ref); // (*) + } + ty::Predicate::Equate(ref t) => { + wf.compute(t.skip_binder().0); + wf.compute(t.skip_binder().1); + } + ty::Predicate::RegionOutlives(..) => { + } + ty::Predicate::TypeOutlives(ref t) => { + wf.compute(t.skip_binder().0); + } + ty::Predicate::Projection(ref t) => { + let t = t.skip_binder(); // (*) + wf.compute_projection(t.projection_ty); + wf.compute(t.ty); + } + ty::Predicate::WellFormed(t) => { + wf.compute(t); + } + ty::Predicate::ObjectSafe(_) => { + } + } + + wf.normalize() +} + +/// Implied bounds are region relationships that we deduce +/// automatically. The idea is that (e.g.) a caller must check that a +/// function's argument types are well-formed immediately before +/// calling that fn, and hence the *callee* can assume that its +/// argument types are well-formed. This may imply certain relationships +/// between generic parameters. For example: +/// +/// fn foo<'a,T>(x: &'a T) +/// +/// can only be called with a `'a` and `T` such that `&'a T` is WF. +/// For `&'a T` to be WF, `T: 'a` must hold. So we can assume `T: 'a`. +#[derive(Debug)] +pub enum ImpliedBound<'tcx> { + RegionSubRegion(ty::Region, ty::Region), + RegionSubParam(ty::Region, ty::ParamTy), + RegionSubProjection(ty::Region, ty::ProjectionTy<'tcx>), +} + +/// This routine computes the full set of well-formedness constraints +/// that must hold for the type `ty` to appear in a context with +/// lifetime `outer_region`. +pub fn implied_bounds<'a,'tcx>( + infcx: &'a InferCtxt<'a,'tcx>, + body_id: ast::NodeId, + ty: Ty<'tcx>, + span: Span) + -> Vec> +{ + // Sometimes when we ask what it takes for T: WF, we get back that + // U: WF is required; in that case, we push U onto this stack and + // process it next. Currently (at least) these resulting + // predicates are always guaranteed to be a subset of the original + // type, so we need not fear non-termination. + let mut wf_types = vec![ty]; + + let mut implied_bounds = vec![]; + + while let Some(ty) = wf_types.pop() { + // Compute the obligations for `ty` to be well-formed. If `ty` is + // an unresolved inference variable, just substituted an empty set + // -- because the return type here is going to be things we *add* + // to the environment, it's always ok for this set to be smaller + // than the ultimate set. (Note: normally there won't be + // unresolved inference variables here anyway, but there might be + // during typeck under some circumstances.) + let obligations = obligations(infcx, body_id, ty, span, false).unwrap_or(vec![]); + + // From the full set of obligations, just filter down to the + // region relationships. + implied_bounds.extend( + obligations + .into_iter() + .flat_map(|obligation| { + assert!(!obligation.has_escaping_regions()); + match obligation.predicate { + ty::Predicate::Trait(..) | + ty::Predicate::Equate(..) | + ty::Predicate::Projection(..) | + ty::Predicate::ObjectSafe(..) => + vec![], + + ty::Predicate::WellFormed(subty) => { + wf_types.push(subty); + vec![] + } + + ty::Predicate::RegionOutlives(ref data) => + match infcx.tcx.no_late_bound_regions(data) { + None => + vec![], + Some(ty::OutlivesPredicate(r_a, r_b)) => + vec![ImpliedBound::RegionSubRegion(r_b, r_a)], + }, + + ty::Predicate::TypeOutlives(ref data) => + match infcx.tcx.no_late_bound_regions(data) { + None => vec![], + Some(ty::OutlivesPredicate(ty_a, r_b)) => { + let components = outlives::components(infcx, ty_a); + implied_bounds_from_components(r_b, components) + } + }, + }})); + } + + implied_bounds +} + +/// When we have an implied bound that `T: 'a`, we can further break +/// this down to determine what relationships would have to hold for +/// `T: 'a` to hold. We get to assume that the caller has validated +/// those relationships. +fn implied_bounds_from_components<'tcx>(sub_region: ty::Region, + sup_components: Vec>) + -> Vec> +{ + sup_components + .into_iter() + .flat_map(|component| { + match component { + Component::Region(r) => + vec!(ImpliedBound::RegionSubRegion(sub_region, r)), + Component::Param(p) => + vec!(ImpliedBound::RegionSubParam(sub_region, p)), + Component::Projection(p) => + vec!(ImpliedBound::RegionSubProjection(sub_region, p)), + Component::EscapingProjection(_) => + // If the projection has escaping regions, don't + // try to infer any implied bounds even for its + // free components. This is conservative, because + // the caller will still have to prove that those + // free components outlive `sub_region`. But the + // idea is that the WAY that the caller proves + // that may change in the future and we want to + // give ourselves room to get smarter here. + vec!(), + Component::UnresolvedInferenceVariable(..) => + vec!(), + Component::RFC1214(components) => + implied_bounds_from_components(sub_region, components), + } + }) + .collect() +} + +struct WfPredicates<'a,'tcx:'a> { + infcx: &'a InferCtxt<'a, 'tcx>, + body_id: ast::NodeId, + span: Span, + out: Vec>, + rfc1214: bool +} + +impl<'a,'tcx> WfPredicates<'a,'tcx> { + fn rfc1214) -> R>(&mut self, f: F) -> R { + let b = mem::replace(&mut self.rfc1214, true); + let r = f(self); + self.rfc1214 = b; + r + } + + fn cause(&mut self, code: traits::ObligationCauseCode<'tcx>) -> traits::ObligationCause<'tcx> { + if !self.rfc1214 { + traits::ObligationCause::new(self.span, self.body_id, code) + } else { + let code = traits::ObligationCauseCode::RFC1214(Rc::new(code)); + traits::ObligationCause::new(self.span, self.body_id, code) + } + } + + fn normalize(&mut self) -> Vec> { + let cause = self.cause(traits::MiscObligation); + let infcx = &mut self.infcx; + self.out.iter() + .inspect(|pred| assert!(!pred.has_escaping_regions())) + .flat_map(|pred| { + let mut selcx = traits::SelectionContext::new(infcx); + let pred = traits::normalize(&mut selcx, cause.clone(), pred); + once(pred.value).chain(pred.obligations) + }) + .collect() + } + + fn compute_rfc1214(&mut self, ty: Ty<'tcx>) { + let b = mem::replace(&mut self.rfc1214, true); + for subty in ty.walk().skip(1) { + self.compute(subty); + } + self.rfc1214 = b; + } + + /// Pushes the obligations required for `trait_ref` to be WF into + /// `self.out`. + fn compute_trait_ref(&mut self, trait_ref: &ty::TraitRef<'tcx>) { + let obligations = self.nominal_obligations(trait_ref.def_id, trait_ref.substs); + self.out.extend(obligations); + + let cause = self.cause(traits::MiscObligation); + self.out.extend( + trait_ref.substs.types + .as_slice() + .iter() + .filter(|ty| !ty.has_escaping_regions()) + .map(|ty| traits::Obligation::new(cause.clone(), + ty::Predicate::WellFormed(ty)))); + } + + /// Pushes the obligations required for `trait_ref::Item` to be WF + /// into `self.out`. + fn compute_projection(&mut self, data: ty::ProjectionTy<'tcx>) { + // A projection is well-formed if (a) the trait ref itself is + // WF WF and (b) the trait-ref holds. (It may also be + // normalizable and be WF that way.) + + self.compute_trait_ref(&data.trait_ref); + + if !data.has_escaping_regions() { + let predicate = data.trait_ref.to_predicate(); + let cause = self.cause(traits::ProjectionWf(data)); + self.out.push(traits::Obligation::new(cause, predicate)); + } + } + + /// Push new obligations into `out`. Returns true if it was able + /// to generate all the predicates needed to validate that `ty0` + /// is WF. Returns false if `ty0` is an unresolved type variable, + /// in which case we are not able to simplify at all. + fn compute(&mut self, ty0: Ty<'tcx>) -> bool { + let mut subtys = ty0.walk(); + while let Some(ty) = subtys.next() { + match ty.sty { + ty::TyBool | + ty::TyChar | + ty::TyInt(..) | + ty::TyUint(..) | + ty::TyFloat(..) | + ty::TyError | + ty::TyStr | + ty::TyParam(_) => { + // WfScalar, WfParameter, etc + } + + ty::TySlice(subty) | + ty::TyArray(subty, _) => { + self.rfc1214(|this| { + if !subty.has_escaping_regions() { + let cause = this.cause(traits::SliceOrArrayElem); + match traits::trait_ref_for_builtin_bound(this.infcx.tcx, + ty::BoundSized, + subty) { + Ok(trait_ref) => { + this.out.push( + traits::Obligation::new(cause, + trait_ref.to_predicate())); + } + Err(ErrorReported) => { } + } + } + }) + } + + ty::TyBox(_) | + ty::TyTuple(_) | + ty::TyRawPtr(_) => { + // simple cases that are WF if their type args are WF + } + + ty::TyProjection(data) => { + subtys.skip_current_subtree(); // subtree handled by compute_projection + self.compute_projection(data); + } + + ty::TyEnum(def, substs) | + ty::TyStruct(def, substs) => { + // WfNominalType + let obligations = self.nominal_obligations(def.did, substs); + self.out.extend(obligations); + } + + ty::TyRef(r, mt) => { + // WfReference + if !r.has_escaping_regions() && !mt.ty.has_escaping_regions() { + let cause = self.cause(traits::ReferenceOutlivesReferent(ty)); + self.out.push( + traits::Obligation::new( + cause, + ty::Predicate::TypeOutlives( + ty::Binder( + ty::OutlivesPredicate(mt.ty, *r))))); + } + } + + ty::TyClosure(..) => { + // the types in a closure are always the types of + // local variables (or possibly references to local + // variables), which are separately checked w/r/t + // WFedness. + } + + ty::TyBareFn(..) => { + // process the bound types; because the old implicator + // did not do this, go into RFC1214 mode. + subtys.skip_current_subtree(); + self.compute_rfc1214(ty); + } + + ty::TyTrait(ref data) => { + // WfObject + // + // Here, we defer WF checking due to higher-ranked + // regions. This is perhaps not ideal. + self.from_object_ty(ty, data); + + // FIXME(#27579) RFC also considers adding trait + // obligations that don't refer to Self and + // checking those + + let cause = self.cause(traits::MiscObligation); + self.out.push( + traits::Obligation::new( + cause, + ty::Predicate::ObjectSafe(data.principal_def_id()))); + + // process the bound types; because the old implicator + // did not do this, go into RFC1214 mode. + subtys.skip_current_subtree(); + self.compute_rfc1214(ty); + } + + // Inference variables are the complicated case, since we don't + // know what type they are. We do two things: + // + // 1. Check if they have been resolved, and if so proceed with + // THAT type. + // 2. If not, check whether this is the type that we + // started with (ty0). In that case, we've made no + // progress at all, so return false. Otherwise, + // we've at least simplified things (i.e., we went + // from `Vec<$0>: WF` to `$0: WF`, so we can + // register a pending obligation and keep + // moving. (Goal is that an "inductive hypothesis" + // is satisfied to ensure termination.) + ty::TyInfer(_) => { + let ty = self.infcx.shallow_resolve(ty); + if let ty::TyInfer(_) = ty.sty { // not yet resolved... + if ty == ty0 { // ...this is the type we started from! no progress. + return false; + } + + let cause = self.cause(traits::MiscObligation); + self.out.push( // ...not the type we started from, so we made progress. + traits::Obligation::new(cause, ty::Predicate::WellFormed(ty))); + } else { + // Yes, resolved, proceed with the + // result. Should never return false because + // `ty` is not a TyInfer. + assert!(self.compute(ty)); + } + } + } + } + + // if we made it through that loop above, we made progress! + return true; + } + + fn nominal_obligations(&mut self, + def_id: ast::DefId, + substs: &Substs<'tcx>) + -> Vec> + { + let predicates = + self.infcx.tcx.lookup_predicates(def_id) + .instantiate(self.infcx.tcx, substs); + let cause = self.cause(traits::ItemObligation(def_id)); + predicates.predicates + .into_iter() + .map(|pred| traits::Obligation::new(cause.clone(), pred)) + .filter(|pred| !pred.has_escaping_regions()) + .collect() + } + + fn from_object_ty(&mut self, ty: Ty<'tcx>, data: &ty::TraitTy<'tcx>) { + // Imagine a type like this: + // + // trait Foo { } + // trait Bar<'c> : 'c { } + // + // &'b (Foo+'c+Bar<'d>) + // ^ + // + // In this case, the following relationships must hold: + // + // 'b <= 'c + // 'd <= 'c + // + // The first conditions is due to the normal region pointer + // rules, which say that a reference cannot outlive its + // referent. + // + // The final condition may be a bit surprising. In particular, + // you may expect that it would have been `'c <= 'd`, since + // usually lifetimes of outer things are conservative + // approximations for inner things. However, it works somewhat + // differently with trait objects: here the idea is that if the + // user specifies a region bound (`'c`, in this case) it is the + // "master bound" that *implies* that bounds from other traits are + // all met. (Remember that *all bounds* in a type like + // `Foo+Bar+Zed` must be met, not just one, hence if we write + // `Foo<'x>+Bar<'y>`, we know that the type outlives *both* 'x and + // 'y.) + // + // Note: in fact we only permit builtin traits, not `Bar<'d>`, I + // am looking forward to the future here. + + if !data.has_escaping_regions() { + let implicit_bounds = + object_region_bounds(self.infcx.tcx, + &data.principal, + data.bounds.builtin_bounds); + + let explicit_bound = data.bounds.region_bound; + + for implicit_bound in implicit_bounds { + let cause = self.cause(traits::ReferenceOutlivesReferent(ty)); + let outlives = ty::Binder(ty::OutlivesPredicate(explicit_bound, implicit_bound)); + self.out.push(traits::Obligation::new(cause, outlives.to_predicate())); + } + } + } +} + +/// Given an object type like `SomeTrait+Send`, computes the lifetime +/// bounds that must hold on the elided self type. These are derived +/// from the declarations of `SomeTrait`, `Send`, and friends -- if +/// they declare `trait SomeTrait : 'static`, for example, then +/// `'static` would appear in the list. The hard work is done by +/// `ty::required_region_bounds`, see that for more information. +pub fn object_region_bounds<'tcx>( + tcx: &ty::ctxt<'tcx>, + principal: &ty::PolyTraitRef<'tcx>, + others: ty::BuiltinBounds) + -> Vec +{ + // Since we don't actually *know* the self type for an object, + // this "open(err)" serves as a kind of dummy standin -- basically + // a skolemized type. + let open_ty = tcx.mk_infer(ty::FreshTy(0)); + + // Note that we preserve the overall binding levels here. + assert!(!open_ty.has_escaping_regions()); + let substs = tcx.mk_substs(principal.0.substs.with_self_ty(open_ty)); + let trait_refs = vec!(ty::Binder(ty::TraitRef::new(principal.0.def_id, substs))); + + let mut predicates = others.to_predicates(tcx, open_ty); + predicates.extend(trait_refs.iter().map(|t| t.to_predicate())); + + tcx.required_region_bounds(open_ty, predicates) +} + diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 99f375c32868e..64cde0fccabaa 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -52,7 +52,7 @@ use middle::astconv_util::{prim_ty_to_ty, check_path_args, NO_TPS, NO_REGIONS}; use middle::const_eval::{self, ConstVal}; use middle::const_eval::EvalHint::UncheckedExprHint; use middle::def; -use middle::implicator::object_region_bounds; +use middle::wf::object_region_bounds; use middle::resolve_lifetime as rl; use middle::privacy::{AllPublic, LastMod}; use middle::subst::{FnSpace, TypeSpace, SelfSpace, Subst, Substs, ParamSpace}; From b1963154a10fd22d16a5eddd751046cc897e909c Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 09:30:19 -0400 Subject: [PATCH 03/38] Add two new kinds of predicates, WellFormed and ObjectSafe. --- src/librustc/metadata/tydecode.rs | 6 ++++ src/librustc/metadata/tyencode.rs | 7 ++++ src/librustc/middle/free_region.rs | 2 ++ src/librustc/middle/implicator.rs | 5 ++- src/librustc/middle/traits/fulfill.rs | 38 ++++++++++++++++++--- src/librustc/middle/traits/object_safety.rs | 6 +++- src/librustc/middle/traits/select.rs | 20 +++++++++++ src/librustc/middle/traits/util.rs | 22 +++++++++++- src/librustc/middle/ty.rs | 30 ++++++++++++++++ src/librustc/middle/ty_fold.rs | 4 +++ src/librustc/util/ppaux.rs | 5 +++ src/librustc_typeck/check/closure.rs | 2 ++ src/librustc_typeck/check/dropck.rs | 6 ++-- src/librustc_typeck/collect.rs | 2 ++ src/librustdoc/clean/mod.rs | 4 ++- src/libsyntax/ast.rs | 2 +- 16 files changed, 149 insertions(+), 12 deletions(-) diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 679213874f964..a8b22846b786d 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -790,6 +790,12 @@ fn parse_predicate_<'a,'tcx, F>(st: &mut PState<'a, 'tcx>, 'o' => ty::Binder(ty::OutlivesPredicate(parse_ty_(st, conv), parse_region_(st, conv))).to_predicate(), 'p' => ty::Binder(parse_projection_predicate_(st, conv)).to_predicate(), + 'w' => ty::Predicate::WellFormed(parse_ty_(st, conv)), + 'O' => { + let def_id = parse_def_(st, NominalType, conv); + assert_eq!(next(st), '|'); + ty::Predicate::ObjectSafe(def_id) + } c => panic!("Encountered invalid character in metadata: {}", c) } } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 88666be6c2cc2..7170a3681713a 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -457,6 +457,13 @@ pub fn enc_predicate<'a, 'tcx>(w: &mut Encoder, mywrite!(w, "p"); enc_projection_predicate(w, cx, data) } + ty::Predicate::WellFormed(data) => { + mywrite!(w, "w"); + enc_ty(w, cx, data); + } + ty::Predicate::ObjectSafe(trait_def_id) => { + mywrite!(w, "O{}|", (cx.ds)(trait_def_id)); + } } } diff --git a/src/librustc/middle/free_region.rs b/src/librustc/middle/free_region.rs index 9a5f03672316a..5af37e9530cce 100644 --- a/src/librustc/middle/free_region.rs +++ b/src/librustc/middle/free_region.rs @@ -57,6 +57,8 @@ impl FreeRegionMap { ty::Predicate::Projection(..) | ty::Predicate::Trait(..) | ty::Predicate::Equate(..) | + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::TypeOutlives(..) => { // No region bounds here } diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index 21f09574a3fc8..1961c15d6e607 100644 --- a/src/librustc/middle/implicator.rs +++ b/src/librustc/middle/implicator.rs @@ -13,7 +13,7 @@ use middle::infer::{InferCtxt, GenericKind}; use middle::subst::Substs; use middle::traits; -use middle::ty::{self, RegionEscape, ToPolyTraitRef, ToPredicate, Ty}; +use middle::ty::{self, RegionEscape, ToPredicate, Ty}; use middle::ty_fold::{TypeFoldable, TypeFolder}; use syntax::ast; @@ -299,6 +299,9 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { } } } + ty::Predicate::ObjectSafe(_) | + ty::Predicate::WellFormed(_) => { + } } } diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs index 44fc6b6b8abdc..96637b92cef41 100644 --- a/src/librustc/middle/traits/fulfill.rs +++ b/src/librustc/middle/traits/fulfill.rs @@ -10,6 +10,7 @@ use middle::infer::InferCtxt; use middle::ty::{self, RegionEscape, Ty, HasTypeFlags}; +use middle::wf; use std::collections::HashSet; use std::fmt; @@ -20,8 +21,10 @@ use util::nodemap::NodeMap; use super::CodeAmbiguity; use super::CodeProjectionError; use super::CodeSelectionError; +use super::is_object_safe; use super::FulfillmentError; use super::ObligationCause; +use super::ObligationCauseCode; use super::PredicateObligation; use super::project; use super::select::SelectionContext; @@ -472,6 +475,32 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>, } } } + + ty::Predicate::ObjectSafe(trait_def_id) => { + if !is_object_safe(selcx.tcx(), trait_def_id) { + errors.push(FulfillmentError::new( + obligation.clone(), + CodeSelectionError(Unimplemented))); + } + true + } + + ty::Predicate::WellFormed(ty) => { + let rfc1214 = match obligation.cause.code { + ObligationCauseCode::RFC1214(_) => true, + _ => false, + }; + match wf::obligations(selcx.infcx(), obligation.cause.body_id, + ty, obligation.cause.span, rfc1214) { + Some(obligations) => { + new_obligations.extend(obligations); + true + } + None => { + false + } + } + } } } @@ -492,11 +521,12 @@ fn register_region_obligation<'tcx>(t_a: Ty<'tcx>, sub_region: r_b, cause: cause }; - debug!("register_region_obligation({:?})", - region_obligation); + debug!("register_region_obligation({:?}, cause={:?})", + region_obligation, region_obligation.cause); - region_obligations.entry(region_obligation.cause.body_id).or_insert(vec![]) - .push(region_obligation); + region_obligations.entry(region_obligation.cause.body_id) + .or_insert(vec![]) + .push(region_obligation); } diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index e7f11b06bd132..9d300c0973167 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -40,7 +40,7 @@ pub enum ObjectSafetyViolation<'tcx> { } /// Reasons a method might not be object-safe. -#[derive(Copy,Clone,Debug)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] pub enum MethodViolationCode { /// e.g., `fn foo()` StaticMethod, @@ -140,6 +140,8 @@ fn supertraits_reference_self<'tcx>(tcx: &ty::ctxt<'tcx>, .any(is_self) } ty::Predicate::Projection(..) | + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::TypeOutlives(..) | ty::Predicate::RegionOutlives(..) | ty::Predicate::Equate(..) => { @@ -181,6 +183,8 @@ fn generics_require_sized_self<'tcx>(tcx: &ty::ctxt<'tcx>, ty::Predicate::Trait(..) | ty::Predicate::Equate(..) | ty::Predicate::RegionOutlives(..) | + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::TypeOutlives(..) => { false } diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 0c9cf1a68b732..6c568b656c047 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -44,6 +44,7 @@ use middle::infer::{InferCtxt, TypeFreshener}; use middle::ty_fold::TypeFoldable; use middle::ty_match; use middle::ty_relate::TypeRelation; +use middle::wf; use std::cell::RefCell; use std::fmt; @@ -465,12 +466,31 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } + ty::Predicate::WellFormed(ty) => { + match wf::obligations(self.infcx, obligation.cause.body_id, + ty, obligation.cause.span, + obligation.cause.code.is_rfc1214()) { + Some(obligations) => + self.evaluate_predicates_recursively(previous_stack, obligations.iter()), + None => + EvaluatedToAmbig, + } + } + ty::Predicate::TypeOutlives(..) | ty::Predicate::RegionOutlives(..) => { // we do not consider region relationships when // evaluating trait matches EvaluatedToOk } + ty::Predicate::ObjectSafe(trait_def_id) => { + if object_safety::is_object_safe(self.tcx(), trait_def_id) { + EvaluatedToOk + } else { + EvaluatedToErr(Unimplemented) + } + } + ty::Predicate::Projection(ref data) => { self.infcx.probe(|_| { let project_obligation = obligation.with(data.clone()); diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index af9d5e5157d28..6df13a3bdaf55 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -10,7 +10,7 @@ use middle::subst::Substs; use middle::infer::InferCtxt; -use middle::ty::{self, Ty, ToPredicate, ToPolyTraitRef}; +use middle::ty::{self, HasTypeFlags, Ty, ToPredicate, ToPolyTraitRef}; use std::fmt; use syntax::ast; use syntax::codemap::Span; @@ -56,6 +56,12 @@ impl<'a,'tcx> PredicateSet<'a,'tcx> { ty::Predicate::Projection(ref data) => ty::Predicate::Projection(self.tcx.anonymize_late_bound_regions(data)), + + ty::Predicate::WellFormed(data) => + ty::Predicate::WellFormed(data), + + ty::Predicate::ObjectSafe(data) => + ty::Predicate::ObjectSafe(data), }; self.set.insert(normalized_pred) } @@ -136,6 +142,14 @@ impl<'cx, 'tcx> Elaborator<'cx, 'tcx> { self.stack.extend(predicates); } + ty::Predicate::WellFormed(..) => { + // Currently, we do not elaborate WF predicates, + // although we easily could. + } + ty::Predicate::ObjectSafe(..) => { + // Currently, we do not elaborate object-safe + // predicates. + } ty::Predicate::Equate(..) => { // Currently, we do not "elaborate" predicates like // `X == Y`, though conceivably we might. For example, @@ -562,3 +576,9 @@ impl<'tcx> fmt::Debug for super::MismatchedProjectionTypes<'tcx> { write!(f, "MismatchedProjectionTypes({:?})", self.err) } } + +impl<'tcx, T: HasTypeFlags> HasTypeFlags for Obligation<'tcx, T> { + fn has_type_flags(&self, flags: ty::TypeFlags) -> bool { + self.predicate.has_type_flags(flags) + } +} diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 7d807bf2431ff..393bb83067cc8 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2417,6 +2417,12 @@ pub enum Predicate<'tcx> { /// where ::Name == X, approximately. /// See `ProjectionPredicate` struct for details. Projection(PolyProjectionPredicate<'tcx>), + + /// no syntax: T WF + WellFormed(Ty<'tcx>), + + /// trait must be object-safe + ObjectSafe(ast::DefId), } impl<'tcx> Predicate<'tcx> { @@ -2502,6 +2508,10 @@ impl<'tcx> Predicate<'tcx> { Predicate::TypeOutlives(ty::Binder(data.subst(tcx, substs))), Predicate::Projection(ty::Binder(ref data)) => Predicate::Projection(ty::Binder(data.subst(tcx, substs))), + Predicate::WellFormed(data) => + Predicate::WellFormed(data.subst(tcx, substs)), + Predicate::ObjectSafe(trait_def_id) => + Predicate::ObjectSafe(trait_def_id), } } } @@ -2689,6 +2699,12 @@ impl<'tcx> Predicate<'tcx> { .chain(Some(data.0.ty)) .collect() } + ty::Predicate::WellFormed(data) => { + vec![data] + } + ty::Predicate::ObjectSafe(_trait_def_id) => { + vec![] + } }; // The only reason to collect into a vector here is that I was @@ -2706,6 +2722,8 @@ impl<'tcx> Predicate<'tcx> { Predicate::RegionOutlives(ref p) => p.has_escaping_regions(), Predicate::TypeOutlives(ref p) => p.has_escaping_regions(), Predicate::Projection(ref p) => p.has_escaping_regions(), + Predicate::WellFormed(p) => p.has_escaping_regions(), + Predicate::ObjectSafe(_trait_def_id) => false, } } @@ -2717,6 +2735,8 @@ impl<'tcx> Predicate<'tcx> { Predicate::Projection(..) | Predicate::Equate(..) | Predicate::RegionOutlives(..) | + Predicate::WellFormed(..) | + Predicate::ObjectSafe(..) | Predicate::TypeOutlives(..) => { None } @@ -6211,6 +6231,8 @@ impl<'tcx> ctxt<'tcx> { ty::Predicate::Projection(..) | ty::Predicate::Trait(..) | ty::Predicate::Equate(..) | + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::RegionOutlives(..) => { None } @@ -6712,6 +6734,8 @@ impl<'tcx> ctxt<'tcx> { ty::Predicate::Equate(..) | ty::Predicate::RegionOutlives(..) | ty::Predicate::TypeOutlives(..) | + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::Projection(..) => { // For now, assume all these where-clauses // may give drop implementation capabilty @@ -6956,6 +6980,8 @@ impl<'tcx> fmt::Debug for ty::Predicate<'tcx> { Predicate::RegionOutlives(ref pair) => write!(f, "{:?}", pair), Predicate::TypeOutlives(ref pair) => write!(f, "{:?}", pair), Predicate::Projection(ref pair) => write!(f, "{:?}", pair), + Predicate::WellFormed(ty) => write!(f, "WF({:?})", ty), + Predicate::ObjectSafe(trait_def_id) => write!(f, "ObjectSafe({:?})", trait_def_id), } } } @@ -7080,6 +7106,8 @@ impl<'tcx> RegionEscape for Predicate<'tcx> { Predicate::RegionOutlives(ref data) => data.has_regions_escaping_depth(depth), Predicate::TypeOutlives(ref data) => data.has_regions_escaping_depth(depth), Predicate::Projection(ref data) => data.has_regions_escaping_depth(depth), + Predicate::WellFormed(ty) => ty.has_regions_escaping_depth(depth), + Predicate::ObjectSafe(_trait_def_id) => false, } } } @@ -7238,6 +7266,8 @@ impl<'tcx> HasTypeFlags for Predicate<'tcx> { Predicate::RegionOutlives(ref data) => data.has_type_flags(flags), Predicate::TypeOutlives(ref data) => data.has_type_flags(flags), Predicate::Projection(ref data) => data.has_type_flags(flags), + Predicate::WellFormed(data) => data.has_type_flags(flags), + Predicate::ObjectSafe(_trait_def_id) => false, } } } diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index cc1efeaea080f..809ee8928afd7 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -394,6 +394,10 @@ impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> { ty::Predicate::TypeOutlives(binder.fold_with(folder)), ty::Predicate::Projection(ref binder) => ty::Predicate::Projection(binder.fold_with(folder)), + ty::Predicate::WellFormed(data) => + ty::Predicate::WellFormed(data.fold_with(folder)), + ty::Predicate::ObjectSafe(trait_def_id) => + ty::Predicate::ObjectSafe(trait_def_id), } } } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index da20f730babab..3e9a64a8eb61e 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -831,6 +831,11 @@ impl<'tcx> fmt::Display for ty::Predicate<'tcx> { ty::Predicate::RegionOutlives(ref predicate) => write!(f, "{}", predicate), ty::Predicate::TypeOutlives(ref predicate) => write!(f, "{}", predicate), ty::Predicate::Projection(ref predicate) => write!(f, "{}", predicate), + ty::Predicate::WellFormed(ty) => write!(f, "{} well-formed", ty), + ty::Predicate::ObjectSafe(trait_def_id) => + ty::tls::with(|tcx| { + write!(f, "the trait `{}` is object-safe", tcx.item_path_str(trait_def_id)) + }), } } } diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index cb5875ec8bcea..9098b241e5b1d 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -177,6 +177,8 @@ fn deduce_expectations_from_obligations<'a,'tcx>( ty::Predicate::Equate(..) => None, ty::Predicate::RegionOutlives(..) => None, ty::Predicate::TypeOutlives(..) => None, + ty::Predicate::WellFormed(..) => None, + ty::Predicate::ObjectSafe(..) => None, }; opt_trait_ref .and_then(|trait_ref| self_type_matches_expected_vid(fcx, trait_ref, expected_vid)) diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index 39e67beab583d..30a9d65661a36 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -254,9 +254,9 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>( /// This function is meant to by applied to the type for every /// expression in the program. pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, - typ: ty::Ty<'tcx>, - span: Span, - scope: region::CodeExtent) { + typ: ty::Ty<'tcx>, + span: Span, + scope: region::CodeExtent) { debug!("check_safety_of_destructor_if_necessary typ: {:?} scope: {:?}", typ, scope); diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index dabc09db68d8e..3c315e335c637 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -490,6 +490,8 @@ impl<'tcx> GetTypeParameterBounds<'tcx> for ty::GenericPredicates<'tcx> { } ty::Predicate::Equate(..) | ty::Predicate::RegionOutlives(..) | + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::Projection(..) => { false } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 52f69784b5cc7..04b1f8ee1b1d3 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -818,7 +818,9 @@ impl<'a> Clean for ty::Predicate<'a> { Predicate::Equate(ref pred) => pred.clean(cx), Predicate::RegionOutlives(ref pred) => pred.clean(cx), Predicate::TypeOutlives(ref pred) => pred.clean(cx), - Predicate::Projection(ref pred) => pred.clean(cx) + Predicate::Projection(ref pred) => pred.clean(cx), + Predicate::WellFormed(_) => panic!("not user writable"), + Predicate::ObjectSafe(_) => panic!("not user writable"), } } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index bcc90dc47d9df..08c6dcc7f872a 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -475,7 +475,7 @@ pub enum WherePredicate { /// A lifetime predicate, e.g. `'a: 'b+'c` RegionPredicate(WhereRegionPredicate), /// An equality predicate (unsupported) - EqPredicate(WhereEqPredicate) + EqPredicate(WhereEqPredicate), } /// A type bound, eg `for<'c> Foo: Send+Clone+'c` From ad47bd8a0f6f5284a8f937f5cd8a0a7e3df96991 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 10:37:17 -0400 Subject: [PATCH 04/38] Extend ParameterEnvironment to remember the free_id, and to be usable on more kind of items --- src/librustc/middle/ty.rs | 103 +++++++++++++++++++++------------ src/librustc/middle/ty_fold.rs | 1 + 2 files changed, 67 insertions(+), 37 deletions(-) diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 393bb83067cc8..9ccfce8d3049f 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2833,6 +2833,15 @@ pub struct ParameterEnvironment<'a, 'tcx:'a> { /// Caches the results of trait selection. This cache is used /// for things that have to do with the parameters in scope. pub selection_cache: traits::SelectionCache<'tcx>, + + /// Scope that is attached to free regions for this scope. This + /// is usually the id of the fn body, but for more abstract scopes + /// like structs we often use the node-id of the struct. + /// + /// FIXME(#3696). It would be nice to refactor so that free + /// regions don't have this implicit scope and instead introduce + /// relationships in the environment. + pub free_id: ast::NodeId, } impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { @@ -2846,6 +2855,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { implicit_region_bound: self.implicit_region_bound, caller_bounds: caller_bounds, selection_cache: traits::SelectionCache::new(), + free_id: self.free_id, } } @@ -2853,6 +2863,18 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { match cx.map.find(id) { Some(ast_map::NodeImplItem(ref impl_item)) => { match impl_item.node { + ast::TypeImplItem(_) => { + // associated types don't have their own entry (for some reason), + // so for now just grab environment for the impl + let impl_id = cx.map.get_parent(id); + let impl_def_id = ast_util::local_def(impl_id); + let scheme = cx.lookup_item_type(impl_def_id); + let predicates = cx.lookup_predicates(impl_def_id); + cx.construct_parameter_environment(impl_item.span, + &scheme.generics, + &predicates, + id) + } ast::ConstImplItem(_, _) => { let def_id = ast_util::local_def(id); let scheme = cx.lookup_item_type(def_id); @@ -2881,42 +2903,37 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { } } } - ast::TypeImplItem(_) => { - cx.sess.bug("ParameterEnvironment::for_item(): \ - can't create a parameter environment \ - for type impl items") - } ast::MacImplItem(_) => cx.sess.bug("unexpanded macro") } } Some(ast_map::NodeTraitItem(trait_item)) => { match trait_item.node { - ast::ConstTraitItem(_, ref default) => { - match *default { - Some(_) => { - let def_id = ast_util::local_def(id); - let scheme = cx.lookup_item_type(def_id); - let predicates = cx.lookup_predicates(def_id); - cx.construct_parameter_environment(trait_item.span, - &scheme.generics, - &predicates, - id) - } - None => { - cx.sess.bug("ParameterEnvironment::from_item(): \ - can't create a parameter environment \ - for const trait items without defaults") - } - } + ast::TypeTraitItem(..) => { + // associated types don't have their own entry (for some reason), + // so for now just grab environment for the trait + let trait_id = cx.map.get_parent(id); + let trait_def_id = ast_util::local_def(trait_id); + let trait_def = cx.lookup_trait_def(trait_def_id); + let predicates = cx.lookup_predicates(trait_def_id); + cx.construct_parameter_environment(trait_item.span, + &trait_def.generics, + &predicates, + id) } - ast::MethodTraitItem(_, None) => { - cx.sess.span_bug(trait_item.span, - "ParameterEnvironment::for_item(): - can't create a parameter \ - environment for required trait \ - methods") + ast::ConstTraitItem(..) => { + let def_id = ast_util::local_def(id); + let scheme = cx.lookup_item_type(def_id); + let predicates = cx.lookup_predicates(def_id); + cx.construct_parameter_environment(trait_item.span, + &scheme.generics, + &predicates, + id) } - ast::MethodTraitItem(_, Some(ref body)) => { + ast::MethodTraitItem(_, ref body) => { + // for the body-id, use the id of the body + // block, unless this is a trait method with + // no default, then fallback to the method id. + let body_id = body.as_ref().map(|b| b.id).unwrap_or(id); let method_def_id = ast_util::local_def(id); match cx.impl_or_trait_item(method_def_id) { MethodTraitItem(ref method_ty) => { @@ -2926,7 +2943,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { trait_item.span, method_generics, method_bounds, - body.id) + body_id) } _ => { cx.sess @@ -2936,11 +2953,6 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { } } } - ast::TypeTraitItem(..) => { - cx.sess.bug("ParameterEnvironment::from_item(): \ - can't create a parameter environment \ - for type trait items") - } } } Some(ast_map::NodeItem(item)) => { @@ -2969,6 +2981,15 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> { &predicates, id) } + ast::ItemTrait(..) => { + let def_id = ast_util::local_def(id); + let trait_def = cx.lookup_trait_def(def_id); + let predicates = cx.lookup_predicates(def_id); + cx.construct_parameter_environment(item.span, + &trait_def.generics, + &predicates, + id) + } _ => { cx.sess.span_bug(item.span, "ParameterEnvironment::from_item(): @@ -6587,12 +6608,19 @@ impl<'tcx> ctxt<'tcx> { /// Construct a parameter environment suitable for static contexts or other contexts where there /// are no free type/lifetime parameters in scope. - pub fn empty_parameter_environment<'a>(&'a self) -> ParameterEnvironment<'a,'tcx> { + pub fn empty_parameter_environment<'a>(&'a self) + -> ParameterEnvironment<'a,'tcx> { ty::ParameterEnvironment { tcx: self, free_substs: Substs::empty(), caller_bounds: Vec::new(), implicit_region_bound: ty::ReEmpty, - selection_cache: traits::SelectionCache::new(), } + selection_cache: traits::SelectionCache::new(), + + // for an empty parameter + // environment, there ARE no free + // regions, so it shouldn't matter + // what we use for the free id + free_id: ast::DUMMY_NODE_ID } } /// Constructs and returns a substitution that can be applied to move from @@ -6676,6 +6704,7 @@ impl<'tcx> ctxt<'tcx> { implicit_region_bound: ty::ReScope(free_id_outlive.to_code_extent()), caller_bounds: predicates, selection_cache: traits::SelectionCache::new(), + free_id: free_id, }; let cause = traits::ObligationCause::misc(span, free_id); diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 809ee8928afd7..09c50804e836b 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -547,6 +547,7 @@ impl<'a, 'tcx> TypeFoldable<'tcx> for ty::ParameterEnvironment<'a, 'tcx> where ' implicit_region_bound: self.implicit_region_bound.fold_with(folder), caller_bounds: self.caller_bounds.fold_with(folder), selection_cache: traits::SelectionCache::new(), + free_id: self.free_id, } } } From 8d98877112d4deb3786de521457418757e010c69 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 09:39:54 -0400 Subject: [PATCH 05/38] Implement a new wfcheck to replace the old wf; this new code only issues warnings. It also checks more conditions than the old code. Keep the old wf code around unchanged so that we can continue to issue errors for the cases where we used to report errors. As part of this, remove the where-clauses-must-reference-parameter rule, which is easily circumvented. --- src/librustc_typeck/check/method/confirm.rs | 4 +- src/librustc_typeck/check/method/probe.rs | 2 + src/librustc_typeck/check/mod.rs | 110 ++- src/librustc_typeck/check/regionck.rs | 148 ++-- src/librustc_typeck/check/wf.rs | 33 +- src/librustc_typeck/check/wfcheck.rs | 630 ++++++++++++++++++ src/librustc_typeck/coherence/overlap.rs | 11 +- src/librustc_typeck/lib.rs | 16 +- .../where-clauses-not-parameter.rs | 45 -- 9 files changed, 854 insertions(+), 145 deletions(-) create mode 100644 src/librustc_typeck/check/wfcheck.rs delete mode 100644 src/test/compile-fail/where-clauses-not-parameter.rs diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index e9869e2a00e5d..d84cbe1f879e6 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -432,7 +432,9 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { traits::ObligationCause::misc(self.span, self.fcx.body_id), method_predicates); - self.fcx.add_default_region_param_bounds( + // this is a projection from a trait reference, so we have to + // make sure that the trait reference inputs are well-formed. + self.fcx.add_wf_bounds( all_substs, self.call_expr); } diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 2ff40b3590d29..f8235ace3dd6a 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -480,6 +480,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { ty::Predicate::Equate(..) | ty::Predicate::Projection(..) | ty::Predicate::RegionOutlives(..) | + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::TypeOutlives(..) => { None } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 86d6d404fb080..df8a80792a342 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -90,7 +90,7 @@ use middle::infer; use middle::infer::type_variable; use middle::pat_util::{self, pat_id_map}; use middle::privacy::{AllPublic, LastMod}; -use middle::region::{self, CodeExtent}; +use middle::region::{self}; use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace, TypeSpace}; use middle::traits::{self, report_fulfillment_errors}; use middle::ty::{FnSig, GenericPredicates, TypeScheme}; @@ -133,7 +133,8 @@ pub mod coercion; pub mod demand; pub mod method; mod upvar; -pub mod wf; +mod wf; +mod wfcheck; mod cast; mod closure; mod callee; @@ -382,7 +383,12 @@ impl<'a, 'tcx> Visitor<'tcx> for CheckItemBodiesVisitor<'a, 'tcx> { } } -pub fn check_item_types(ccx: &CrateCtxt) { +pub fn check_wf_old(ccx: &CrateCtxt) { + // FIXME(#25759). The new code below is much more reliable but (for now) + // only generates warnings. So as to ensure that we continue + // getting errors where we used to get errors, we run the old wf + // code first and abort if it encounters any errors. If no abort + // comes, we run the new code and issue warnings. let krate = ccx.tcx.map.krate(); let mut visit = wf::CheckTypeWellFormedVisitor::new(ccx); visit::walk_crate(&mut visit, krate); @@ -390,17 +396,34 @@ pub fn check_item_types(ccx: &CrateCtxt) { // If types are not well-formed, it leads to all manner of errors // downstream, so stop reporting errors at this point. ccx.tcx.sess.abort_if_errors(); +} - let mut visit = CheckItemTypesVisitor { ccx: ccx }; +pub fn check_wf_new(ccx: &CrateCtxt) { + let krate = ccx.tcx.map.krate(); + let mut visit = wfcheck::CheckTypeWellFormedVisitor::new(ccx); visit::walk_crate(&mut visit, krate); + // If types are not well-formed, it leads to all manner of errors + // downstream, so stop reporting errors at this point. ccx.tcx.sess.abort_if_errors(); +} +pub fn check_item_types(ccx: &CrateCtxt) { + let krate = ccx.tcx.map.krate(); + let mut visit = CheckItemTypesVisitor { ccx: ccx }; + visit::walk_crate(&mut visit, krate); + ccx.tcx.sess.abort_if_errors(); +} + +pub fn check_item_bodies(ccx: &CrateCtxt) { + let krate = ccx.tcx.map.krate(); let mut visit = CheckItemBodiesVisitor { ccx: ccx }; visit::walk_crate(&mut visit, krate); ccx.tcx.sess.abort_if_errors(); +} +pub fn check_drop_impls(ccx: &CrateCtxt) { for drop_method_did in ccx.tcx.destructors.borrow().iter() { if drop_method_did.krate == ast::LOCAL_CRATE { let drop_impl_did = ccx.tcx.map.get_parent_did(drop_method_did.node); @@ -586,7 +609,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>, if let ty::FnConverging(ret_ty) = ret_ty { fcx.require_type_is_sized(ret_ty, decl.output.span(), traits::ReturnType); - fn_sig_tys.push(ret_ty); + fn_sig_tys.push(ret_ty); // FIXME(#25759) just take implied bounds from the arguments } debug!("fn-sig-map: fn_id={} fn_sig_tys={:?}", @@ -600,6 +623,14 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>, // Add formal parameters. for (arg_ty, input) in arg_tys.iter().zip(&decl.inputs) { + // The type of the argument must be well-formed. + // + // NB -- this is now checked in wfcheck, but that + // currently only results in warnings, so we issue an + // old-style WF obligation here so that we still get the + // errors that we used to get. + fcx.register_old_wf_obligation(arg_ty, input.ty.span, traits::MiscObligation); + // Create type variables for each argument. pat_util::pat_bindings( &tcx.def_map, @@ -1507,10 +1538,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub fn to_ty(&self, ast_t: &ast::Ty) -> Ty<'tcx> { let t = ast_ty_to_ty(self, self, ast_t); - let mut bounds_checker = wf::BoundsChecker::new(self, - self.body_id, - None); - bounds_checker.check_ty(t, ast_t.span); + // Generally speaking, we must check that types entered by the + // user are well-formed. This is not true for `_`, since those + // types are generated by inference. Now, you might think that + // we could as well generate a WF obligation -- but + // unfortunately that breaks code like `foo as *const _`, + // because those type variables wind up being unconstrained + // until very late. Nasty. Probably it'd be best to refactor + // that code path, but that's tricky because of + // defaults. Argh! + match ast_t.node { + ast::TyInfer => { } + _ => { self.register_wf_obligation(t, ast_t.span, traits::MiscObligation); } + } t } @@ -1629,15 +1669,38 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fulfillment_cx.register_region_obligation(ty, region, cause); } - pub fn add_default_region_param_bounds(&self, - substs: &Substs<'tcx>, - expr: &ast::Expr) + /// Registers an obligation for checking later, during regionck, that the type `ty` must + /// outlive the region `r`. + pub fn register_wf_obligation(&self, + ty: Ty<'tcx>, + span: Span, + code: traits::ObligationCauseCode<'tcx>) + { + // WF obligations never themselves fail, so no real need to give a detailed cause: + let cause = traits::ObligationCause::new(span, self.body_id, code); + self.register_predicate(traits::Obligation::new(cause, ty::Predicate::WellFormed(ty))); + } + + pub fn register_old_wf_obligation(&self, + ty: Ty<'tcx>, + span: Span, + code: traits::ObligationCauseCode<'tcx>) + { + // Registers an "old-style" WF obligation that uses the + // implicator code. This is basically a buggy version of + // `register_wf_obligation` that is being kept around + // temporarily just to help with phasing in the newer rules. + // + // FIXME(#27579) all uses of this should be migrated to register_wf_obligation eventually + let cause = traits::ObligationCause::new(span, self.body_id, code); + self.register_region_obligation(ty, ty::ReEmpty, cause); + } + + /// Registers obligations that all types appearing in `substs` are well-formed. + pub fn add_wf_bounds(&self, substs: &Substs<'tcx>, expr: &ast::Expr) { for &ty in &substs.types { - let default_bound = ty::ReScope(CodeExtent::from_node_id(expr.id)); - let cause = traits::ObligationCause::new(expr.span, self.body_id, - traits::MiscObligation); - self.register_region_obligation(ty, default_bound, cause); + self.register_wf_obligation(ty, expr.span, traits::MiscObligation); } } @@ -2477,7 +2540,8 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, Expectation::rvalue_hint(fcx.tcx(), ty) }); - check_expr_with_unifier(fcx, &**arg, + check_expr_with_unifier(fcx, + &**arg, expected.unwrap_or(ExpectHasType(formal_ty)), NoPreference, || { // 2. Coerce to the most detailed type that could be coerced @@ -3362,7 +3426,9 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // We always require that the type provided as the value for // a type parameter outlives the moment of instantiation. - constrain_path_type_parameters(fcx, expr); + fcx.opt_node_ty_substs(expr.id, |item_substs| { + fcx.add_wf_bounds(&item_substs.substs, expr); + }); } ast::ExprInlineAsm(ref ia) => { for &(_, ref input) in &ia.inputs { @@ -3903,14 +3969,6 @@ pub fn resolve_ty_and_def_ufcs<'a, 'b, 'tcx>(fcx: &FnCtxt<'b, 'tcx>, } } -fn constrain_path_type_parameters(fcx: &FnCtxt, - expr: &ast::Expr) -{ - fcx.opt_node_ty_substs(expr.id, |item_substs| { - fcx.add_default_region_param_bounds(&item_substs.substs, expr); - }); -} - impl<'tcx> Expectation<'tcx> { /// Provide an expectation for an rvalue expression given an *optional* /// hint, which is not required for type safety (the resulting type might diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index aeac38dab9047..925ea11690125 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -86,15 +86,19 @@ use astconv::AstConv; use check::dropck; use check::FnCtxt; use middle::free_region::FreeRegionMap; -use middle::implicator; +use middle::implicator::{self, Implication}; use middle::mem_categorization as mc; +use middle::outlives; use middle::region::CodeExtent; +use middle::subst::Substs; use middle::traits; -use middle::ty::{self, ReScope, Ty, MethodCall, HasTypeFlags}; -use middle::infer::{self, GenericKind}; +use middle::ty::{self, RegionEscape, ReScope, Ty, MethodCall, HasTypeFlags}; +use middle::infer::{self, GenericKind, InferCtxt, SubregionOrigin, VerifyBound}; use middle::pat_util; +use middle::wf::{self, ImpliedBound}; use std::mem; +use std::rc::Rc; use syntax::{ast, ast_util}; use syntax::codemap::Span; use syntax::visit; @@ -120,12 +124,19 @@ pub fn regionck_expr(fcx: &FnCtxt, e: &ast::Expr) { rcx.resolve_regions_and_report_errors(); } -pub fn regionck_item(fcx: &FnCtxt, item: &ast::Item) { - let mut rcx = Rcx::new(fcx, RepeatingScope(item.id), item.id, Subject(item.id)); +/// Region checking during the WF phase for items. `wf_tys` are the +/// types from which we should derive implied bounds, if any. +pub fn regionck_item<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>, + item_id: ast::NodeId, + span: Span, + wf_tys: &[Ty<'tcx>]) { + debug!("regionck_item(item.id={:?}, wf_tys={:?}", item_id, wf_tys); + let mut rcx = Rcx::new(fcx, RepeatingScope(item_id), item_id, Subject(item_id)); let tcx = fcx.tcx(); rcx.free_region_map .relate_free_regions_from_predicates(tcx, &fcx.infcx().parameter_environment.caller_bounds); - rcx.visit_region_obligations(item.id); + rcx.relate_free_regions(wf_tys, item_id, span); + rcx.visit_region_obligations(item_id); rcx.resolve_regions_and_report_errors(); } @@ -154,22 +165,6 @@ pub fn regionck_fn(fcx: &FnCtxt, fcx.tcx().store_free_region_map(fn_id, rcx.free_region_map); } -/// Checks that the types in `component_tys` are well-formed. This will add constraints into the -/// region graph. Does *not* run `resolve_regions_and_report_errors` and so forth. -pub fn regionck_ensure_component_tys_wf<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, - span: Span, - component_tys: &[Ty<'tcx>]) { - let mut rcx = Rcx::new(fcx, RepeatingScope(0), 0, SubjectNode::None); - for &component_ty in component_tys { - // Check that each type outlives the empty region. Since the - // empty region is a subregion of all others, this can't fail - // unless the type does not meet the well-formedness - // requirements. - type_must_outlive(&mut rcx, infer::RelateParamBound(span, component_ty), - component_ty, ty::ReEmpty); - } -} - /////////////////////////////////////////////////////////////////////////// // INTERNALS @@ -213,6 +208,10 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { self.fcx.ccx.tcx } + pub fn infcx(&self) -> &InferCtxt<'a,'tcx> { + self.fcx.infcx() + } + fn set_body_id(&mut self, body_id: ast::NodeId) -> ast::NodeId { mem::replace(&mut self.body_id, body_id) } @@ -325,11 +324,16 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { .to_vec(); for r_o in ®ion_obligations { - debug!("visit_region_obligations: r_o={:?}", - r_o); + debug!("visit_region_obligations: r_o={:?} cause={:?}", + r_o, r_o.cause); let sup_type = self.resolve_type(r_o.sup_type); - let origin = infer::RelateParamBound(r_o.cause.span, sup_type); - type_must_outlive(self, origin, sup_type, r_o.sub_region); + let origin = self.code_to_origin(r_o.cause.span, sup_type, &r_o.cause.code); + + if r_o.sub_region != ty::ReEmpty { + type_must_outlive(self, origin, sup_type, r_o.sub_region); + } else { + self.visit_old_school_wf(node_id, sup_type, origin); + } } // Processing the region obligations should not cause the list to grow further: @@ -337,6 +341,62 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { self.fcx.inh.infcx.fulfillment_cx.borrow().region_obligations(node_id).len()); } + fn visit_old_school_wf(&mut self, + body_id: ast::NodeId, + ty: Ty<'tcx>, + origin: infer::SubregionOrigin<'tcx>) { + // As a weird kind of hack, we use a region of empty as a signal + // to mean "old-school WF rules". The only reason the old-school + // WF rules are not encoded using WF is that this leads to errors, + // and we want to phase those in gradually. + + // FIXME(#27579) remove this weird special case once we phase in new WF rules completely + let implications = implicator::implications(self.infcx(), + body_id, + ty, + ty::ReEmpty, + origin.span()); + let origin_for_ty = |ty: Option>| match ty { + None => origin.clone(), + Some(ty) => infer::ReferenceOutlivesReferent(ty, origin.span()), + }; + for implication in implications { + match implication { + Implication::RegionSubRegion(ty, r1, r2) => { + self.fcx.mk_subr(origin_for_ty(ty), r1, r2); + } + Implication::RegionSubGeneric(ty, r1, GenericKind::Param(param_ty)) => { + param_ty_must_outlive(self, origin_for_ty(ty), r1, param_ty); + } + Implication::RegionSubGeneric(ty, r1, GenericKind::Projection(proj_ty)) => { + projection_must_outlive(self, origin_for_ty(ty), r1, proj_ty); + } + Implication::Predicate(def_id, predicate) => { + let cause = traits::ObligationCause::new(origin.span(), + body_id, + traits::ItemObligation(def_id)); + let obligation = traits::Obligation::new(cause, predicate); + self.fcx.register_predicate(obligation); + } + } + } + } + + fn code_to_origin(&self, + span: Span, + sup_type: Ty<'tcx>, + code: &traits::ObligationCauseCode<'tcx>) + -> SubregionOrigin<'tcx> { + match *code { + traits::ObligationCauseCode::RFC1214(ref code) => + infer::RFC1214Subregion(Rc::new(self.code_to_origin(span, sup_type, code))), + traits::ObligationCauseCode::ReferenceOutlivesReferent(ref_type) => + infer::ReferenceOutlivesReferent(ref_type, span), + _ => + infer::RelateParamBound(span, sup_type), + } + } + /// This method populates the region map's `free_region_map`. It walks over the transformed /// argument and return types for each function just before we check the body of that function, /// looking for types where you have a borrowed pointer to other borrowed data (e.g., `&'a &'b @@ -356,33 +416,28 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { for &ty in fn_sig_tys { let ty = self.resolve_type(ty); debug!("relate_free_regions(t={:?})", ty); - let body_scope = CodeExtent::from_node_id(body_id); - let body_scope = ty::ReScope(body_scope); - let implications = implicator::implications(self.fcx.infcx(), body_id, - ty, body_scope, span); + let implied_bounds = wf::implied_bounds(self.fcx.infcx(), body_id, ty, span); // Record any relations between free regions that we observe into the free-region-map. - self.free_region_map.relate_free_regions_from_implications(&implications); + self.free_region_map.relate_free_regions_from_implied_bounds(&implied_bounds); // But also record other relationships, such as `T:'x`, // that don't go into the free-region-map but which we use // here. - for implication in implications { + for implication in implied_bounds { debug!("implication: {:?}", implication); match implication { - implicator::Implication::RegionSubRegion(_, - ty::ReFree(free_a), - ty::ReInfer(ty::ReVar(vid_b))) => { + ImpliedBound::RegionSubRegion(ty::ReFree(free_a), + ty::ReInfer(ty::ReVar(vid_b))) => { self.fcx.inh.infcx.add_given(free_a, vid_b); } - implicator::Implication::RegionSubGeneric(_, r_a, ref generic_b) => { - debug!("RegionSubGeneric: {:?} <= {:?}", - r_a, generic_b); - - self.region_bound_pairs.push((r_a, generic_b.clone())); + ImpliedBound::RegionSubParam(r_a, param_b) => { + self.region_bound_pairs.push((r_a, GenericKind::Param(param_b))); } - implicator::Implication::RegionSubRegion(..) | - implicator::Implication::Predicate(..) => { + ImpliedBound::RegionSubProjection(r_a, projection_b) => { + self.region_bound_pairs.push((r_a, GenericKind::Projection(projection_b))); + } + ImpliedBound::RegionSubRegion(..) => { // In principle, we could record (and take // advantage of) every relationship here, but // we are also free not to -- it simply means @@ -492,12 +547,11 @@ fn constrain_bindings_in_pat(pat: &ast::Pat, rcx: &mut Rcx) { // that the lifetime of any regions that appear in a // variable's type enclose at least the variable's scope. - let var_region = tcx.region_maps.var_region(id); - type_of_node_must_outlive( - rcx, infer::BindingTypeIsNotValidAtDecl(span), - id, var_region); - let var_scope = tcx.region_maps.var_scope(id); + + let origin = infer::BindingTypeIsNotValidAtDecl(span); + type_of_node_must_outlive(rcx, origin, id, ty::ReScope(var_scope)); + let typ = rcx.resolve_node_type(id); dropck::check_safety_of_destructor_if_necessary(rcx, typ, span, var_scope); }) diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index 7790a29db12f7..21f48d37799e7 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -9,7 +9,7 @@ // except according to those terms. use astconv::AstConv; -use check::{FnCtxt, Inherited, blank_fn_ctxt, regionck}; +use check::{FnCtxt, Inherited, blank_fn_ctxt, regionck, wfcheck}; use constrained_type_params::{identify_constrained_type_params, Parameter}; use CrateCtxt; use middle::region; @@ -23,7 +23,7 @@ use std::collections::HashSet; use syntax::ast; use syntax::ast_util::local_def; use syntax::codemap::{DUMMY_SP, Span}; -use syntax::parse::token::special_idents; +use syntax::parse::token::{special_idents}; use syntax::visit; use syntax::visit::Visitor; @@ -86,9 +86,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { Some(ty::BoundSend) | Some(ty::BoundSync) => {} Some(_) | None => { if !ccx.tcx.trait_has_default_impl(trait_ref.def_id) { - span_err!(ccx.tcx.sess, item.span, E0192, - "negative impls are only allowed for traits with \ - default impls (e.g., `Send` and `Sync`)") + wfcheck::error_192(ccx, item.span); } } } @@ -122,9 +120,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { reject_non_type_param_bounds(ccx.tcx, item.span, &trait_predicates); if ccx.tcx.trait_has_default_impl(local_def(item.id)) { if !items.is_empty() { - span_err!(ccx.tcx.sess, item.span, E0380, - "traits with default impls (`e.g. unsafe impl \ - Trait for ..`) must have no methods or associated items") + wfcheck::error_380(ccx, item.span); } } } @@ -149,7 +145,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(type_scheme.ty), item.id); f(self, &fcx); fcx.select_all_obligations_or_error(); - regionck::regionck_item(&fcx, item); + regionck::regionck_item(&fcx, item.id, item.span, &[]); } /// In a type definition, we check that to ensure that the types of the fields are well-formed. @@ -185,8 +181,9 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { let field_tys: Vec = variants.iter().flat_map(|v| v.fields.iter().map(|f| f.ty)).collect(); - regionck::regionck_ensure_component_tys_wf( - fcx, item.span, &field_tys); + for &field_ty in &field_tys { + fcx.register_wf_obligation(field_ty, item.span, traits::MiscObligation); + } }); } @@ -355,8 +352,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { span: Span, param_name: ast::Name) { - span_err!(self.tcx().sess, span, E0392, - "parameter `{}` is never used", param_name); + wfcheck::error_392(self.tcx(), span, param_name); let suggested_marker_id = self.tcx().lang_items.phantom_data(); match suggested_marker_id { @@ -420,9 +416,7 @@ fn reject_shadowing_type_parameters<'tcx>(tcx: &ty::ctxt<'tcx>, for method_param in generics.types.get_slice(subst::FnSpace) { if impl_params.contains(&method_param.name) { - span_err!(tcx.sess, span, E0194, - "type parameter `{}` shadows another type parameter of the same name", - method_param.name); + wfcheck::error_194(tcx, span, method_param.name); } } } @@ -521,11 +515,6 @@ impl<'cx,'tcx> BoundsChecker<'cx,'tcx> { } } - pub fn check_ty(&mut self, ty: Ty<'tcx>, span: Span) { - self.span = span; - ty.fold_with(self); - } - fn check_traits_in_ty(&mut self, ty: Ty<'tcx>, span: Span) { self.span = span; // When checking types outside of a type def'n, we ignore @@ -709,6 +698,8 @@ fn filter_to_trait_obligations<'tcx>(bounds: ty::InstantiatedPredicates<'tcx>) ty::Predicate::Projection(..) => { result.predicates.push(space, predicate.clone()) } + ty::Predicate::WellFormed(..) | + ty::Predicate::ObjectSafe(..) | ty::Predicate::Equate(..) | ty::Predicate::TypeOutlives(..) | ty::Predicate::RegionOutlives(..) => { diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs new file mode 100644 index 0000000000000..03e6ae2dd1545 --- /dev/null +++ b/src/librustc_typeck/check/wfcheck.rs @@ -0,0 +1,630 @@ +// Copyright 2014 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 astconv::AstConv; +use check::{FnCtxt, Inherited, blank_fn_ctxt, regionck}; +use constrained_type_params::{identify_constrained_type_params, Parameter}; +use CrateCtxt; +use middle::region::DestructionScopeData; +use middle::subst::{self, TypeSpace, FnSpace, ParamSpace, SelfSpace}; +use middle::traits; +use middle::ty::{self, Ty}; +use middle::ty_fold::{TypeFolder}; +use middle::wf; + +use std::cell::RefCell; +use std::collections::HashSet; +use std::rc::Rc; +use syntax::ast; +use syntax::ast_util::local_def; +use syntax::codemap::{Span}; +use syntax::parse::token::{special_idents}; +use syntax::ptr::P; +use syntax::visit; +use syntax::visit::Visitor; + +pub struct CheckTypeWellFormedVisitor<'ccx, 'tcx:'ccx> { + ccx: &'ccx CrateCtxt<'ccx, 'tcx>, + code: traits::ObligationCauseCode<'tcx>, +} + +impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { + pub fn new(ccx: &'ccx CrateCtxt<'ccx, 'tcx>) + -> CheckTypeWellFormedVisitor<'ccx, 'tcx> { + CheckTypeWellFormedVisitor { + ccx: ccx, + code: traits::ObligationCauseCode::RFC1214( + Rc::new(traits::ObligationCauseCode::MiscObligation)) + } + } + + fn tcx(&self) -> &ty::ctxt<'tcx> { + self.ccx.tcx + } + + /// 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: &ast::Item) { + let ccx = self.ccx; + debug!("check_item_well_formed(it.id={}, it.ident={})", + item.id, + ccx.tcx.item_path_str(local_def(item.id))); + + match item.node { + /// Right now we check that every default trait implementation + /// has an implementation of itself. Basically, a case like: + /// + /// `impl Trait for T {}` + /// + /// has a requirement of `T: Trait` which was required for default + /// method implementations. Although this could be improved now that + /// there's a better infrastructure in place for this, it's being left + /// for a follow-up work. + /// + /// Since there's such a requirement, we need to check *just* positive + /// implementations, otherwise things like: + /// + /// impl !Send for T {} + /// + /// won't be allowed unless there's an *explicit* implementation of `Send` + /// for `T` + ast::ItemImpl(_, ast::ImplPolarity::Positive, _, + ref trait_ref, ref self_ty, _) => { + self.check_impl(item, self_ty, trait_ref); + } + ast::ItemImpl(_, ast::ImplPolarity::Negative, _, Some(_), _, _) => { + // FIXME(#27579) what amount of WF checking do we need for neg impls? + + let trait_ref = ccx.tcx.impl_trait_ref(local_def(item.id)).unwrap(); + ccx.tcx.populate_implementations_for_trait_if_necessary(trait_ref.def_id); + match ccx.tcx.lang_items.to_builtin_kind(trait_ref.def_id) { + Some(ty::BoundSend) | Some(ty::BoundSync) => {} + Some(_) | None => { + if !ccx.tcx.trait_has_default_impl(trait_ref.def_id) { + error_192(ccx, item.span); + } + } + } + } + ast::ItemFn(_, _, _, _, _, ref body) => { + self.check_item_fn(item, body); + } + ast::ItemStatic(..) => { + self.check_item_type(item); + } + ast::ItemConst(..) => { + self.check_item_type(item); + } + ast::ItemStruct(ref struct_def, ref ast_generics) => { + self.check_type_defn(item, |fcx| { + vec![struct_variant(fcx, &**struct_def)] + }); + + self.check_variances_for_type_defn(item, ast_generics); + } + ast::ItemEnum(ref enum_def, ref ast_generics) => { + self.check_type_defn(item, |fcx| { + enum_variants(fcx, enum_def) + }); + + self.check_variances_for_type_defn(item, ast_generics); + } + ast::ItemTrait(_, _, _, ref items) => { + self.check_trait(item, items); + } + _ => {} + } + } + + fn check_trait_or_impl_item(&mut self, item_id: ast::NodeId, span: Span) { + let code = self.code.clone(); + self.with_fcx(item_id, span, |fcx, this| { + let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; + let free_id = fcx.inh.infcx.parameter_environment.free_id; + + let item = fcx.tcx().impl_or_trait_item(local_def(item_id)); + + let mut implied_bounds = match item.container() { + ty::TraitContainer(_) => vec![], + ty::ImplContainer(def_id) => impl_implied_bounds(fcx, def_id, span) + }; + + match item { + ty::ConstTraitItem(assoc_const) => { + let ty = fcx.instantiate_type_scheme(span, free_substs, &assoc_const.ty); + fcx.register_wf_obligation(ty, span, code.clone()); + } + ty::MethodTraitItem(method) => { + reject_shadowing_type_parameters(fcx.tcx(), span, &method.generics); + let method_ty = fcx.instantiate_type_scheme(span, free_substs, &method.fty); + let predicates = fcx.instantiate_bounds(span, free_substs, &method.predicates); + this.check_fn_or_method(fcx, span, &method_ty, &predicates, + free_id, &mut implied_bounds); + } + ty::TypeTraitItem(assoc_type) => { + if let Some(ref ty) = assoc_type.ty { + let ty = fcx.instantiate_type_scheme(span, free_substs, ty); + fcx.register_wf_obligation(ty, span, code.clone()); + } + } + } + + implied_bounds + }) + } + + fn with_item_fcx(&mut self, item: &ast::Item, f: F) where + F: for<'fcx> FnMut(&FnCtxt<'fcx, 'tcx>, + &mut CheckTypeWellFormedVisitor<'ccx,'tcx>) -> Vec>, + { + self.with_fcx(item.id, item.span, f) + } + + fn with_fcx(&mut self, id: ast::NodeId, span: Span, mut f: F) where + F: for<'fcx> FnMut(&FnCtxt<'fcx, 'tcx>, + &mut CheckTypeWellFormedVisitor<'ccx,'tcx>) -> Vec>, + { + let ccx = self.ccx; + let param_env = ty::ParameterEnvironment::for_item(ccx.tcx, id); + let tables = RefCell::new(ty::Tables::empty()); + let inh = Inherited::new(ccx.tcx, &tables, param_env); + let fcx = blank_fn_ctxt(ccx, &inh, ty::FnDiverging, id); + let wf_tys = f(&fcx, self); + fcx.select_all_obligations_or_error(); + regionck::regionck_item(&fcx, id, span, &wf_tys); + } + + /// In a type definition, we check that to ensure that the types of the fields are well-formed. + fn check_type_defn(&mut self, item: &ast::Item, mut lookup_fields: F) where + F: for<'fcx> FnMut(&FnCtxt<'fcx, 'tcx>) -> Vec>, + { + self.with_item_fcx(item, |fcx, this| { + let variants = lookup_fields(fcx); + + for variant in &variants { + // For DST, all intermediate types must be sized. + if let Some((_, fields)) = variant.fields.split_last() { + for field in fields { + fcx.register_builtin_bound( + field.ty, + ty::BoundSized, + traits::ObligationCause::new(field.span, + fcx.body_id, + traits::FieldSized)); + } + } + + // All field types must be well-formed. + for field in &variant.fields { + fcx.register_wf_obligation(field.ty, field.span, this.code.clone()) + } + } + + let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; + let predicates = fcx.tcx().lookup_predicates(local_def(item.id)); + let predicates = fcx.instantiate_bounds(item.span, free_substs, &predicates); + this.check_where_clauses(fcx, item.span, &predicates); + + vec![] // no implied bounds in a struct def'n + }); + } + + fn check_trait(&mut self, + item: &ast::Item, + items: &[P]) + { + let trait_def_id = local_def(item.id); + + if self.ccx.tcx.trait_has_default_impl(trait_def_id) { + if !items.is_empty() { + error_380(self.ccx, item.span); + } + } + + self.with_item_fcx(item, |fcx, this| { + let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; + let predicates = fcx.tcx().lookup_predicates(trait_def_id); + let predicates = fcx.instantiate_bounds(item.span, free_substs, &predicates); + this.check_where_clauses(fcx, item.span, &predicates); + vec![] + }); + } + + fn check_item_fn(&mut self, + item: &ast::Item, + body: &ast::Block) + { + self.with_item_fcx(item, |fcx, this| { + let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; + let type_scheme = fcx.tcx().lookup_item_type(local_def(item.id)); + let item_ty = fcx.instantiate_type_scheme(item.span, free_substs, &type_scheme.ty); + let bare_fn_ty = match item_ty.sty { + ty::TyBareFn(_, ref bare_fn_ty) => bare_fn_ty, + _ => { + this.tcx().sess.span_bug(item.span, "Fn item without bare fn type"); + } + }; + + let predicates = fcx.tcx().lookup_predicates(local_def(item.id)); + let predicates = fcx.instantiate_bounds(item.span, free_substs, &predicates); + + let mut implied_bounds = vec![]; + this.check_fn_or_method(fcx, item.span, bare_fn_ty, &predicates, + body.id, &mut implied_bounds); + implied_bounds + }) + } + + fn check_item_type(&mut self, + item: &ast::Item) + { + debug!("check_item_type: {:?}", item); + + self.with_item_fcx(item, |fcx, this| { + let type_scheme = fcx.tcx().lookup_item_type(local_def(item.id)); + let item_ty = fcx.instantiate_type_scheme(item.span, + &fcx.inh + .infcx + .parameter_environment + .free_substs, + &type_scheme.ty); + + fcx.register_wf_obligation(item_ty, item.span, this.code.clone()); + + vec![] // no implied bounds in a const etc + }); + } + + fn check_impl(&mut self, + item: &ast::Item, + ast_self_ty: &ast::Ty, + ast_trait_ref: &Option) + { + debug!("check_impl: {:?}", item); + + self.with_item_fcx(item, |fcx, this| { + let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; + let item_def_id = local_def(item.id); + + match *ast_trait_ref { + Some(ref ast_trait_ref) => { + let trait_ref = fcx.tcx().impl_trait_ref(item_def_id).unwrap(); + let trait_ref = + fcx.instantiate_type_scheme( + ast_trait_ref.path.span, free_substs, &trait_ref); + let obligations = + wf::trait_obligations(fcx.infcx(), + fcx.body_id, + &trait_ref, + ast_trait_ref.path.span, + true); + for obligation in obligations { + fcx.register_predicate(obligation); + } + } + None => { + let self_ty = fcx.tcx().node_id_to_type(item.id); + let self_ty = fcx.instantiate_type_scheme(item.span, free_substs, &self_ty); + fcx.register_wf_obligation(self_ty, ast_self_ty.span, this.code.clone()); + } + } + + let predicates = fcx.tcx().lookup_predicates(item_def_id); + let predicates = fcx.instantiate_bounds(item.span, free_substs, &predicates); + this.check_where_clauses(fcx, item.span, &predicates); + + impl_implied_bounds(fcx, local_def(item.id), item.span) + }); + } + + fn check_where_clauses<'fcx>(&mut self, + fcx: &FnCtxt<'fcx,'tcx>, + span: Span, + predicates: &ty::InstantiatedPredicates<'tcx>) + { + let obligations = + predicates.predicates + .iter() + .flat_map(|p| wf::predicate_obligations(fcx.infcx(), + fcx.body_id, + p, + span, + true)); + + for obligation in obligations { + fcx.register_predicate(obligation); + } + } + + fn check_fn_or_method<'fcx>(&mut self, + fcx: &FnCtxt<'fcx,'tcx>, + span: Span, + fty: &ty::BareFnTy<'tcx>, + predicates: &ty::InstantiatedPredicates<'tcx>, + free_id: ast::NodeId, + implied_bounds: &mut Vec>) + { + let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; + let fty = fcx.instantiate_type_scheme(span, free_substs, fty); + let free_id_outlive = DestructionScopeData::new(free_id); + let sig = fcx.tcx().liberate_late_bound_regions(free_id_outlive, &fty.sig); + + for &input_ty in &sig.inputs { + fcx.register_wf_obligation(input_ty, span, self.code.clone()); + } + implied_bounds.extend(sig.inputs); + + match sig.output { + ty::FnConverging(output) => { + fcx.register_wf_obligation(output, span, self.code.clone()); + + // FIXME(#25759) return types should not be implied bounds + implied_bounds.push(output); + } + ty::FnDiverging => { } + } + + self.check_where_clauses(fcx, span, predicates); + } + + fn check_variances_for_type_defn(&self, + item: &ast::Item, + ast_generics: &ast::Generics) + { + let item_def_id = local_def(item.id); + let ty_predicates = self.tcx().lookup_predicates(item_def_id); + let variances = self.tcx().item_variances(item_def_id); + + let mut constrained_parameters: HashSet<_> = + variances.types + .iter_enumerated() + .filter(|&(_, _, &variance)| variance != ty::Bivariant) + .map(|(space, index, _)| self.param_ty(ast_generics, space, index)) + .map(|p| Parameter::Type(p)) + .collect(); + + identify_constrained_type_params(self.tcx(), + ty_predicates.predicates.as_slice(), + None, + &mut constrained_parameters); + + for (space, index, _) in variances.types.iter_enumerated() { + let param_ty = self.param_ty(ast_generics, space, index); + if constrained_parameters.contains(&Parameter::Type(param_ty)) { + continue; + } + let span = self.ty_param_span(ast_generics, item, space, index); + self.report_bivariance(span, param_ty.name); + } + + for (space, index, &variance) in variances.regions.iter_enumerated() { + if variance != ty::Bivariant { + continue; + } + + assert_eq!(space, TypeSpace); + let span = ast_generics.lifetimes[index].lifetime.span; + let name = ast_generics.lifetimes[index].lifetime.name; + self.report_bivariance(span, name); + } + } + + fn param_ty(&self, + ast_generics: &ast::Generics, + space: ParamSpace, + index: usize) + -> ty::ParamTy + { + let name = match space { + TypeSpace => ast_generics.ty_params[index].ident.name, + SelfSpace => special_idents::type_self.name, + FnSpace => self.tcx().sess.bug("Fn space occupied?"), + }; + + ty::ParamTy { space: space, idx: index as u32, name: name } + } + + fn ty_param_span(&self, + ast_generics: &ast::Generics, + item: &ast::Item, + space: ParamSpace, + index: usize) + -> Span + { + match space { + TypeSpace => ast_generics.ty_params[index].span, + SelfSpace => item.span, + FnSpace => self.tcx().sess.span_bug(item.span, "Fn space occupied?"), + } + } + + fn report_bivariance(&self, + span: Span, + param_name: ast::Name) + { + error_392(self.tcx(), span, param_name); + + let suggested_marker_id = self.tcx().lang_items.phantom_data(); + match suggested_marker_id { + Some(def_id) => { + self.tcx().sess.fileline_help( + span, + &format!("consider removing `{}` or using a marker such as `{}`", + param_name, + self.tcx().item_path_str(def_id))); + } + None => { + // no lang items, no help! + } + } + } +} + +fn reject_shadowing_type_parameters<'tcx>(tcx: &ty::ctxt<'tcx>, + span: Span, + generics: &ty::Generics<'tcx>) { + let impl_params = generics.types.get_slice(subst::TypeSpace).iter() + .map(|tp| tp.name).collect::>(); + + for method_param in generics.types.get_slice(subst::FnSpace) { + if impl_params.contains(&method_param.name) { + error_194(tcx, span, method_param.name); + } + } +} + +impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> { + fn visit_item(&mut self, i: &ast::Item) { + debug!("visit_item: {:?}", i); + self.check_item_well_formed(i); + visit::walk_item(self, i); + } + + fn visit_trait_item(&mut self, trait_item: &'v ast::TraitItem) { + debug!("visit_trait_item: {:?}", trait_item); + self.check_trait_or_impl_item(trait_item.id, trait_item.span); + visit::walk_trait_item(self, trait_item) + } + + fn visit_impl_item(&mut self, impl_item: &'v ast::ImplItem) { + debug!("visit_impl_item: {:?}", impl_item); + self.check_trait_or_impl_item(impl_item.id, impl_item.span); + visit::walk_impl_item(self, impl_item) + } +} + +/////////////////////////////////////////////////////////////////////////// +// ADT + +struct AdtVariant<'tcx> { + fields: Vec>, +} + +struct AdtField<'tcx> { + ty: Ty<'tcx>, + span: Span, +} + +fn struct_variant<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, + struct_def: &ast::StructDef) + -> AdtVariant<'tcx> { + let fields = + struct_def.fields + .iter() + .map(|field| { + let field_ty = fcx.tcx().node_id_to_type(field.node.id); + let field_ty = fcx.instantiate_type_scheme(field.span, + &fcx.inh + .infcx + .parameter_environment + .free_substs, + &field_ty); + AdtField { ty: field_ty, span: field.span } + }) + .collect(); + AdtVariant { fields: fields } +} + +fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, + enum_def: &ast::EnumDef) + -> Vec> { + enum_def.variants.iter() + .map(|variant| { + match variant.node.kind { + ast::TupleVariantKind(ref args) if !args.is_empty() => { + let ctor_ty = fcx.tcx().node_id_to_type(variant.node.id); + + // the regions in the argument types come from the + // enum def'n, and hence will all be early bound + let arg_tys = fcx.tcx().no_late_bound_regions(&ctor_ty.fn_args()).unwrap(); + AdtVariant { + fields: args.iter().enumerate().map(|(index, arg)| { + let arg_ty = arg_tys[index]; + let arg_ty = + fcx.instantiate_type_scheme(variant.span, + &fcx.inh + .infcx + .parameter_environment + .free_substs, + &arg_ty); + AdtField { + ty: arg_ty, + span: arg.ty.span + } + }).collect() + } + } + ast::TupleVariantKind(_) => { + AdtVariant { + fields: Vec::new() + } + } + ast::StructVariantKind(ref struct_def) => { + struct_variant(fcx, &**struct_def) + } + } + }) + .collect() +} + +fn impl_implied_bounds<'fcx,'tcx>(fcx: &FnCtxt<'fcx, 'tcx>, + impl_def_id: ast::DefId, + span: Span) + -> Vec> +{ + let free_substs = &fcx.inh.infcx.parameter_environment.free_substs; + match fcx.tcx().impl_trait_ref(impl_def_id) { + Some(ref trait_ref) => { + // Trait impl: take implied bounds from all types that + // appear in the trait reference. + let trait_ref = fcx.instantiate_type_scheme(span, free_substs, trait_ref); + trait_ref.substs.types.as_slice().to_vec() + } + + None => { + // Inherent impl: take implied bounds from the self type. + let self_ty = fcx.tcx().lookup_item_type(impl_def_id).ty; + let self_ty = fcx.instantiate_type_scheme(span, free_substs, &self_ty); + vec![self_ty] + } + } +} + +pub fn error_192<'ccx,'tcx>(ccx: &'ccx CrateCtxt<'ccx, 'tcx>, span: Span) { + span_err!(ccx.tcx.sess, span, E0192, + "negative impls are only allowed for traits with \ + default impls (e.g., `Send` and `Sync`)") +} + +pub fn error_380<'ccx,'tcx>(ccx: &'ccx CrateCtxt<'ccx, 'tcx>, span: Span) { + span_err!(ccx.tcx.sess, span, E0380, + "traits with default impls (`e.g. unsafe impl \ + Trait for ..`) must have no methods or associated items") +} + +pub fn error_392<'tcx>(tcx: &ty::ctxt<'tcx>, span: Span, param_name: ast::Name) { + span_err!(tcx.sess, span, E0392, + "parameter `{}` is never used", param_name); +} + +pub fn error_194<'tcx>(tcx: &ty::ctxt<'tcx>, span: Span, name: ast::Name) { + span_err!(tcx.sess, span, E0194, + "type parameter `{}` shadows another type parameter of the same name", + name); +} diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index 42c6bcbfbb999..1652c67c531d3 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -200,10 +200,13 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> { // if Trait1 is a supertrait of Trait2 or Trait2 is not object safe. if !traits::is_object_safe(self.tcx, data.principal_def_id()) { - // this just means the self-ty is illegal, - // and probably this error should have - // been reported elsewhere, but I'm trying to avoid - // giving a misleading message below. + // FIXME(#27579). This just means the + // self-ty is illegal; WF will report this + // error. But it will do so as a warning + // for a release or two. For backwards + // compat reasons, then, we continue to + // report it here so that things which + // were errors remain errors. span_err!(self.tcx.sess, self_ty.span, E0372, "the trait `{}` cannot be made into an object", self.tcx.item_path_str(data.principal_def_id())); diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 5d7822a71bb5d..e6824c811c58e 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -345,9 +345,23 @@ pub fn check_crate(tcx: &ty::ctxt, trait_map: ty::TraitMap) { time(time_passes, "coherence checking", (), |_| coherence::check_coherence(&ccx)); - time(time_passes, "type checking", (), |_| + time(time_passes, "wf checking (old)", (), |_| + check::check_wf_old(&ccx)); + + time(time_passes, "item-types checking", (), |_| check::check_item_types(&ccx)); + time(time_passes, "item-bodies checking", (), |_| + check::check_item_bodies(&ccx)); + + time(time_passes, "drop-impl checking", (), |_| + check::check_drop_impls(&ccx)); + + // Do this last so that if there are errors in the old code, they + // get reported, and we don't get extra warnings. + time(time_passes, "wf checking (new)", (), |_| + check::check_wf_new(&ccx)); + check_for_entry_fn(&ccx); tcx.sess.abort_if_errors(); } diff --git a/src/test/compile-fail/where-clauses-not-parameter.rs b/src/test/compile-fail/where-clauses-not-parameter.rs deleted file mode 100644 index 7968cc37090ac..0000000000000 --- a/src/test/compile-fail/where-clauses-not-parameter.rs +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright 2014 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. - -fn equal(_: &T, _: &T) -> bool where isize : Eq { - true //~^ ERROR cannot bound type `isize`, where clause bounds may only be attached -} - -// This should be fine involves a type parameter. -fn test() -> bool where Option : Eq {} - -// This should be rejected as well. -fn test2() -> bool where Option : Eq {} -//~^ ERROR cannot bound type `core::option::Option`, where clause bounds may - -#[derive(PartialEq)] -//~^ ERROR cannot bound type `isize`, where clause bounds -enum Foo where isize : Eq { MkFoo(T) } -//~^ ERROR cannot bound type `isize`, where clause bounds - -fn test3() -> bool where Option> : Eq {} - -fn test4() -> bool where Option> : Eq {} -//~^ ERROR cannot bound type `core::option::Option>`, where clause bounds - -trait Baz where isize : Eq { - //~^ ERROR cannot bound type `isize`, where clause bounds may only - fn baz(&self, t: T) where String : Eq; //~ ERROR cannot bound type `collections::string::String` - //~^ ERROR cannot bound type `isize`, where clause -} - -impl Baz for isize where isize : Eq { - //~^ ERROR cannot bound type `isize`, where clause bounds - fn baz() where String : Eq {} -} - -fn main() { - equal(&0, &0); -} From 6bb1e2291195a518ddeef6e64337f4edb1432a72 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 09:43:40 -0400 Subject: [PATCH 06/38] New WF condition requires checking that argument types are WF on every call. This ensures that implies bounds are reasonable (the older code only checked that the values provided had WF types, but we also must know that the formal types of the arguments are WF.) --- src/librustc_typeck/check/mod.rs | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index df8a80792a342..bf5d1373d0bf5 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2432,6 +2432,12 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, 1 }; + // All the input types from the fn signature must outlive the call + // so as to validate implied bounds. + for &fn_input_ty in fn_inputs { + fcx.register_wf_obligation(fn_input_ty, sp, traits::MiscObligation); + } + let mut expected_arg_tys = expected_arg_tys; let expected_arg_count = fn_inputs.len(); let formal_tys = if tuple_arguments == TupleArguments { @@ -3541,16 +3547,18 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } ast::ExprCall(ref callee, ref args) => { callee::check_call(fcx, expr, &**callee, &args[..], expected); + + // we must check that return type of called functions is WF: + let ret_ty = fcx.expr_ty(expr); + fcx.register_wf_obligation(ret_ty, expr.span, traits::MiscObligation); } ast::ExprMethodCall(ident, ref tps, ref args) => { - check_method_call(fcx, expr, ident, &args[..], &tps[..], expected, lvalue_pref); - let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a)); - let args_err = arg_tys.fold(false, - |rest_err, a| { - rest_err || a.references_error()}); - if args_err { - fcx.write_error(id); - } + check_method_call(fcx, expr, ident, &args[..], &tps[..], expected, lvalue_pref); + let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a)); + let args_err = arg_tys.fold(false, |rest_err, a| rest_err || a.references_error()); + if args_err { + fcx.write_error(id); + } } ast::ExprCast(ref e, ref t) => { if let ast::TyFixedLengthVec(_, ref count_expr) = t.node { From 39d164d0421a7560ea1e35a2347fda223cd43f6e Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 13:31:42 -0400 Subject: [PATCH 07/38] New tests --- check that wf relation is being checked in various positions --- .../compile-fail/regions-wf-trait-object.rs | 21 ++++ src/test/compile-fail/wf-array-elem-sized.rs | 21 ++++ src/test/compile-fail/wf-const-type.rs | 24 ++++ src/test/compile-fail/wf-enum-bound.rs | 26 +++++ src/test/compile-fail/wf-enum-fields.rs | 32 ++++++ src/test/compile-fail/wf-fn-where-clause.rs | 24 ++++ .../wf-impl-associated-type-region.rs | 24 ++++ .../wf-impl-associated-type-trait.rs | 33 ++++++ src/test/compile-fail/wf-in-fn-arg.rs | 24 ++++ src/test/compile-fail/wf-in-fn-ret.rs | 24 ++++ src/test/compile-fail/wf-in-fn-type-arg.rs | 22 ++++ src/test/compile-fail/wf-in-fn-type-ret.rs | 22 ++++ src/test/compile-fail/wf-in-fn-type-static.rs | 32 ++++++ .../compile-fail/wf-in-fn-where-clause.rs | 25 +++++ .../compile-fail/wf-in-obj-type-static.rs | 28 +++++ src/test/compile-fail/wf-in-obj-type-trait.rs | 24 ++++ .../wf-inherent-impl-method-where-clause.rs | 27 +++++ .../wf-inherent-impl-where-clause.rs | 26 +++++ src/test/compile-fail/wf-object-safe.rs | 20 ++++ .../wf-outlives-ty-in-fn-or-trait.rs | 34 ++++++ src/test/compile-fail/wf-static-type.rs | 24 ++++ src/test/compile-fail/wf-struct-bound.rs | 26 +++++ src/test/compile-fail/wf-struct-field.rs | 26 +++++ .../wf-trait-associated-type-bound.rs | 24 ++++ .../wf-trait-associated-type-region.rs | 24 ++++ .../wf-trait-associated-type-trait | Bin 0 -> 493092 bytes .../wf-trait-associated-type-trait.rs | 26 +++++ src/test/compile-fail/wf-trait-bound.rs | 25 +++++ .../compile-fail/wf-trait-default-fn-arg.rs | 29 +++++ .../compile-fail/wf-trait-default-fn-ret.rs | 30 +++++ .../wf-trait-default-fn-where-clause.rs | 29 +++++ src/test/compile-fail/wf-trait-fn-arg.rs | 27 +++++ src/test/compile-fail/wf-trait-fn-ret.rs | 27 +++++ .../compile-fail/wf-trait-fn-where-clause.rs | 27 +++++ src/test/compile-fail/wf-trait-superbound.rs | 23 ++++ .../run-pass/project-defer-unification.rs | 105 ++++++++++++++++++ 36 files changed, 985 insertions(+) create mode 100644 src/test/compile-fail/regions-wf-trait-object.rs create mode 100644 src/test/compile-fail/wf-array-elem-sized.rs create mode 100644 src/test/compile-fail/wf-const-type.rs create mode 100644 src/test/compile-fail/wf-enum-bound.rs create mode 100644 src/test/compile-fail/wf-enum-fields.rs create mode 100644 src/test/compile-fail/wf-fn-where-clause.rs create mode 100644 src/test/compile-fail/wf-impl-associated-type-region.rs create mode 100644 src/test/compile-fail/wf-impl-associated-type-trait.rs create mode 100644 src/test/compile-fail/wf-in-fn-arg.rs create mode 100644 src/test/compile-fail/wf-in-fn-ret.rs create mode 100644 src/test/compile-fail/wf-in-fn-type-arg.rs create mode 100644 src/test/compile-fail/wf-in-fn-type-ret.rs create mode 100644 src/test/compile-fail/wf-in-fn-type-static.rs create mode 100644 src/test/compile-fail/wf-in-fn-where-clause.rs create mode 100644 src/test/compile-fail/wf-in-obj-type-static.rs create mode 100644 src/test/compile-fail/wf-in-obj-type-trait.rs create mode 100644 src/test/compile-fail/wf-inherent-impl-method-where-clause.rs create mode 100644 src/test/compile-fail/wf-inherent-impl-where-clause.rs create mode 100644 src/test/compile-fail/wf-object-safe.rs create mode 100644 src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs create mode 100644 src/test/compile-fail/wf-static-type.rs create mode 100644 src/test/compile-fail/wf-struct-bound.rs create mode 100644 src/test/compile-fail/wf-struct-field.rs create mode 100644 src/test/compile-fail/wf-trait-associated-type-bound.rs create mode 100644 src/test/compile-fail/wf-trait-associated-type-region.rs create mode 100755 src/test/compile-fail/wf-trait-associated-type-trait create mode 100644 src/test/compile-fail/wf-trait-associated-type-trait.rs create mode 100644 src/test/compile-fail/wf-trait-bound.rs create mode 100644 src/test/compile-fail/wf-trait-default-fn-arg.rs create mode 100644 src/test/compile-fail/wf-trait-default-fn-ret.rs create mode 100644 src/test/compile-fail/wf-trait-default-fn-where-clause.rs create mode 100644 src/test/compile-fail/wf-trait-fn-arg.rs create mode 100644 src/test/compile-fail/wf-trait-fn-ret.rs create mode 100644 src/test/compile-fail/wf-trait-fn-where-clause.rs create mode 100644 src/test/compile-fail/wf-trait-superbound.rs create mode 100644 src/test/run-pass/project-defer-unification.rs diff --git a/src/test/compile-fail/regions-wf-trait-object.rs b/src/test/compile-fail/regions-wf-trait-object.rs new file mode 100644 index 0000000000000..2ad1163052b37 --- /dev/null +++ b/src/test/compile-fail/regions-wf-trait-object.rs @@ -0,0 +1,21 @@ +// Copyright 2014 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.t + +// Check that the explicit lifetime bound (`'b`, in this example) must +// outlive all the superbound from the trait (`'a`, in this example). + +trait TheTrait<'t>: 't { } + +struct Foo<'a,'b> { + //~^ ERROR lifetime bound not satisfied + x: Box+'b> +} + +fn main() { } diff --git a/src/test/compile-fail/wf-array-elem-sized.rs b/src/test/compile-fail/wf-array-elem-sized.rs new file mode 100644 index 0000000000000..aaae41c766762 --- /dev/null +++ b/src/test/compile-fail/wf-array-elem-sized.rs @@ -0,0 +1,21 @@ +// Copyright 2015 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. + +// Check that array elemen types must be Sized. Issue #25692. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct Foo { //~ WARN E0277 + foo: [[u8]], +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-const-type.rs b/src/test/compile-fail/wf-const-type.rs new file mode 100644 index 0000000000000..c3015afd8dd0d --- /dev/null +++ b/src/test/compile-fail/wf-const-type.rs @@ -0,0 +1,24 @@ +// Copyright 2014 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. + +// Test that we check the types of constants are well-formed. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct IsCopy { t: T } +struct NotCopy; + +const FOO: IsCopy> = IsCopy { t: None }; +//~^ ERROR E0277 + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/wf-enum-bound.rs b/src/test/compile-fail/wf-enum-bound.rs new file mode 100644 index 0000000000000..1d271d1530a75 --- /dev/null +++ b/src/test/compile-fail/wf-enum-bound.rs @@ -0,0 +1,26 @@ +// Copyright 2014 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. + +// Test that we check enum bounds for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +enum SomeEnum //~ WARN E0277 + where T: ExtraCopy +{ + SomeVariant(T,U) +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-enum-fields.rs b/src/test/compile-fail/wf-enum-fields.rs new file mode 100644 index 0000000000000..40a939350822b --- /dev/null +++ b/src/test/compile-fail/wf-enum-fields.rs @@ -0,0 +1,32 @@ +// Copyright 2014 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. + +// Test that we check struct fields for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct IsCopy { + value: T +} + +enum SomeEnum { + SomeVariant(IsCopy) //~ ERROR E0277 +} + +enum AnotherEnum { //~ ERROR E0277 + AnotherVariant { + f: IsCopy + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/wf-fn-where-clause.rs b/src/test/compile-fail/wf-fn-where-clause.rs new file mode 100644 index 0000000000000..769894613c764 --- /dev/null +++ b/src/test/compile-fail/wf-fn-where-clause.rs @@ -0,0 +1,24 @@ +// Copyright 2014 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. + +// Test that we check where-clauses on fn items. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +fn foo() where T: ExtraCopy //~ WARN E0277 +{ +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-impl-associated-type-region.rs b/src/test/compile-fail/wf-impl-associated-type-region.rs new file mode 100644 index 0000000000000..2d7727fff3503 --- /dev/null +++ b/src/test/compile-fail/wf-impl-associated-type-region.rs @@ -0,0 +1,24 @@ +// Copyright 2015 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. + +// Check that we require that associated types in an impl are well-formed. + +#![feature(rustc_attrs)] + +pub trait Foo<'a> { + type Bar; +} + +impl<'a, T> Foo<'a> for T { + type Bar = &'a T; //~ WARN E0309 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation diff --git a/src/test/compile-fail/wf-impl-associated-type-trait.rs b/src/test/compile-fail/wf-impl-associated-type-trait.rs new file mode 100644 index 0000000000000..8a612c321570d --- /dev/null +++ b/src/test/compile-fail/wf-impl-associated-type-trait.rs @@ -0,0 +1,33 @@ +// Copyright 2015 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. + +// Check that we require that associated types in an impl are well-formed. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +pub trait MyHash { } + +pub struct MySet { + data: Vec +} + +pub trait Foo { + type Bar; +} + +impl Foo for T { + type Bar = MySet; + //~^ WARN the trait `MyHash` is not implemented for the type `T` +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful + diff --git a/src/test/compile-fail/wf-in-fn-arg.rs b/src/test/compile-fail/wf-in-fn-arg.rs new file mode 100644 index 0000000000000..e302cac0006b1 --- /dev/null +++ b/src/test/compile-fail/wf-in-fn-arg.rs @@ -0,0 +1,24 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions also for argument types in fn items. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct MustBeCopy { + t: T +} + +fn bar(_: &MustBeCopy) //~ ERROR E0277 +{ +} + +fn main() { } diff --git a/src/test/compile-fail/wf-in-fn-ret.rs b/src/test/compile-fail/wf-in-fn-ret.rs new file mode 100644 index 0000000000000..719bc9282ad7d --- /dev/null +++ b/src/test/compile-fail/wf-in-fn-ret.rs @@ -0,0 +1,24 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions also for return types in fn items. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct MustBeCopy { + t: T +} + +fn bar() -> MustBeCopy //~ ERROR E0277 +{ +} + +fn main() { } diff --git a/src/test/compile-fail/wf-in-fn-type-arg.rs b/src/test/compile-fail/wf-in-fn-type-arg.rs new file mode 100644 index 0000000000000..08ee0e954ac2d --- /dev/null +++ b/src/test/compile-fail/wf-in-fn-type-arg.rs @@ -0,0 +1,22 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions also for types in fns. + +struct MustBeCopy { + t: T +} + +struct Bar { + // needs T: Copy + x: fn(MustBeCopy) //~ ERROR E0277 +} + +fn main() { } diff --git a/src/test/compile-fail/wf-in-fn-type-ret.rs b/src/test/compile-fail/wf-in-fn-type-ret.rs new file mode 100644 index 0000000000000..6942f78606060 --- /dev/null +++ b/src/test/compile-fail/wf-in-fn-type-ret.rs @@ -0,0 +1,22 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions also for types in fns. + +struct MustBeCopy { + t: T +} + +struct Foo { + // needs T: 'static + x: fn() -> MustBeCopy //~ ERROR E0277 +} + +fn main() { } diff --git a/src/test/compile-fail/wf-in-fn-type-static.rs b/src/test/compile-fail/wf-in-fn-type-static.rs new file mode 100644 index 0000000000000..08853c69d6dac --- /dev/null +++ b/src/test/compile-fail/wf-in-fn-type-static.rs @@ -0,0 +1,32 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions related to regions also for +// types in fns. + +#![allow(dead_code)] +#![feature(rustc_attrs)] + +struct MustBeCopy { + t: T +} + +struct Foo { //~ WARN E0310 + // needs T: 'static + x: fn() -> &'static T //~ WARN E0310 +} + +struct Bar { //~ WARN E0310 + // needs T: Copy + x: fn(&'static T) //~ WARN E0310 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-in-fn-where-clause.rs b/src/test/compile-fail/wf-in-fn-where-clause.rs new file mode 100644 index 0000000000000..fc3d234aac252 --- /dev/null +++ b/src/test/compile-fail/wf-in-fn-where-clause.rs @@ -0,0 +1,25 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions also for where clauses in fn items. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait MustBeCopy { +} + +fn bar() //~ WARN E0277 + where T: MustBeCopy +{ +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-in-obj-type-static.rs b/src/test/compile-fail/wf-in-obj-type-static.rs new file mode 100644 index 0000000000000..36c8f5be308c5 --- /dev/null +++ b/src/test/compile-fail/wf-in-obj-type-static.rs @@ -0,0 +1,28 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions also for types in fns. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait Object { } + +struct MustBeCopy { + t: T +} + +struct Foo { //~ WARN E0310 + // needs T: 'static + x: Object<&'static T> //~ WARN E0310 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-in-obj-type-trait.rs b/src/test/compile-fail/wf-in-obj-type-trait.rs new file mode 100644 index 0000000000000..add48219c1d7e --- /dev/null +++ b/src/test/compile-fail/wf-in-obj-type-trait.rs @@ -0,0 +1,24 @@ +// Copyright 2015 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. + +// Check that we enforce WF conditions also for types in fns. + +trait Object { } + +struct MustBeCopy { + t: T +} + +struct Bar { + // needs T: Copy + x: Object> //~ ERROR E0277 +} + +fn main() { } diff --git a/src/test/compile-fail/wf-inherent-impl-method-where-clause.rs b/src/test/compile-fail/wf-inherent-impl-method-where-clause.rs new file mode 100644 index 0000000000000..44671be835533 --- /dev/null +++ b/src/test/compile-fail/wf-inherent-impl-method-where-clause.rs @@ -0,0 +1,27 @@ +// Copyright 2014 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. + +// Test that we check where-clauses on inherent impl methods. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +struct Foo(T,U); + +impl Foo { + fn foo(self) where T: ExtraCopy //~ WARN E0277 + {} +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-inherent-impl-where-clause.rs b/src/test/compile-fail/wf-inherent-impl-where-clause.rs new file mode 100644 index 0000000000000..a0f588c1961d1 --- /dev/null +++ b/src/test/compile-fail/wf-inherent-impl-where-clause.rs @@ -0,0 +1,26 @@ +// Copyright 2014 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. + +// Test that we check where-clauses on inherent impls. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +struct Foo(T,U); + +impl Foo where T: ExtraCopy //~ WARN E0277 +{ +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-object-safe.rs b/src/test/compile-fail/wf-object-safe.rs new file mode 100644 index 0000000000000..92c0a8c5be8af --- /dev/null +++ b/src/test/compile-fail/wf-object-safe.rs @@ -0,0 +1,20 @@ +// Copyright 2015 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. + +// Check that object-safe traits are not WF when used as object types. +// Issue #21953. + +trait A { + fn foo(&self, _x: &Self); +} + +fn main() { + let _x: &A; //~ ERROR E0038 +} diff --git a/src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs b/src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs new file mode 100644 index 0000000000000..eca128f4a1380 --- /dev/null +++ b/src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs @@ -0,0 +1,34 @@ +// Copyright 2014 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. + +// Test that an appearance of `T` in fn args or in a trait object must +// still meet the outlives bounds. Since this is a new requirement, +// this is currently only a warning, not a hard error. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait Trait { } + +struct Foo<'a,T> { + //~^ WARN E0309 + f: &'a fn(T), + //~^ WARN E0309 +} + +struct Bar<'a,T> { + //~^ WARN E0309 + f: &'a Trait, + //~^ WARN E0309 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful + diff --git a/src/test/compile-fail/wf-static-type.rs b/src/test/compile-fail/wf-static-type.rs new file mode 100644 index 0000000000000..ba02c5dca3e6d --- /dev/null +++ b/src/test/compile-fail/wf-static-type.rs @@ -0,0 +1,24 @@ +// Copyright 2014 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. + +// Test that we check the types of statics are well-formed. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct IsCopy { t: T } +struct NotCopy; + +static FOO: IsCopy> = IsCopy { t: None }; +//~^ ERROR E0277 + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/wf-struct-bound.rs b/src/test/compile-fail/wf-struct-bound.rs new file mode 100644 index 0000000000000..43378061e40c0 --- /dev/null +++ b/src/test/compile-fail/wf-struct-bound.rs @@ -0,0 +1,26 @@ +// Copyright 2014 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. + +// Test that we check struct bounds for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +struct SomeStruct //~ WARN E0277 + where T: ExtraCopy +{ + data: (T,U) +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-struct-field.rs b/src/test/compile-fail/wf-struct-field.rs new file mode 100644 index 0000000000000..8a631a6c335a0 --- /dev/null +++ b/src/test/compile-fail/wf-struct-field.rs @@ -0,0 +1,26 @@ +// Copyright 2014 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. + +// Test that we check struct fields for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct IsCopy { + value: T +} + +struct SomeStruct { + data: IsCopy //~ ERROR E0277 +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/wf-trait-associated-type-bound.rs b/src/test/compile-fail/wf-trait-associated-type-bound.rs new file mode 100644 index 0000000000000..63a532138e3bd --- /dev/null +++ b/src/test/compile-fail/wf-trait-associated-type-bound.rs @@ -0,0 +1,24 @@ +// Copyright 2014 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. + +// Test that we check associated type bounds for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +trait SomeTrait { //~ WARN E0277 + type Type1: ExtraCopy; +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-associated-type-region.rs b/src/test/compile-fail/wf-trait-associated-type-region.rs new file mode 100644 index 0000000000000..b3aa4e19c9656 --- /dev/null +++ b/src/test/compile-fail/wf-trait-associated-type-region.rs @@ -0,0 +1,24 @@ +// Copyright 2014 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. + +// Test that we check associated type default values for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait SomeTrait<'a> { + type Type1; + type Type2 = &'a Self::Type1; + //~^ WARN E0309 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-associated-type-trait b/src/test/compile-fail/wf-trait-associated-type-trait new file mode 100755 index 0000000000000000000000000000000000000000..a11cbc2cb1913080342cbaa4137a24eccc6542e0 GIT binary patch literal 493092 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 z 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

{ + loop { } + } +} + +pub struct Pixels<'a, I: 'a> { + image: &'a I, + x: u32, + y: u32, + width: u32, + height: u32 +} + +impl<'a, I: GenericImage> Iterator for Pixels<'a, I> { + type Item = (u32, u32, I::Pixel); + + fn next(&mut self) -> Option<(u32, u32, I::Pixel)> { + loop { } + } +} + +pub struct PixelsMut<'a, P: Pixel + 'a> where P::Subpixel: 'a { + chunks: &'a mut P::Subpixel +} + +impl<'a, P: Pixel + 'a> Iterator for PixelsMut<'a, P> where P::Subpixel: 'a { + type Item = &'a mut P; + + fn next(&mut self) -> Option<&'a mut P> { + loop { } + } +} + +pub fn index_colors(image: &ImageBuffer>) + -> ImageBuffer, Vec> +where Pix: Pixel + 'static, +{ + let mut indices: ImageBuffer<_,Vec<_>> = loop { }; + for (pixel, idx) in image.pixels().zip(indices.pixels_mut()) { + // failured occurred here ^^ because we were requiring that we + // could project Pixel or Subpixel from `T_indices` (type of + // `indices`), but the type is insufficiently constrained + // until we reach the return below. + } + indices +} + +fn main() { } From 75ee8f156204cef3140d6e153d36f9970ca2bfa1 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 10:28:51 -0400 Subject: [PATCH 08/38] Introduce a "origin/cause" for new requirements (or bugfixes...) introduced by RFC 1214, and issue a warning (and explanatory note) when we encounter such a thing. --- src/librustc/middle/infer/error_reporting.rs | 70 +++- src/librustc/middle/infer/mod.rs | 21 ++ src/librustc/middle/traits/error_reporting.rs | 303 +++++++++++------- src/librustc/middle/traits/mod.rs | 29 +- src/librustc/middle/traits/select.rs | 22 +- src/librustc/session/mod.rs | 14 + src/libsyntax/diagnostics/macros.rs | 12 + 7 files changed, 339 insertions(+), 132 deletions(-) diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index 663746ac2dd3c..44eceb1f213af 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -239,8 +239,7 @@ pub trait ErrorReporting<'tcx> { fn report_generic_bound_failure(&self, origin: SubregionOrigin<'tcx>, kind: GenericKind<'tcx>, - sub: Region, - sups: Vec); + sub: Region); fn report_sub_sup_conflict(&self, var_origin: RegionVariableOrigin, @@ -292,8 +291,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { self.report_concrete_failure(origin, sub, sup); } - GenericBoundFailure(kind, param_ty, sub, sups) => { - self.report_generic_bound_failure(kind, param_ty, sub, sups); + GenericBoundFailure(kind, param_ty, sub) => { + self.report_generic_bound_failure(kind, param_ty, sub); } SubSupConflict(var_origin, @@ -527,14 +526,18 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { fn report_generic_bound_failure(&self, origin: SubregionOrigin<'tcx>, bound_kind: GenericKind<'tcx>, - sub: Region, - _sups: Vec) + sub: Region) { // FIXME: it would be better to report the first error message // with the span of the parameter itself, rather than the span // where the error was detected. But that span is not readily // accessible. + let is_warning = match origin { + infer::RFC1214Subregion(_) => true, + _ => false, + }; + let labeled_user_string = match bound_kind { GenericKind::Param(ref p) => format!("the parameter type `{}`", p), @@ -545,7 +548,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { match sub { ty::ReFree(ty::FreeRegion {bound_region: ty::BrNamed(..), ..}) => { // Does the required lifetime have a nice name we can print? - span_err!(self.tcx.sess, origin.span(), E0309, + span_err_or_warn!( + is_warning, self.tcx.sess, origin.span(), E0309, "{} may not live long enough", labeled_user_string); self.tcx.sess.fileline_help( origin.span(), @@ -557,7 +561,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { ty::ReStatic => { // Does the required lifetime have a nice name we can print? - span_err!(self.tcx.sess, origin.span(), E0310, + span_err_or_warn!( + is_warning, self.tcx.sess, origin.span(), E0310, "{} may not live long enough", labeled_user_string); self.tcx.sess.fileline_help( origin.span(), @@ -568,9 +573,10 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { _ => { // If not, be less specific. - span_err!(self.tcx.sess, origin.span(), E0311, - "{} may not live long enough", - labeled_user_string); + span_err_or_warn!( + is_warning, self.tcx.sess, origin.span(), E0311, + "{} may not live long enough", + labeled_user_string); self.tcx.sess.fileline_help( origin.span(), &format!( @@ -583,6 +589,10 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { } } + if is_warning { + self.tcx.sess.note_rfc_1214(origin.span()); + } + self.note_region_origin(&origin); } @@ -591,6 +601,13 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { sub: Region, sup: Region) { match origin { + infer::RFC1214Subregion(ref suborigin) => { + // Ideally, this would be a warning, but it doesn't + // seem to come up in practice, since the changes from + // RFC1214 mostly trigger errors in type definitions + // that don't wind up coming down this path. + self.report_concrete_failure((**suborigin).clone(), sub, sup); + } infer::Subtype(trace) => { let terr = TypeError::RegionsDoesNotOutlive(sup, sub); self.report_and_explain_type_error(trace, &terr); @@ -819,6 +836,23 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { sup, ""); } + infer::ParameterInScope(_, span) => { + self.tcx.sess.span_err( + span, + &format!("type/lifetime parameter not in scope here")); + self.tcx.note_and_explain_region( + "the parameter is only valid for ", + sub, + ""); + } + infer::DataBorrowed(ty, span) => { + self.tcx.sess.span_err( + span, + &format!("a value of type `{}` is borrowed for too long", + self.ty_to_string(ty))); + self.tcx.note_and_explain_region("the type is valid for ", sub, ""); + self.tcx.note_and_explain_region("but the borrow lasts for ", sup, ""); + } infer::ReferenceOutlivesReferent(ty, span) => { self.tcx.sess.span_err( span, @@ -1567,6 +1601,9 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) { match *origin { + infer::RFC1214Subregion(ref suborigin) => { + self.note_region_origin(suborigin); + } infer::Subtype(ref trace) => { let desc = match trace.origin { infer::Misc(_) => { @@ -1714,6 +1751,17 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { span, "...so that variable is valid at time of its declaration"); } + infer::ParameterInScope(_, span) => { + self.tcx.sess.span_note( + span, + &format!("...so that a type/lifetime parameter is in scope here")); + } + infer::DataBorrowed(ty, span) => { + self.tcx.sess.span_note( + span, + &format!("...so that the type `{}` is not borrowed for too long", + self.ty_to_string(ty))); + } infer::ReferenceOutlivesReferent(ty, span) => { self.tcx.sess.span_note( span, diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index f63154af72426..da3749979b601 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -35,6 +35,7 @@ use middle::ty_relate::{Relate, RelateResult, TypeRelation}; use rustc_data_structures::unify::{self, UnificationTable}; use std::cell::{RefCell, Ref}; use std::fmt; +use std::rc::Rc; use syntax::ast; use syntax::codemap; use syntax::codemap::{Span, DUMMY_SP}; @@ -188,6 +189,8 @@ pub struct TypeTrace<'tcx> { /// See `error_reporting.rs` for more details #[derive(Clone, Debug)] pub enum SubregionOrigin<'tcx> { + RFC1214Subregion(Rc>), + // Arose from a subtyping relation Subtype(TypeTrace<'tcx>), @@ -229,9 +232,15 @@ pub enum SubregionOrigin<'tcx> { // Creating a pointer `b` to contents of an upvar ReborrowUpvar(Span, ty::UpvarId), + // Data with type `Ty<'tcx>` was borrowed + DataBorrowed(Ty<'tcx>, Span), + // (&'a &'b T) where a >= b ReferenceOutlivesReferent(Ty<'tcx>, Span), + // Type or region parameters must be in scope. + ParameterInScope(ParameterOrigin, Span), + // The type T of an expression E must outlive the lifetime for E. ExprTypeIsNotInScope(Ty<'tcx>, Span), @@ -260,6 +269,15 @@ pub enum SubregionOrigin<'tcx> { SafeDestructor(Span), } +/// Places that type/region parameters can appear. +#[derive(Clone, Copy, Debug)] +pub enum ParameterOrigin { + Path, // foo::bar + MethodCall, // foo.bar() <-- parameters on impl providing bar() + OverloadedOperator, // a + b when overloaded + OverloadedDeref, // *a when overloaded +} + /// Times when we replace late-bound regions with variables: #[derive(Clone, Copy, Debug)] pub enum LateBoundRegionConversionTime { @@ -1565,6 +1583,7 @@ impl TypeOrigin { impl<'tcx> SubregionOrigin<'tcx> { pub fn span(&self) -> Span { match *self { + RFC1214Subregion(ref a) => a.span(), Subtype(ref a) => a.span(), InfStackClosure(a) => a, InvokeClosure(a) => a, @@ -1577,7 +1596,9 @@ impl<'tcx> SubregionOrigin<'tcx> { RelateDefaultParamBound(a, _) => a, Reborrow(a) => a, ReborrowUpvar(a, _) => a, + DataBorrowed(_, a) => a, ReferenceOutlivesReferent(_, a) => a, + ParameterInScope(_, a) => a, ExprTypeIsNotInScope(_, a) => a, BindingTypeIsNotValidAtDecl(a) => a, CallRcvr(a) => a, diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index 1f79db9e5232b..fb2db5089c978 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -25,11 +25,12 @@ use super::{ use fmt_macros::{Parser, Piece, Position}; use middle::infer::InferCtxt; -use middle::ty::{self, ToPredicate, HasTypeFlags, ToPolyTraitRef, TraitRef}; +use middle::ty::{self, ToPredicate, HasTypeFlags, ToPolyTraitRef, TraitRef, Ty}; use middle::ty_fold::TypeFoldable; use std::collections::HashMap; use std::fmt; use syntax::codemap::Span; +use syntax::ast; use syntax::attr::{AttributeMethods, AttrMetaMethods}; pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, @@ -54,22 +55,28 @@ fn report_fulfillment_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, } } +fn is_warning(obligation: &Obligation) -> bool { + obligation.cause.code.is_rfc1214() +} + pub fn report_projection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, obligation: &PredicateObligation<'tcx>, error: &MismatchedProjectionTypes<'tcx>) { let predicate = infcx.resolve_type_vars_if_possible(&obligation.predicate); + // The TyError created by normalize_to_error can end up being unified // into all obligations: for example, if our obligation is something // like `$X = <() as Foo<$X>>::Out` and () does not implement Foo<_>, // then $X will be unified with TyError, but the error still needs to be // reported. if !infcx.tcx.sess.has_errors() || !predicate.references_error() { - span_err!(infcx.tcx.sess, obligation.cause.span, E0271, - "type mismatch resolving `{}`: {}", - predicate, - error.err); + span_err_or_warn!( + is_warning(obligation), infcx.tcx.sess, obligation.cause.span, E0271, + "type mismatch resolving `{}`: {}", + predicate, + error.err); note_obligation_cause(infcx, obligation); } } @@ -173,66 +180,93 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, obligation: &PredicateObligation<'tcx>, error: &SelectionError<'tcx>) { + let is_warning = is_warning(obligation); match *error { SelectionError::Unimplemented => { - match &obligation.cause.code { - &ObligationCauseCode::CompareImplMethodObligation => { - span_err!(infcx.tcx.sess, obligation.cause.span, E0276, - "the requirement `{}` appears on the impl \ - method but not on the corresponding trait method", - obligation.predicate);; - } - _ => { - match obligation.predicate { - ty::Predicate::Trait(ref trait_predicate) => { - let trait_predicate = - infcx.resolve_type_vars_if_possible(trait_predicate); - - if !infcx.tcx.sess.has_errors() || - !trait_predicate.references_error() { - let trait_ref = trait_predicate.to_poly_trait_ref(); - span_err!(infcx.tcx.sess, obligation.cause.span, E0277, - "the trait `{}` is not implemented for the type `{}`", - trait_ref, - trait_ref.self_ty()); - // Check if it has a custom "#[rustc_on_unimplemented]" - // error message, report with that message if it does - let custom_note = report_on_unimplemented(infcx, &trait_ref.0, - obligation.cause.span); - if let Some(s) = custom_note { - infcx.tcx.sess.span_note(obligation.cause.span, - &s); - } + if let ObligationCauseCode::CompareImplMethodObligation = obligation.cause.code { + span_err_or_warn!( + is_warning, infcx.tcx.sess, obligation.cause.span, E0276, + "the requirement `{}` appears on the impl \ + method but not on the corresponding trait method", + obligation.predicate);; + } else { + match obligation.predicate { + ty::Predicate::Trait(ref trait_predicate) => { + let trait_predicate = + infcx.resolve_type_vars_if_possible(trait_predicate); + + if !infcx.tcx.sess.has_errors() || !trait_predicate.references_error() { + let trait_ref = trait_predicate.to_poly_trait_ref(); + span_err_or_warn!( + is_warning, infcx.tcx.sess, obligation.cause.span, E0277, + "the trait `{}` is not implemented for the type `{}`", + trait_ref, trait_ref.self_ty()); + + // Check if it has a custom "#[rustc_on_unimplemented]" + // error message, report with that message if it does + let custom_note = report_on_unimplemented(infcx, &trait_ref.0, + obligation.cause.span); + if is_warning { + note_obligation_cause(infcx, obligation); + } else if let Some(s) = custom_note { + infcx.tcx.sess.span_note(obligation.cause.span, &s); + } else { + note_obligation_cause(infcx, obligation); } } + } - ty::Predicate::Equate(ref predicate) => { - let predicate = infcx.resolve_type_vars_if_possible(predicate); - let err = infcx.equality_predicate(obligation.cause.span, - &predicate).err().unwrap(); - span_err!(infcx.tcx.sess, obligation.cause.span, E0278, - "the requirement `{}` is not satisfied (`{}`)", - predicate, - err); - } + ty::Predicate::Equate(ref predicate) => { + let predicate = infcx.resolve_type_vars_if_possible(predicate); + let err = infcx.equality_predicate(obligation.cause.span, + &predicate).err().unwrap(); + span_err_or_warn!( + is_warning, infcx.tcx.sess, obligation.cause.span, E0278, + "the requirement `{}` is not satisfied (`{}`)", + predicate, + err); + note_obligation_cause(infcx, obligation); + } - ty::Predicate::RegionOutlives(ref predicate) => { - let predicate = infcx.resolve_type_vars_if_possible(predicate); - let err = infcx.region_outlives_predicate(obligation.cause.span, - &predicate).err().unwrap(); - span_err!(infcx.tcx.sess, obligation.cause.span, E0279, - "the requirement `{}` is not satisfied (`{}`)", - predicate, - err); - } + ty::Predicate::RegionOutlives(ref predicate) => { + let predicate = infcx.resolve_type_vars_if_possible(predicate); + let err = infcx.region_outlives_predicate(obligation.cause.span, + &predicate).err().unwrap(); + span_err_or_warn!( + is_warning, infcx.tcx.sess, obligation.cause.span, E0279, + "the requirement `{}` is not satisfied (`{}`)", + predicate, + err); + note_obligation_cause(infcx, obligation); + } - ty::Predicate::Projection(..) | ty::Predicate::TypeOutlives(..) => { - let predicate = - infcx.resolve_type_vars_if_possible(&obligation.predicate); - span_err!(infcx.tcx.sess, obligation.cause.span, E0280, - "the requirement `{}` is not satisfied", - predicate); - } + ty::Predicate::Projection(..) | ty::Predicate::TypeOutlives(..) => { + let predicate = + infcx.resolve_type_vars_if_possible(&obligation.predicate); + span_err_or_warn!( + is_warning, infcx.tcx.sess, obligation.cause.span, E0280, + "the requirement `{}` is not satisfied", + predicate); + note_obligation_cause(infcx, obligation); + } + + ty::Predicate::ObjectSafe(trait_def_id) => { + report_object_safety_error(infcx.tcx, + obligation.cause.span, + trait_def_id, + is_warning); + note_obligation_cause(infcx, obligation); + } + + ty::Predicate::WellFormed(ty) => { + // WF predicates cannot themselves make + // errors. They can only block due to + // ambiguity; otherwise, they always + // degenerate into other obligations + // (which may fail). + infcx.tcx.sess.span_bug( + obligation.cause.span, + &format!("WF predicate not satisfied for {:?}", ty)); } } } @@ -242,62 +276,73 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, let expected_trait_ref = infcx.resolve_type_vars_if_possible(&*expected_trait_ref); let actual_trait_ref = infcx.resolve_type_vars_if_possible(&*actual_trait_ref); if !actual_trait_ref.self_ty().references_error() { - span_err!(infcx.tcx.sess, obligation.cause.span, E0281, - "type mismatch: the type `{}` implements the trait `{}`, \ - but the trait `{}` is required ({})", - expected_trait_ref.self_ty(), - expected_trait_ref, - actual_trait_ref, - e); - note_obligation_cause(infcx, obligation); + span_err_or_warn!( + is_warning, infcx.tcx.sess, obligation.cause.span, E0281, + "type mismatch: the type `{}` implements the trait `{}`, \ + but the trait `{}` is required ({})", + expected_trait_ref.self_ty(), + expected_trait_ref, + actual_trait_ref, + e); + note_obligation_cause(infcx, obligation); } } TraitNotObjectSafe(did) => { - span_err!(infcx.tcx.sess, obligation.cause.span, E0038, - "cannot convert to a trait object because trait `{}` is not object-safe", - infcx.tcx.item_path_str(did)); - - for violation in object_safety_violations(infcx.tcx, did) { - match violation { - ObjectSafetyViolation::SizedSelf => { - infcx.tcx.sess.span_note( - obligation.cause.span, - "the trait cannot require that `Self : Sized`"); - } + report_object_safety_error(infcx.tcx, obligation.cause.span, did, is_warning); + note_obligation_cause(infcx, obligation); + } + } +} - ObjectSafetyViolation::SupertraitSelf => { - infcx.tcx.sess.span_note( - obligation.cause.span, - "the trait cannot use `Self` as a type parameter \ - in the supertrait listing"); - } +pub fn report_object_safety_error<'tcx>(tcx: &ty::ctxt<'tcx>, + span: Span, + trait_def_id: ast::DefId, + is_warning: bool) +{ + span_err_or_warn!( + is_warning, tcx.sess, span, E0038, + "the trait `{}` cannot be made into an object", + tcx.item_path_str(trait_def_id)); - ObjectSafetyViolation::Method(method, - MethodViolationCode::StaticMethod) => { - infcx.tcx.sess.span_note( - obligation.cause.span, - &format!("method `{}` has no receiver", - method.name)); - } + for violation in object_safety_violations(tcx, trait_def_id) { + match violation { + ObjectSafetyViolation::SizedSelf => { + tcx.sess.span_note( + span, + "the trait cannot require that `Self : Sized`"); + } - ObjectSafetyViolation::Method(method, - MethodViolationCode::ReferencesSelf) => { - infcx.tcx.sess.span_note( - obligation.cause.span, - &format!("method `{}` references the `Self` type \ - in its arguments or return type", - method.name)); - } + ObjectSafetyViolation::SupertraitSelf => { + tcx.sess.span_note( + span, + "the trait cannot use `Self` as a type parameter \ + in the supertrait listing"); + } - ObjectSafetyViolation::Method(method, - MethodViolationCode::Generic) => { - infcx.tcx.sess.span_note( - obligation.cause.span, - &format!("method `{}` has generic type parameters", - method.name)); - } - } + ObjectSafetyViolation::Method(method, + MethodViolationCode::StaticMethod) => { + tcx.sess.span_note( + span, + &format!("method `{}` has no receiver", + method.name)); + } + + ObjectSafetyViolation::Method(method, + MethodViolationCode::ReferencesSelf) => { + tcx.sess.span_note( + span, + &format!("method `{}` references the `Self` type \ + in its arguments or return type", + method.name)); + } + + ObjectSafetyViolation::Method(method, + MethodViolationCode::Generic) => { + tcx.sess.span_note( + span, + &format!("method `{}` has generic type parameters", + method.name)); } } } @@ -342,14 +387,11 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, infcx.tcx.lang_items.sized_trait() .map_or(false, |sized_id| sized_id == trait_ref.def_id()) { - span_err!(infcx.tcx.sess, obligation.cause.span, E0282, - "unable to infer enough type information about `{}`; \ - type annotations or generic parameter binding required", - self_ty); + need_type_info(infcx, obligation.cause.span, self_ty); } else { span_err!(infcx.tcx.sess, obligation.cause.span, E0283, "type annotations required: cannot resolve `{}`", - predicate);; + predicate); note_obligation_cause(infcx, obligation); } } @@ -366,6 +408,14 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, } } + ty::Predicate::WellFormed(ty) => { + // Same hacky approach as above to avoid deluging user + // with error messages. + if !ty.references_error() && !infcx.tcx.sess.has_errors() { + need_type_info(infcx, obligation.cause.span, ty); + } + } + _ => { if !infcx.tcx.sess.has_errors() { span_err!(infcx.tcx.sess, obligation.cause.span, E0284, @@ -377,6 +427,16 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, } } +fn need_type_info<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, + span: Span, + ty: Ty<'tcx>) +{ + span_err!(infcx.tcx.sess, span, E0282, + "unable to infer enough type information about `{}`; \ + type annotations or generic parameter binding required", + ty); +} + fn note_obligation_cause<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>, obligation: &Obligation<'tcx, T>) where T: fmt::Display @@ -396,6 +456,27 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>, let tcx = infcx.tcx; match *cause_code { ObligationCauseCode::MiscObligation => { } + ObligationCauseCode::RFC1214(ref subcode) => { + tcx.sess.note_rfc_1214(cause_span); + note_obligation_cause_code(infcx, predicate, cause_span, subcode); + } + ObligationCauseCode::SliceOrArrayElem => { + tcx.sess.span_note( + cause_span, + &format!("slice and array elements must have `Sized` type")); + } + ObligationCauseCode::ProjectionWf(data) => { + tcx.sess.span_note( + cause_span, + &format!("required so that the projection `{}` is well-formed", + data)); + } + ObligationCauseCode::ReferenceOutlivesReferent(ref_ty) => { + tcx.sess.span_note( + cause_span, + &format!("required so that reference `{}` does not outlive its referent", + ref_ty)); + } ObligationCauseCode::ItemObligation(item_def_id) => { let item_name = tcx.item_path_str(item_def_id); tcx.sess.span_note( diff --git a/src/librustc/middle/traits/mod.rs b/src/librustc/middle/traits/mod.rs index 376430e87c6f0..14ab6c505d05c 100644 --- a/src/librustc/middle/traits/mod.rs +++ b/src/librustc/middle/traits/mod.rs @@ -27,6 +27,7 @@ use syntax::codemap::{Span, DUMMY_SP}; pub use self::error_reporting::report_fulfillment_errors; pub use self::error_reporting::report_overflow_error; pub use self::error_reporting::report_selection_error; +pub use self::error_reporting::report_object_safety_error; pub use self::error_reporting::suggest_new_overflow_limit; pub use self::coherence::orphan_check; pub use self::coherence::overlapping_impls; @@ -80,7 +81,7 @@ pub type PredicateObligation<'tcx> = Obligation<'tcx, ty::Predicate<'tcx>>; pub type TraitObligation<'tcx> = Obligation<'tcx, ty::PolyTraitPredicate<'tcx>>; /// Why did we incur this obligation? Used for error reporting. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq)] pub struct ObligationCause<'tcx> { pub span: Span, @@ -95,15 +96,27 @@ pub struct ObligationCause<'tcx> { pub code: ObligationCauseCode<'tcx> } -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq)] pub enum ObligationCauseCode<'tcx> { /// Not well classified or should be obvious from span. MiscObligation, + /// Obligation that triggers warning until RFC 1214 is fully in place. + RFC1214(Rc>), + + /// This is the trait reference from the given projection + SliceOrArrayElem, + + /// This is the trait reference from the given projection + ProjectionWf(ty::ProjectionTy<'tcx>), + /// In an impl of trait X for type Y, type Y must /// also implement all supertraits of X. ItemObligation(ast::DefId), + /// A type like `&'a T` is WF only if `T: 'a`. + ReferenceOutlivesReferent(Ty<'tcx>), + /// Obligation incurred due to an object cast. ObjectCastObligation(/* Object type */ Ty<'tcx>), @@ -124,7 +137,6 @@ pub enum ObligationCauseCode<'tcx> { // static items must have `Sync` type SharedStatic, - BuiltinDerivedObligation(DerivedObligationCause<'tcx>), ImplDerivedObligation(DerivedObligationCause<'tcx>), @@ -132,7 +144,7 @@ pub enum ObligationCauseCode<'tcx> { CompareImplMethodObligation, } -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq)] pub struct DerivedObligationCause<'tcx> { /// The trait reference of the parent obligation that led to the /// current obligation. Note that only trait obligations lead to @@ -516,6 +528,15 @@ impl<'tcx> ObligationCause<'tcx> { } } +impl<'tcx> ObligationCauseCode<'tcx> { + pub fn is_rfc1214(&self) -> bool { + match *self { + ObligationCauseCode::RFC1214(..) => true, + _ => false, + } + } +} + impl<'tcx, N> Vtable<'tcx, N> { pub fn nested_obligations(self) -> Vec { match self { diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 6c568b656c047..713b7394b59a1 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -2920,13 +2920,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // chain. Ideally, we should have a way to configure this either // by using -Z verbose or just a CLI argument. if obligation.recursion_depth >= 0 { - let derived_cause = DerivedObligationCause { - parent_trait_ref: obligation.predicate.to_poly_trait_ref(), - parent_code: Rc::new(obligation.cause.code.clone()), + let derived_code = match obligation.cause.code { + ObligationCauseCode::RFC1214(ref base_code) => { + let derived_cause = DerivedObligationCause { + parent_trait_ref: obligation.predicate.to_poly_trait_ref(), + parent_code: base_code.clone(), + }; + ObligationCauseCode::RFC1214(Rc::new(variant(derived_cause))) + } + _ => { + let derived_cause = DerivedObligationCause { + parent_trait_ref: obligation.predicate.to_poly_trait_ref(), + parent_code: Rc::new(obligation.cause.code.clone()) + }; + variant(derived_cause) + } }; - ObligationCause::new(obligation.cause.span, - obligation.cause.body_id, - variant(derived_cause)) + ObligationCause::new(obligation.cause.span, obligation.cause.body_id, derived_code) } else { obligation.cause.clone() } diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 99a58f07ae62b..ffb3a8ccb36ba 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -90,6 +90,13 @@ impl Session { } self.diagnostic().handler().fatal(msg) } + pub fn span_err_or_warn(&self, is_warning: bool, sp: Span, msg: &str) { + if is_warning { + self.span_warn(sp, msg); + } else { + self.span_err(sp, msg); + } + } pub fn span_err(&self, sp: Span, msg: &str) { if self.opts.treat_err_as_bug { self.span_bug(sp, msg); @@ -99,6 +106,13 @@ impl Session { None => self.diagnostic().span_err(sp, msg) } } + pub fn note_rfc_1214(&self, span: Span) { + self.span_note( + span, + &format!("this warning results from recent bug fixes and clarifications; \ + it will become a HARD ERROR in the next release. \ + See RFC 1214 for details.")); + } pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) { if self.opts.treat_err_as_bug { self.span_bug(sp, msg); diff --git a/src/libsyntax/diagnostics/macros.rs b/src/libsyntax/diagnostics/macros.rs index 669b930ecc92e..3c8347f8a8e0e 100644 --- a/src/libsyntax/diagnostics/macros.rs +++ b/src/libsyntax/diagnostics/macros.rs @@ -30,6 +30,18 @@ macro_rules! span_err { }) } +#[macro_export] +macro_rules! span_err_or_warn { + ($is_warning:expr, $session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ + __diagnostic_used!($code); + if $is_warning { + $session.span_warn_with_code($span, &format!($($message)*), stringify!($code)) + } else { + $session.span_err_with_code($span, &format!($($message)*), stringify!($code)) + } + }) +} + #[macro_export] macro_rules! span_warn { ($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ From d15997750211421cc1367faba574b3d9b2dc2432 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 10:33:18 -0400 Subject: [PATCH 09/38] Generalize the outlives rule for projections to handle the new cases; also, generalize VerifyBounds to include OR conditions. --- src/librustc/middle/infer/mod.rs | 8 +- .../middle/infer/region_inference/mod.rs | 193 ++++++-- src/librustc_typeck/check/regionck.rs | 441 +++++++++++++++--- 3 files changed, 541 insertions(+), 101 deletions(-) diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index da3749979b601..61c166e11d280 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -17,7 +17,7 @@ pub use self::TypeOrigin::*; pub use self::ValuePairs::*; pub use middle::ty::IntVarValue; pub use self::freshen::TypeFreshener; -pub use self::region_inference::GenericKind; +pub use self::region_inference::{GenericKind, VerifyBound}; use middle::free_region::FreeRegionMap; use middle::mem_categorization as mc; @@ -1416,13 +1416,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { origin: SubregionOrigin<'tcx>, kind: GenericKind<'tcx>, a: ty::Region, - bs: Vec) { + bound: VerifyBound) { debug!("verify_generic_bound({:?}, {:?} <: {:?})", kind, a, - bs); + bound); - self.region_vars.verify_generic_bound(origin, kind, a, bs); + self.region_vars.verify_generic_bound(origin, kind, a, bound); } pub fn can_equate<'b,T>(&'b self, a: &T, b: &T) -> UnitResult<'tcx> diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 4b62c7beab002..e8f8dbfbb0e63 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -64,15 +64,41 @@ pub enum Verify<'tcx> { // outlive `RS`. Therefore verify that `R <= RS[i]` for some // `i`. Inference variables may be involved (but this verification // step doesn't influence inference). - VerifyGenericBound(GenericKind<'tcx>, SubregionOrigin<'tcx>, Region, Vec), + VerifyGenericBound(GenericKind<'tcx>, SubregionOrigin<'tcx>, Region, VerifyBound), } -#[derive(Clone, PartialEq, Eq)] +#[derive(Copy, Clone, PartialEq, Eq)] pub enum GenericKind<'tcx> { Param(ty::ParamTy), Projection(ty::ProjectionTy<'tcx>), } +// When we introduce a verification step, we wish to test that a +// particular region (let's call it `'min`) meets some bound. +// The bound is described the by the following grammar: +#[derive(Debug)] +pub enum VerifyBound { + // B = exists {R} --> some 'r in {R} must outlive 'min + // + // Put another way, the subject value is known to outlive all + // regions in {R}, so if any of those outlives 'min, then the + // bound is met. + AnyRegion(Vec), + + // B = forall {R} --> all 'r in {R} must outlive 'min + // + // Put another way, the subject value is known to outlive some + // region in {R}, so if all of those outlives 'min, then the bound + // is met. + AllRegions(Vec), + + // B = exists {B} --> 'min must meet some bound b in {B} + AnyBound(Vec), + + // B = forall {B} --> 'min must meet all bounds b in {B} + AllBounds(Vec), +} + #[derive(Copy, Clone, PartialEq, Eq, Hash)] pub struct TwoRegions { a: Region, @@ -102,12 +128,11 @@ pub enum RegionResolutionError<'tcx> { /// `o` requires that `a <= b`, but this does not hold ConcreteFailure(SubregionOrigin<'tcx>, Region, Region), - /// `GenericBoundFailure(p, s, a, bs) + /// `GenericBoundFailure(p, s, a) /// /// The parameter/associated-type `p` must be known to outlive the lifetime - /// `a`, but it is only known to outlive `bs` (and none of the - /// regions in `bs` outlive `a`). - GenericBoundFailure(SubregionOrigin<'tcx>, GenericKind<'tcx>, Region, Vec), + /// `a` (but none of the known bounds are sufficient). + GenericBoundFailure(SubregionOrigin<'tcx>, GenericKind<'tcx>, Region), /// `SubSupConflict(v, sub_origin, sub_r, sup_origin, sup_r)`: /// @@ -408,6 +433,14 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { debug!("RegionVarBindings: add_verify({:?})", verify); + // skip no-op cases known to be satisfied + match verify { + VerifyGenericBound(_, _, _, VerifyBound::AllBounds(ref bs)) if bs.len() == 0 => { + return; + } + _ => { } + } + let mut verifys = self.verifys.borrow_mut(); let index = verifys.len(); verifys.push(verify); @@ -497,8 +530,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { origin: SubregionOrigin<'tcx>, kind: GenericKind<'tcx>, sub: Region, - sups: Vec) { - self.add_verify(VerifyGenericBound(kind, origin, sub, sups)); + bound: VerifyBound) { + self.add_verify(VerifyGenericBound(kind, origin, sub, bound)); } pub fn lub_regions(&self, @@ -663,12 +696,11 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { &mut result_set, r, a, b); } - VerifyGenericBound(_, _, a, ref bs) => { - for &b in bs { - consider_adding_bidirectional_edges( - &mut result_set, r, - a, b); - } + VerifyGenericBound(_, _, a, ref bound) => { + bound.for_each_region(&mut |b| { + consider_adding_bidirectional_edges(&mut result_set, r, + a, b) + }); } } } @@ -1258,26 +1290,22 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { continue; } - debug!("ConcreteFailure: !(sub <= sup): sub={:?}, sup={:?}", - sub, - sup); + debug!("region inference error at {:?}: {:?} <= {:?} is not true", + origin, sub, sup); + errors.push(ConcreteFailure((*origin).clone(), sub, sup)); } - VerifyGenericBound(ref kind, ref origin, sub, ref sups) => { + VerifyGenericBound(ref kind, ref origin, sub, ref bound) => { let sub = normalize(values, sub); - if sups.iter() - .map(|&sup| normalize(values, sup)) - .any(|sup| free_regions.is_subregion_of(self.tcx, sub, sup)) - { + if bound.is_met(self.tcx, free_regions, values, sub) { continue; } - let sups = sups.iter().map(|&sup| normalize(values, sup)) - .collect(); - errors.push( - GenericBoundFailure( - (*origin).clone(), kind.clone(), sub, sups)); + debug!("region inference error at {:?}: verifying {:?} <= {:?}", + origin, sub, bound); + + errors.push(GenericBoundFailure((*origin).clone(), kind.clone(), sub)); } } } @@ -1438,10 +1466,12 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { if !free_regions.is_subregion_of(self.tcx, lower_bound.region, upper_bound.region) { - debug!("pushing SubSupConflict sub: {:?} sup: {:?}", - lower_bound.region, upper_bound.region); + let origin = (*self.var_origins.borrow())[node_idx.index as usize].clone(); + debug!("region inference error at {:?} for {:?}: \ + SubSupConflict sub: {:?} sup: {:?}", + origin, node_idx, lower_bound.region, upper_bound.region); errors.push(SubSupConflict( - (*self.var_origins.borrow())[node_idx.index as usize].clone(), + origin, lower_bound.origin.clone(), lower_bound.region, upper_bound.origin.clone(), @@ -1484,16 +1514,20 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { match self.glb_concrete_regions(free_regions, upper_bound_1.region, upper_bound_2.region) { - Ok(_) => {} - Err(_) => { - errors.push(SupSupConflict( - (*self.var_origins.borrow())[node_idx.index as usize].clone(), - upper_bound_1.origin.clone(), - upper_bound_1.region, - upper_bound_2.origin.clone(), - upper_bound_2.region)); - return; - } + Ok(_) => {} + Err(_) => { + let origin = (*self.var_origins.borrow())[node_idx.index as usize].clone(); + debug!("region inference error at {:?} for {:?}: \ + SupSupConflict sub: {:?} sup: {:?}", + origin, node_idx, upper_bound_1.region, upper_bound_2.region); + errors.push(SupSupConflict( + origin, + upper_bound_1.origin.clone(), + upper_bound_1.region, + upper_bound_2.origin.clone(), + upper_bound_2.region)); + return; + } } } } @@ -1676,3 +1710,82 @@ impl<'tcx> GenericKind<'tcx> { } } } + +impl VerifyBound { + fn for_each_region(&self, f: &mut FnMut(ty::Region)) { + match self { + &VerifyBound::AnyRegion(ref rs) | + &VerifyBound::AllRegions(ref rs) => + for &r in rs { f(r); }, + + &VerifyBound::AnyBound(ref bs) | + &VerifyBound::AllBounds(ref bs) => + for b in bs { b.for_each_region(f); }, + } + } + + pub fn must_hold(&self) -> bool { + match self { + &VerifyBound::AnyRegion(ref bs) => bs.contains(&ty::ReStatic), + &VerifyBound::AllRegions(ref bs) => bs.is_empty(), + &VerifyBound::AnyBound(ref bs) => bs.iter().any(|b| b.must_hold()), + &VerifyBound::AllBounds(ref bs) => bs.iter().all(|b| b.must_hold()), + } + } + + pub fn cannot_hold(&self) -> bool { + match self { + &VerifyBound::AnyRegion(ref bs) => bs.is_empty(), + &VerifyBound::AllRegions(ref bs) => bs.contains(&ty::ReEmpty), + &VerifyBound::AnyBound(ref bs) => bs.iter().all(|b| b.cannot_hold()), + &VerifyBound::AllBounds(ref bs) => bs.iter().any(|b| b.cannot_hold()), + } + } + + pub fn or(self, vb: VerifyBound) -> VerifyBound { + if self.must_hold() || vb.cannot_hold() { + self + } else if self.cannot_hold() || vb.must_hold() { + vb + } else { + VerifyBound::AnyBound(vec![self, vb]) + } + } + + pub fn and(self, vb: VerifyBound) -> VerifyBound { + if self.must_hold() && vb.must_hold() { + self + } else if self.cannot_hold() && vb.cannot_hold() { + self + } else { + VerifyBound::AllBounds(vec![self, vb]) + } + } + + fn is_met<'tcx>(&self, + tcx: &ty::ctxt<'tcx>, + free_regions: &FreeRegionMap, + var_values: &Vec, + min: ty::Region) + -> bool { + match self { + &VerifyBound::AnyRegion(ref rs) => + rs.iter() + .map(|&r| normalize(var_values, r)) + .any(|r| free_regions.is_subregion_of(tcx, min, r)), + + &VerifyBound::AllRegions(ref rs) => + rs.iter() + .map(|&r| normalize(var_values, r)) + .all(|r| free_regions.is_subregion_of(tcx, min, r)), + + &VerifyBound::AnyBound(ref bs) => + bs.iter() + .any(|b| b.is_met(tcx, free_regions, var_values, min)), + + &VerifyBound::AllBounds(ref bs) => + bs.iter() + .all(|b| b.is_met(tcx, free_regions, var_values, min)), + } + } +} diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 925ea11690125..1fed29ec68e71 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -568,7 +568,29 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { type_must_outlive(rcx, infer::ExprTypeIsNotInScope(expr_ty, expr.span), expr_ty, ty::ReScope(CodeExtent::from_node_id(expr.id))); - let has_method_map = rcx.fcx.infcx().is_method_call(expr.id); + let method_call = MethodCall::expr(expr.id); + let opt_method_callee = rcx.fcx.inh.tables.borrow().method_map.get(&method_call).cloned(); + let has_method_map = opt_method_callee.is_some(); + + // the region corresponding to this expression + let expr_region = ty::ReScope(CodeExtent::from_node_id(expr.id)); + + // If we are calling a method (either explicitly or via an + // overloaded operator), check that all of the types provided as + // arguments for its type parameters are well-formed, and all the regions + // provided as arguments outlive the call. + if let Some(callee) = opt_method_callee { + let origin = match expr.node { + ast::ExprMethodCall(..) => + infer::ParameterOrigin::MethodCall, + ast::ExprUnary(op, _) if op == ast::UnDeref => + infer::ParameterOrigin::OverloadedDeref, + _ => + infer::ParameterOrigin::OverloadedOperator + }; + + substs_wf_in_scope(rcx, origin, &callee.substs, expr.span, expr_region); + } // Check any autoderefs or autorefs that appear. let adjustment = rcx.fcx.inh.tables.borrow().adjustments.get(&expr.id).map(|a| a.clone()); @@ -639,6 +661,13 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { } match expr.node { + ast::ExprPath(..) => { + rcx.fcx.opt_node_ty_substs(expr.id, |item_substs| { + let origin = infer::ParameterOrigin::Path; + substs_wf_in_scope(rcx, origin, &item_substs.substs, expr.span, expr_region); + }); + } + ast::ExprCall(ref callee, ref args) => { if has_method_map { constrain_call(rcx, expr, Some(&**callee), @@ -949,6 +978,9 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, debug!("constrain_autoderefs: #{} is overloaded, method={:?}", i, method); + let origin = infer::ParameterOrigin::OverloadedDeref; + substs_wf_in_scope(rcx, origin, method.substs, deref_expr.span, r_deref_expr); + // Treat overloaded autoderefs as if an AutoRef adjustment // was applied on the base type, as that is always the case. let fn_sig = method.ty.fn_sig(); @@ -1250,6 +1282,9 @@ fn link_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, let mut borrow_cmt = borrow_cmt; let mut borrow_kind = borrow_kind; + let origin = infer::DataBorrowed(borrow_cmt.ty, span); + type_must_outlive(rcx, origin, borrow_cmt.ty, *borrow_region); + loop { debug!("link_region(borrow_region={:?}, borrow_kind={:?}, borrow_cmt={:?})", borrow_region, @@ -1449,74 +1484,371 @@ fn link_reborrowed_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, } } -/// Ensures that all borrowed data reachable via `ty` outlives `region`. -pub fn type_must_outlive<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, - origin: infer::SubregionOrigin<'tcx>, - ty: Ty<'tcx>, - region: ty::Region) +/// Checks that the values provided for type/region arguments in a given +/// expression are well-formed and in-scope. +pub fn substs_wf_in_scope<'a,'tcx>(rcx: &mut Rcx<'a,'tcx>, + origin: infer::ParameterOrigin, + substs: &Substs<'tcx>, + expr_span: Span, + expr_region: ty::Region) { + debug!("substs_wf_in_scope(substs={:?}, \ + expr_region={:?}, \ + origin={:?}, \ + expr_span={:?})", + substs, expr_region, origin, expr_span); + + let origin = infer::ParameterInScope(origin, expr_span); + + for ®ion in substs.regions() { + rcx.fcx.mk_subr(origin.clone(), expr_region, region); + } + + for &ty in &substs.types { + let ty = rcx.resolve_type(ty); + type_must_outlive(rcx, origin.clone(), ty, expr_region); + } +} + +/// Ensures that type is well-formed in `region`, which implies (among +/// other things) that all borrowed data reachable via `ty` outlives +/// `region`. +pub fn type_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, + origin: infer::SubregionOrigin<'tcx>, + ty: Ty<'tcx>, + region: ty::Region) { + let ty = rcx.resolve_type(ty); + debug!("type_must_outlive(ty={:?}, region={:?})", ty, region); - let implications = implicator::implications(rcx.fcx.infcx(), rcx.body_id, - ty, region, origin.span()); - for implication in implications { - debug!("implication: {:?}", implication); - match implication { - implicator::Implication::RegionSubRegion(None, r_a, r_b) => { - rcx.fcx.mk_subr(origin.clone(), r_a, r_b); + assert!(!ty.has_escaping_regions()); + + let components = outlives::components(rcx.infcx(), ty); + components_must_outlive(rcx, origin, components, region); +} + +fn components_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, + origin: infer::SubregionOrigin<'tcx>, + components: Vec>, + region: ty::Region) +{ + for component in components { + let origin = origin.clone(); + match component { + outlives::Component::Region(region1) => { + rcx.fcx.mk_subr(origin, region, region1); } - implicator::Implication::RegionSubRegion(Some(ty), r_a, r_b) => { - let o1 = infer::ReferenceOutlivesReferent(ty, origin.span()); - rcx.fcx.mk_subr(o1, r_a, r_b); + outlives::Component::Param(param_ty) => { + param_ty_must_outlive(rcx, origin, region, param_ty); } - implicator::Implication::RegionSubGeneric(None, r_a, ref generic_b) => { - generic_must_outlive(rcx, origin.clone(), r_a, generic_b); + outlives::Component::Projection(projection_ty) => { + projection_must_outlive(rcx, origin, region, projection_ty); } - implicator::Implication::RegionSubGeneric(Some(ty), r_a, ref generic_b) => { - let o1 = infer::ReferenceOutlivesReferent(ty, origin.span()); - generic_must_outlive(rcx, o1, r_a, generic_b); + outlives::Component::EscapingProjection(subcomponents) => { + components_must_outlive(rcx, origin, subcomponents, region); } - implicator::Implication::Predicate(def_id, predicate) => { - let cause = traits::ObligationCause::new(origin.span(), - rcx.body_id, - traits::ItemObligation(def_id)); - let obligation = traits::Obligation::new(cause, predicate); - rcx.fcx.register_predicate(obligation); + outlives::Component::UnresolvedInferenceVariable(_) => { + // ignore this, we presume it will yield an error + // later, since if a type variable is not resolved by + // this point it never will be + } + outlives::Component::RFC1214(subcomponents) => { + let suborigin = infer::RFC1214Subregion(Rc::new(origin)); + components_must_outlive(rcx, suborigin, subcomponents, region); } } } } -fn generic_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, - origin: infer::SubregionOrigin<'tcx>, - region: ty::Region, - generic: &GenericKind<'tcx>) { - let param_env = &rcx.fcx.inh.infcx.parameter_environment; +/// Checks that all data reachable via `ty` *strictly* outlives `scope`. +/// This is used by dropck. +/// +/// CAUTION: It is mostly but not entirely equivalent to `T:'parent` +/// where `'parent` is the parent of `scope`. The difference is subtle +/// and has to do with trait objects, primarily. In particular, if you +/// have `Foo<'y>+'z`, then we require that `'z:'parent` but not +/// `'y:'parent` (same with lifetimes appearing in fn arguments). This +/// is because there is no actual reference to the trait object that +/// outlives `scope`, so we don't need to require that the type could +/// be named outside `scope`. Because trait objects are always +/// considered "suspicious" by dropck, if we don't add this special +/// case, you wind up with some kind of annoying and odd limitations +/// that crop up +/// `src/test/compile-fail/regions-early-bound-trait-param.rs`. +/// Basically there we have `&'foo Trait<'foo>+'bar`, and thus forcing +/// `'foo` to outlive `'parent` also forces the borrow to outlive +/// `'parent`, which is longer than should be necessary. The existence +/// of this "the same but different" predicate is somewhat bothersome +/// and questionable. +pub fn type_strictly_outlives<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, + origin: infer::SubregionOrigin<'tcx>, + ty: Ty<'tcx>, + scope: CodeExtent) +{ + debug!("type_strictly_outlives(ty={:?}, scope={:?})", + ty, scope); - debug!("param_must_outlive(region={:?}, generic={:?})", - region, - generic); + let span = origin.span(); - // To start, collect bounds from user: - let mut param_bounds = rcx.tcx().required_region_bounds(generic.to_ty(rcx.tcx()), - param_env.caller_bounds.clone()); + let parent_region = + match rcx.tcx().region_maps.opt_encl_scope(scope) { + Some(parent_scope) => ty::ReScope(parent_scope), + None => rcx.tcx().sess.span_bug( + span, &format!("no enclosing scope found for scope: {:?}", + scope)), + }; + + type_must_outlive(rcx, origin, ty, parent_region); +} + +fn param_ty_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, + origin: infer::SubregionOrigin<'tcx>, + region: ty::Region, + param_ty: ty::ParamTy) { + debug!("param_ty_must_outlive(region={:?}, param_ty={:?}, origin={:?})", + region, param_ty, origin); + + let verify_bound = param_bound(rcx, param_ty); + let generic = GenericKind::Param(param_ty); + rcx.fcx.infcx().verify_generic_bound(origin, generic, region, verify_bound); +} + +fn projection_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, + origin: infer::SubregionOrigin<'tcx>, + region: ty::Region, + projection_ty: ty::ProjectionTy<'tcx>) { + debug!("projection_must_outlive(region={:?}, projection_ty={:?}, origin={:?})", + region, projection_ty, origin); + + // This is a particularly thorny situation for inference, and for + // now we don't have a complete solution, we just do the best we + // can. The problem is that there are multiple ways for `>::Foo: 'r` to be satisfied: + // + // 1. If `Pi: 'r` forall i, it is satisfied. + // 2. If there is a suitable where-clause, it can be satisfied. + // 3. The trait declaration may declare `'static` bounds on `Foo` as well. + // + // The fact that there are so many options here makes this thorny. + // In the case of parameter relations like `T: 'r`, it's somewhat + // simpler, because checking such a relation does not affect + // inference. This is true because the region bounds we can + // derive for `T` never involve region variables -- they are + // always free regions. The only place a region variable can come + // is on the RHS, and in that case, the smaller the region, the + // better. This means that our current inference, which always + // infers the smallest region it can, can just be used, and we'll + // know what the smallest value for `'r` is when it's done. We can + // then compare that to the regions in the LHS, which are already + // as big as possible, and we're all done. + // + // Projections can in fact be this simple as well. In particular, + // if the parameters `P0..Pn` do not involve any region variables, + // that's the same situation. + // + // Where things get thorny is when region variables are involved, + // because in that case relating `Pi: 'r` may influence the + // inference process, since it could cause `'r` to be inferred to + // a larger value. But the problem is that if we add that as a + // constraint into our dataflow graph, we've essentially committed + // to using option 1 (above) to show that `>::Foo: 'r` is satisfied, and it may be that + // Option 1 does not apply, but Option 2 or 3 does. But we can't + // know that now. + // + // For now we choose to accept this. It's a conservative choice, + // so we can move to a more sophisticated inference model later. + // And it's sometimes possible to workaround by introducing + // explicit type parameters or type annotations. But it ain't + // great! + + let declared_bounds = projection_declared_bounds(rcx, origin.span(), projection_ty); + + debug!("projection_must_outlive: declared_bounds={:?}", + declared_bounds); + + // If we know that the projection outlives 'static, then we're done here. + if declared_bounds.contains(&ty::ReStatic) { + return; + } + + // Determine whether any of regions that appear in the projection + // were declared as bounds by the user. This is typically a situation + // like this: + // + // trait Foo<'a> { + // type Bar: 'a; + // } + // + // where we are checking `>: '_#1r`. In such a + // case, if we use the conservative rule, we will check that + // BOTH of the following hold: + // + // T: _#1r + // _#0r: _#1r + // + // This is overkill, since the declared bounds tell us that the + // the latter is sufficient. + let intersection_bounds: Vec<_> = + projection_ty.trait_ref.substs.regions() + .iter() + .filter(|r| declared_bounds.contains(r)) + .collect(); + let intersection_bounds_needs_infer = + intersection_bounds.iter() + .any(|r| r.needs_infer()); + if intersection_bounds_needs_infer { + // If the upper bound(s) (`_#0r` in the above example) are + // region variables, then introduce edges into the inference + // graph, because we need to ensure that `_#0r` is inferred to + // something big enough. But if the upper bound has no + // inference, then fallback (below) to the verify path, where + // we just check after the fact that it was big enough. This + // is more flexible, because it only requires that there + // exists SOME intersection bound that is big enough, whereas + // this path requires that ALL intersection bounds be big + // enough. + debug!("projection_must_outlive: intersection_bounds={:?}", + intersection_bounds); + for &r in intersection_bounds { + rcx.fcx.mk_subr(origin.clone(), region, r); + } + return; + } + + // If there are no intersection bounds, but there are still + // inference variables involves, then fallback to the most + // conservative rule, where we require all components of the + // projection outlive the bound. + if + intersection_bounds.is_empty() && ( + projection_ty.trait_ref.substs.types.iter().any(|t| t.needs_infer()) || + projection_ty.trait_ref.substs.regions().iter().any(|r| r.needs_infer())) + { + debug!("projection_must_outlive: fallback to rule #1"); - // In the case of a projection T::Foo, we may be able to extract bounds from the trait def: - match *generic { - GenericKind::Param(..) => { } - GenericKind::Projection(ref projection_ty) => { - param_bounds.push_all( - &projection_bounds(rcx, origin.span(), projection_ty)); + for &component_ty in &projection_ty.trait_ref.substs.types { + type_must_outlive(rcx, origin.clone(), component_ty, region); } + + for &r in projection_ty.trait_ref.substs.regions() { + rcx.fcx.mk_subr(origin.clone(), region, r); + } + + return; } + // Inform region inference that this generic must be properly + // bounded. + let verify_bound = projection_bound(rcx, origin.span(), declared_bounds, projection_ty); + let generic = GenericKind::Projection(projection_ty); + rcx.fcx.infcx().verify_generic_bound(origin, generic.clone(), region, verify_bound); +} + +fn type_bound<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, span: Span, ty: Ty<'tcx>) -> VerifyBound { + match ty.sty { + ty::TyParam(p) => { + param_bound(rcx, p) + } + ty::TyProjection(data) => { + let declared_bounds = projection_declared_bounds(rcx, span, data); + projection_bound(rcx, span, declared_bounds, data) + } + _ => { + recursive_type_bound(rcx, span, ty) + } + } +} + +fn param_bound<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, param_ty: ty::ParamTy) -> VerifyBound { + let param_env = &rcx.infcx().parameter_environment; + + debug!("param_bound(param_ty={:?})", + param_ty); + + let mut param_bounds = declared_generic_bounds_from_env(rcx, GenericKind::Param(param_ty)); + // Add in the default bound of fn body that applies to all in // scope type parameters: param_bounds.push(param_env.implicit_region_bound); - // Finally, collect regions we scraped from the well-formedness + VerifyBound::AnyRegion(param_bounds) +} + +fn projection_declared_bounds<'a, 'tcx>(rcx: &Rcx<'a,'tcx>, + span: Span, + projection_ty: ty::ProjectionTy<'tcx>) + -> Vec +{ + // First assemble bounds from where clauses and traits. + + let mut declared_bounds = + declared_generic_bounds_from_env(rcx, GenericKind::Projection(projection_ty)); + + declared_bounds.push_all( + &declared_projection_bounds_from_trait(rcx, span, projection_ty)); + + declared_bounds +} + +fn projection_bound<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, + span: Span, + declared_bounds: Vec, + projection_ty: ty::ProjectionTy<'tcx>) + -> VerifyBound { + debug!("projection_bound(declared_bounds={:?}, projection_ty={:?})", + declared_bounds, projection_ty); + + // see the extensive comment in projection_must_outlive + + // this routine is not invoked in this case + assert!( + !projection_ty.trait_ref.substs.types.iter().any(|t| t.needs_infer()) && + !projection_ty.trait_ref.substs.regions().iter().any(|r| r.needs_infer())); + + let ty = rcx.tcx().mk_projection(projection_ty.trait_ref, projection_ty.item_name); + let recursive_bound = recursive_type_bound(rcx, span, ty); + + VerifyBound::AnyRegion(declared_bounds).or(recursive_bound) +} + +fn recursive_type_bound<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, + span: Span, + ty: Ty<'tcx>) + -> VerifyBound { + let mut bounds = vec![]; + + for subty in ty.walk_shallow() { + bounds.push(type_bound(rcx, span, subty)); + } + + let mut regions = ty.regions(); + regions.retain(|r| !r.is_bound()); // ignore late-bound regions + bounds.push(VerifyBound::AllRegions(ty.regions())); + + // remove bounds that must hold, since they are not interesting + bounds.retain(|b| !b.must_hold()); + + if bounds.len() == 1 { + bounds.pop().unwrap() + } else { + VerifyBound::AllBounds(bounds) + } +} + +fn declared_generic_bounds_from_env<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, + generic: GenericKind<'tcx>) + -> Vec +{ + let param_env = &rcx.infcx().parameter_environment; + + // To start, collect bounds from user: + let mut param_bounds = rcx.tcx().required_region_bounds(generic.to_ty(rcx.tcx()), + param_env.caller_bounds.clone()); + + // Next, collect regions we scraped from the well-formedness // constraints in the fn signature. To do that, we walk the list // of known relations from the fn ctxt. // @@ -1527,27 +1859,22 @@ fn generic_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, // The problem is that the type of `x` is `&'a A`. To be // well-formed, then, A must be lower-generic by `'a`, but we // don't know that this holds from first principles. - for &(ref r, ref p) in &rcx.region_bound_pairs { + for &(r, p) in &rcx.region_bound_pairs { debug!("generic={:?} p={:?}", generic, p); if generic == p { - param_bounds.push(*r); + param_bounds.push(r); } } - // Inform region inference that this generic must be properly - // bounded. - rcx.fcx.infcx().verify_generic_bound(origin, - generic.clone(), - region, - param_bounds); + param_bounds } -fn projection_bounds<'a,'tcx>(rcx: &Rcx<'a, 'tcx>, - span: Span, - projection_ty: &ty::ProjectionTy<'tcx>) - -> Vec +fn declared_projection_bounds_from_trait<'a,'tcx>(rcx: &Rcx<'a, 'tcx>, + span: Span, + projection_ty: ty::ProjectionTy<'tcx>) + -> Vec { let fcx = rcx.fcx; let tcx = fcx.tcx(); From 788a802dad3f273b74150b732d24d37a695d29f6 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 13:25:23 -0400 Subject: [PATCH 10/38] New tests --- projection outlives relation --- .../compile-fail/associated-types-outlives.rs | 38 +++++++++++++ ...gions-close-associated-type-into-object.rs | 9 ++- ...regions-implied-bounds-projection-gap-1.rs | 40 +++++++++++++ ...regions-implied-bounds-projection-gap-2.rs | 33 +++++++++++ ...regions-implied-bounds-projection-gap-3.rs | 33 +++++++++++ ...regions-implied-bounds-projection-gap-4.rs | 33 +++++++++++ ...ions-implied-bounds-projection-gap-hr-1.rs | 39 +++++++++++++ .../regions-outlives-nominal-type-enum.rs | 56 +++++++++++++++++++ .../regions-outlives-nominal-type-struct.rs | 56 +++++++++++++++++++ ...ons-outlives-projection-container-hrtb.rs} | 11 ++-- ...gions-outlives-projection-container-wc.rs} | 0 ... regions-outlives-projection-container.rs} | 11 ++-- .../regions-outlives-projection-trait-def.rs | 31 ++++++++++ .../compile-fail/regions-outlives-scalar.rs | 23 ++++++++ .../traits-issue-23003-overflow.rs | 15 ++--- 15 files changed, 405 insertions(+), 23 deletions(-) create mode 100644 src/test/compile-fail/associated-types-outlives.rs create mode 100644 src/test/compile-fail/regions-implied-bounds-projection-gap-1.rs create mode 100644 src/test/compile-fail/regions-implied-bounds-projection-gap-2.rs create mode 100644 src/test/compile-fail/regions-implied-bounds-projection-gap-3.rs create mode 100644 src/test/compile-fail/regions-implied-bounds-projection-gap-4.rs create mode 100644 src/test/compile-fail/regions-implied-bounds-projection-gap-hr-1.rs create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-enum.rs create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-struct.rs rename src/test/compile-fail/{regions-assoc-type-outlives-container-hrtb.rs => regions-outlives-projection-container-hrtb.rs} (82%) rename src/test/compile-fail/{regions-assoc-type-outlives-container-wc.rs => regions-outlives-projection-container-wc.rs} (100%) rename src/test/compile-fail/{regions-assoc-type-outlives-container.rs => regions-outlives-projection-container.rs} (86%) create mode 100644 src/test/compile-fail/regions-outlives-projection-trait-def.rs create mode 100644 src/test/compile-fail/regions-outlives-scalar.rs diff --git a/src/test/compile-fail/associated-types-outlives.rs b/src/test/compile-fail/associated-types-outlives.rs new file mode 100644 index 0000000000000..f070ab6799c08 --- /dev/null +++ b/src/test/compile-fail/associated-types-outlives.rs @@ -0,0 +1,38 @@ +// Copyright 2015 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. + +// Regression test for issue #24622. The older associated types code +// was erroneously assuming that all projections outlived the current +// fn body, causing this (invalid) code to be accepted. + +pub trait Foo<'a> { + type Bar; +} + +impl<'a, T:'a> Foo<'a> for T { + type Bar = &'a T; +} + +fn denormalise<'a, T>(t: &'a T) -> >::Bar { + t +} + +pub fn free_and_use Foo<'a>, + F: for<'a> FnOnce(>::Bar)>(x: T, f: F) { + let y; + 'body: loop { // lifetime annotations added for clarity + 's: loop { y = denormalise(&x); break } + drop(x); //~ ERROR cannot move out of `x` because it is borrowed + return f(y); + } +} + +pub fn main() { +} diff --git a/src/test/compile-fail/regions-close-associated-type-into-object.rs b/src/test/compile-fail/regions-close-associated-type-into-object.rs index fdc97ecaf21e2..61897aac18769 100644 --- a/src/test/compile-fail/regions-close-associated-type-into-object.rs +++ b/src/test/compile-fail/regions-close-associated-type-into-object.rs @@ -72,13 +72,12 @@ fn meh1<'a, T: Iter>(v: &'a T) -> Box where T::Item : Clone { // This case is kind of interesting. It's the same as `ok3` but - // without the explicit declaration. In principle, it seems like - // we ought to be able to infer that `T::Item : 'a` because we - // invoked `v.as_self()` which yielded a value of type `&'a - // T::Item`. But we're not that smart at present. + // without the explicit declaration. This is valid because `T: 'a + // => T::Item: 'a`, and the former we can deduce from our argument + // of type `&'a T`. let item = Clone::clone(v.as_item()); - Box::new(item) //~ ERROR associated type `::Item` may not live + Box::new(item) } fn main() {} diff --git a/src/test/compile-fail/regions-implied-bounds-projection-gap-1.rs b/src/test/compile-fail/regions-implied-bounds-projection-gap-1.rs new file mode 100644 index 0000000000000..65594ab8f2e29 --- /dev/null +++ b/src/test/compile-fail/regions-implied-bounds-projection-gap-1.rs @@ -0,0 +1,40 @@ +// Copyright 2012 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. + +// Illustrates the "projection gap": in this test, even though we know +// that `T::Foo: 'x`, that does not tell us that `T: 'x`, because +// there might be other ways for the caller of `func` to show that +// `T::Foo: 'x` holds (e.g., where-clause). + +trait Trait1<'x> { + type Foo; +} + +// calling this fn should trigger a check that the type argument +// supplied is well-formed. +fn wf() { } + +fn func<'x, T:Trait1<'x>>(t: &'x T::Foo) +{ + wf::<&'x T>(); + //~^ ERROR the parameter type `T` may not live long enough +} + +fn caller2<'x, T:Trait1<'x>>(t: &'x T) +{ + wf::<&'x T::Foo>(); // OK +} + +fn caller3<'x, T:Trait1<'x>>(t: &'x T::Foo) +{ + wf::<&'x T::Foo>(); // OK +} + +fn main() { } diff --git a/src/test/compile-fail/regions-implied-bounds-projection-gap-2.rs b/src/test/compile-fail/regions-implied-bounds-projection-gap-2.rs new file mode 100644 index 0000000000000..b3037a1e187f4 --- /dev/null +++ b/src/test/compile-fail/regions-implied-bounds-projection-gap-2.rs @@ -0,0 +1,33 @@ +// Copyright 2012 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. + +// Along with the other tests in this series, illustrates the +// "projection gap": in this test, we know that `T: 'x`, and that is +// enough to conclude that `T::Foo: 'x`. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +trait Trait1<'x> { + type Foo; +} + +// calling this fn should trigger a check that the type argument +// supplied is well-formed. +fn wf() { } + +fn func<'x, T:Trait1<'x>>(t: &'x T) +{ + wf::<&'x T::Foo>(); +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/regions-implied-bounds-projection-gap-3.rs b/src/test/compile-fail/regions-implied-bounds-projection-gap-3.rs new file mode 100644 index 0000000000000..a2e6de2137696 --- /dev/null +++ b/src/test/compile-fail/regions-implied-bounds-projection-gap-3.rs @@ -0,0 +1,33 @@ +// Copyright 2012 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. + +// Along with the other tests in this series, illustrates the +// "projection gap": in this test, we know that `T::Foo: 'x`, and that +// is (naturally) enough to conclude that `T::Foo: 'x`. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +trait Trait1<'x> { + type Foo; +} + +// calling this fn should trigger a check that the type argument +// supplied is well-formed. +fn wf() { } + +fn func<'x, T:Trait1<'x>>(t: &'x T::Foo) +{ + wf::<&'x T::Foo>(); +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/regions-implied-bounds-projection-gap-4.rs b/src/test/compile-fail/regions-implied-bounds-projection-gap-4.rs new file mode 100644 index 0000000000000..b8582f8c26b31 --- /dev/null +++ b/src/test/compile-fail/regions-implied-bounds-projection-gap-4.rs @@ -0,0 +1,33 @@ +// Copyright 2012 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. + +// Along with the other tests in this series, illustrates the +// "projection gap": in this test, we know that `T: 'x`, and that +// is (naturally) enough to conclude that `T: 'x`. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +trait Trait1<'x> { + type Foo; +} + +// calling this fn should trigger a check that the type argument +// supplied is well-formed. +fn wf() { } + +fn func<'x, T:Trait1<'x>>(t: &'x T) +{ + wf::<&'x T>(); +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/regions-implied-bounds-projection-gap-hr-1.rs b/src/test/compile-fail/regions-implied-bounds-projection-gap-hr-1.rs new file mode 100644 index 0000000000000..47985f931dd34 --- /dev/null +++ b/src/test/compile-fail/regions-implied-bounds-projection-gap-hr-1.rs @@ -0,0 +1,39 @@ +// Copyright 2012 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. + +// The "projection gap" is particularly "fun" around higher-ranked +// projections. This is because the current code is hard-coded to say +// that a projection that contains escaping regions, like `>::Foo` where `'z` is bound, can only be found to +// outlive a region if all components that appear free (`'y`, where) +// outlive that region. However, we DON'T add those components to the +// implied bounds set, but rather we treat projections with escaping +// regions as opaque entities, just like projections without escaping +// regions. + +trait Trait1 { } + +trait Trait2<'a, 'b> { + type Foo; +} + +fn wf() { } + +// As a side-effect of the conservative process above, this argument +// is not automatically considered well-formed, since for it to be WF, +// we would need to know that `'y: 'x`, but we do not infer that. +fn callee<'x, 'y, T>( + t: &'x for<'z> Trait1< >::Foo >) +{ + wf::<&'x &'y i32>(); + //~^ ERROR reference has a longer lifetime than the data it references +} + +fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-enum.rs b/src/test/compile-fail/regions-outlives-nominal-type-enum.rs new file mode 100644 index 0000000000000..6fb409326f1f7 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-enum.rs @@ -0,0 +1,56 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod variant_enum_region { + enum Foo<'a> { + V { x: &'a i32 } + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<'b> + } +} + +mod rev_variant_enum_region { + enum Foo<'a> { + V { x: fn(&'a i32) } + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<'b> + } +} + +mod variant_enum_type { + enum Foo { + V { x: T } + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<&'b i32> + } +} + +mod rev_variant_enum_type { + enum Foo { + V { x: fn(T) } + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<&'b i32> + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-struct.rs b/src/test/compile-fail/regions-outlives-nominal-type-struct.rs new file mode 100644 index 0000000000000..fb3fdddae8879 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-struct.rs @@ -0,0 +1,56 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod variant_struct_region { + struct Foo<'a> { + x: &'a i32, + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<'b> + } +} + +mod rev_variant_struct_region { + struct Foo<'a> { + x: fn(&'a i32), + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<'b> + } +} + +mod variant_struct_type { + struct Foo { + x: T + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<&'b i32> + } +} + +mod rev_variant_struct_type { + struct Foo { + x: fn(T) + } + struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime + f: &'a Foo<&'b i32> + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-assoc-type-outlives-container-hrtb.rs b/src/test/compile-fail/regions-outlives-projection-container-hrtb.rs similarity index 82% rename from src/test/compile-fail/regions-assoc-type-outlives-container-hrtb.rs rename to src/test/compile-fail/regions-outlives-projection-container-hrtb.rs index 0d3d2e296bec6..b8c4a7f8a8c05 100644 --- a/src/test/compile-fail/regions-assoc-type-outlives-container-hrtb.rs +++ b/src/test/compile-fail/regions-outlives-projection-container-hrtb.rs @@ -37,10 +37,10 @@ pub struct WithHrAssoc } fn with_assoc<'a,'b>() { - // We get no error here because the where clause has a higher-ranked assoc type, - // which could not be projected from. + // We get an error because beacuse 'b:'a does not hold: let _: &'a WithHrAssoc> = loop { }; + //~^ ERROR reference has a longer lifetime } /////////////////////////////////////////////////////////////////////////// @@ -57,12 +57,13 @@ pub struct WithHrAssocSub } fn with_assoc_sub<'a,'b>() { - // Same here, because although the where clause is not HR, it - // extends a trait in a HR way. + // The error here is just because `'b:'a` must hold for the type + // below to be well-formed, it is not related to the HR relation. let _: &'a WithHrAssocSub> = loop { }; + //~^ ERROR reference has a longer lifetime } #[rustc_error] -fn main() { //~ ERROR compilation successful +fn main() { } diff --git a/src/test/compile-fail/regions-assoc-type-outlives-container-wc.rs b/src/test/compile-fail/regions-outlives-projection-container-wc.rs similarity index 100% rename from src/test/compile-fail/regions-assoc-type-outlives-container-wc.rs rename to src/test/compile-fail/regions-outlives-projection-container-wc.rs diff --git a/src/test/compile-fail/regions-assoc-type-outlives-container.rs b/src/test/compile-fail/regions-outlives-projection-container.rs similarity index 86% rename from src/test/compile-fail/regions-assoc-type-outlives-container.rs rename to src/test/compile-fail/regions-outlives-projection-container.rs index e3e57ff17115c..6f5ebf2d1cecf 100644 --- a/src/test/compile-fail/regions-assoc-type-outlives-container.rs +++ b/src/test/compile-fail/regions-outlives-projection-container.rs @@ -59,11 +59,10 @@ fn with_assoc1<'a,'b>() where 'b : 'a { } fn without_assoc<'a,'b>() { - // Here there are no associated types and the `'b` appearing in - // `TheType<'b>` is purely covariant, so there is no requirement - // that `'b:'a` holds. + // Here there are no associated types but there is a requirement + // that `'b:'a` holds because the `'b` appears in `TheType<'b>`. - let _: &'a WithoutAssoc> = loop { }; + let _: &'a WithoutAssoc> = loop { }; //~ ERROR reference has a longer lifetime } fn call_with_assoc<'a,'b>() { @@ -72,13 +71,13 @@ fn call_with_assoc<'a,'b>() { // no data. call::<&'a WithAssoc>>(); - //~^ ERROR cannot infer + //~^ ERROR reference has a longer lifetime } fn call_without_assoc<'a,'b>() { // As `without_assoc`, but in a distinct scenario. - call::<&'a WithoutAssoc>>(); + call::<&'a WithoutAssoc>>(); //~ ERROR reference has a longer lifetime } fn call() { } diff --git a/src/test/compile-fail/regions-outlives-projection-trait-def.rs b/src/test/compile-fail/regions-outlives-projection-trait-def.rs new file mode 100644 index 0000000000000..04682a7729735 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-projection-trait-def.rs @@ -0,0 +1,31 @@ +// Copyright 2014 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. + +// Test that `>::Type: 'b`, where `trait Foo<'a> { Type: +// 'a; }`, does not require that `F: 'b`. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait SomeTrait<'a> { + type Type: 'a; +} + +impl<'a: 'c, 'c, T> SomeTrait<'a> for &'c T where T: SomeTrait<'a> { + type Type = >::Type; + // ~~~~~~~~~~~~~~~~~~~~~~~~~~ + // | + // Note that this type must outlive 'a, due to the trait + // definition. If we fall back to OutlivesProjectionComponents + // here, then we would require that `T:'a`, which is too strong. +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/regions-outlives-scalar.rs b/src/test/compile-fail/regions-outlives-scalar.rs new file mode 100644 index 0000000000000..94f7a350cf787 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-scalar.rs @@ -0,0 +1,23 @@ +// Copyright 2014 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. + +// Test that scalar values outlive all regions. +// Rule OutlivesScalar from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct Foo<'a> { + x: &'a i32, + y: &'static i32 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/traits-issue-23003-overflow.rs b/src/test/compile-fail/traits-issue-23003-overflow.rs index ea41775f310d3..80d2884ee60aa 100644 --- a/src/test/compile-fail/traits-issue-23003-overflow.rs +++ b/src/test/compile-fail/traits-issue-23003-overflow.rs @@ -9,10 +9,11 @@ // except according to those terms. // A variant of traits-issue-23003 in which an infinite series of -// types are required. This currently creates an overflow. This test -// is included to ensure that some controlled failure, at least, -// results -- but it might be that we should adjust the rules somewhat -// to make this legal. -nmatsakis +// types are required. This test now just compiles fine, since the +// relevant rules that triggered the overflow were removed. + +#![feature(rustc_attrs)] +#![allow(dead_code)] use std::marker::PhantomData; @@ -32,7 +33,7 @@ impl Async for Complete { type Cancel = Receipt>>; } -fn foo(r: Receipt>) { } -//~^ ERROR overflow +fn foo(_: Receipt>) { } -fn main() { } +#[rustc_error] +fn main() { } //~ ERROR compilation successful From 91b3e9cac0125e35d65169fb7e06166a078296c7 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 09:27:27 -0400 Subject: [PATCH 11/38] Fallout in libs -- misc missing bounds uncovered by WF checks. --- src/libcore/iter.rs | 2 +- src/libcore/marker.rs | 2 +- src/libcore/num/mod.rs | 4 ++-- src/libcore/str/mod.rs | 3 ++- src/libgraphviz/lib.rs | 2 +- src/librand/distributions/range.rs | 3 ++- src/librustc/middle/astencode.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 2 +- src/librustc_data_structures/unify/mod.rs | 2 +- src/libserialize/serialize.rs | 2 +- src/libstd/sync/mutex.rs | 2 +- src/libstd/thread/local.rs | 2 +- src/libstd/thread/scoped_tls.rs | 2 +- 13 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 3382095b4560f..d19f3b6d27a75 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -2623,7 +2623,7 @@ impl Iterator for Unfold where F: FnMut(&mut St) -> Option { /// two `Step` objects. #[unstable(feature = "step_trait", reason = "likely to be replaced by finer-grained traits")] -pub trait Step: PartialOrd { +pub trait Step: PartialOrd+Sized { /// Steps `self` if possible. fn step(&self, by: &Self) -> Option; diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index c0956753c988c..32f367e12f034 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -56,7 +56,7 @@ pub trait Sized { /// Types that can be "unsized" to a dynamically sized type. #[unstable(feature = "unsize")] #[lang="unsize"] -pub trait Unsize { +pub trait Unsize { // Empty. } diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index ad891bf8fa623..7507e5782d6a2 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -19,7 +19,7 @@ use char::CharExt; use cmp::{Eq, PartialOrd}; use fmt; use intrinsics; -use marker::Copy; +use marker::{Copy, Sized}; use mem::size_of; use option::Option::{self, Some, None}; use result::Result::{self, Ok, Err}; @@ -1264,7 +1264,7 @@ pub enum FpCategory { #[doc(hidden)] #[unstable(feature = "core_float", reason = "stable interface is via `impl f{32,64}` in later crates")] -pub trait Float { +pub trait Float: Sized { /// Returns the NaN value. fn nan() -> Self; /// Returns the infinite value. diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 3c9338c2cd29c..d5bceb3ba623c 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -25,6 +25,7 @@ use default::Default; use fmt; use iter::ExactSizeIterator; use iter::{Map, Iterator, DoubleEndedIterator}; +use marker::Sized; use mem; use ops::{Fn, FnMut, FnOnce}; use option::Option::{self, None, Some}; @@ -37,7 +38,7 @@ pub mod pattern; /// A trait to abstract the idea of creating a new instance of a type from a /// string. #[stable(feature = "rust1", since = "1.0.0")] -pub trait FromStr { +pub trait FromStr: Sized { /// The associated error which can be returned from parsing. #[stable(feature = "rust1", since = "1.0.0")] type Err; diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index f6f3438f46720..a0b571b65ab5c 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -561,7 +561,7 @@ pub type Edges<'a,E> = Cow<'a,[E]>; /// `Cow<[T]>` to leave implementers the freedom to create /// entirely new vectors or to pass back slices into internally owned /// vectors. -pub trait GraphWalk<'a, N, E> { +pub trait GraphWalk<'a, N: Clone, E: Clone> { /// Returns all the nodes in this graph. fn nodes(&'a self) -> Nodes<'a, N>; /// Returns all of the edges in this graph. diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index e196708368ad3..26f92ee3b1cf0 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -12,6 +12,7 @@ // this is surprisingly complicated to be both generic & correct +use core::marker::Sized; use Rng; use distributions::{Sample, IndependentSample}; @@ -57,7 +58,7 @@ impl IndependentSample for Range { /// uniformly between two values. This should not be used directly, /// and is only to facilitate `Range`. #[doc(hidden)] -pub trait SampleRange { +pub trait SampleRange: Sized { /// Construct the `Range` object that `sample_range` /// requires. This should not ever be called directly, only via /// `Range::new`, which will check that `low < high`, so this diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 5c3b0a1c2d246..c064b31173f98 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1061,7 +1061,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, } } -trait doc_decoder_helpers { +trait doc_decoder_helpers: Sized { fn as_int(&self) -> isize; fn opt_child(&self, tag: c::astencode_tag) -> Option; } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 3755b4c57c3ec..a97fe84e6acef 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -239,7 +239,7 @@ impl OverloadedCallType { // supplies types from the tree. After type checking is complete, you // can just use the tcx as the typer. -pub struct ExprUseVisitor<'d,'t,'a: 't, 'tcx:'a> { +pub struct ExprUseVisitor<'d, 't, 'a: 't, 'tcx:'a+'d> { typer: &'t infer::InferCtxt<'a, 'tcx>, mc: mc::MemCategorizationContext<'t, 'a, 'tcx>, delegate: &'d mut (Delegate<'tcx>+'d), diff --git a/src/librustc_data_structures/unify/mod.rs b/src/librustc_data_structures/unify/mod.rs index 7582b7ff61d88..4d79b1a64c191 100644 --- a/src/librustc_data_structures/unify/mod.rs +++ b/src/librustc_data_structures/unify/mod.rs @@ -272,7 +272,7 @@ impl<'tcx,K> UnificationTable impl<'tcx,K,V> UnificationTable where K: UnifyKey>, - V: Clone+PartialEq, + V: Clone+PartialEq+Debug, { pub fn unify_var_var(&mut self, a_id: K, diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs index af1387346106a..5e96ec6ab0df3 100644 --- a/src/libserialize/serialize.rs +++ b/src/libserialize/serialize.rs @@ -194,7 +194,7 @@ pub trait Encodable { fn encode(&self, s: &mut S) -> Result<(), S::Error>; } -pub trait Decodable { +pub trait Decodable: Sized { fn decode(d: &mut D) -> Result; } diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index 4b62434d06894..773bd7f560694 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -369,7 +369,7 @@ mod tests { use sync::{Arc, Mutex, StaticMutex, Condvar}; use thread; - struct Packet(Arc<(Mutex, Condvar)>); + struct Packet(Arc<(Mutex, Condvar)>); unsafe impl Send for Packet {} unsafe impl Sync for Packet {} diff --git a/src/libstd/thread/local.rs b/src/libstd/thread/local.rs index 3bf170b5fe218..a228cbfd85ba3 100644 --- a/src/libstd/thread/local.rs +++ b/src/libstd/thread/local.rs @@ -60,7 +60,7 @@ pub use self::imp::Key as __KeyInner; /// }); /// ``` #[stable(feature = "rust1", since = "1.0.0")] -pub struct LocalKey { +pub struct LocalKey { // The key itself may be tagged with #[thread_local], and this `Key` is // stored as a `static`, and it's not valid for a static to reference the // address of another thread_local static. For this reason we kinda wonkily diff --git a/src/libstd/thread/scoped_tls.rs b/src/libstd/thread/scoped_tls.rs index 303ab0f9f0134..810e3bb62f705 100644 --- a/src/libstd/thread/scoped_tls.rs +++ b/src/libstd/thread/scoped_tls.rs @@ -55,7 +55,7 @@ pub use self::imp::KeyInner as __KeyInner; #[unstable(feature = "scoped_tls", reason = "scoped TLS has yet to have wide enough use to fully consider \ stabilizing its interface")] -pub struct ScopedKey { inner: fn() -> &'static imp::KeyInner } +pub struct ScopedKey { inner: fn() -> &'static imp::KeyInner } /// Declare a new scoped thread local storage key. /// From d15d743fa87efa9d496447eac1ebd402c5dab0b3 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 10:48:13 -0400 Subject: [PATCH 12/38] Add FIXME for apparent stage0 regression --- src/librustc/middle/expr_use_visitor.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index a97fe84e6acef..4e09f9a86329a 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -273,7 +273,9 @@ enum PassArgs { impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { pub fn new(delegate: &'d mut Delegate<'tcx>, typer: &'t infer::InferCtxt<'a, 'tcx>) - -> ExprUseVisitor<'d,'t,'a, 'tcx> { + -> ExprUseVisitor<'d,'t,'a,'tcx> + where 'tcx: 't // FIXME(#27583) workaround apparent stage0 bug + { ExprUseVisitor { typer: typer, mc: mc::MemCategorizationContext::new(typer), From 09bf2fef2249602bdd3d4d58ae0dcb9e7968cacc Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 10:58:00 -0400 Subject: [PATCH 13/38] Fallout in tests -- we now report an error if you even reference a type `&Foo` where `Foo` is a trait that is not object-safe --- src/test/auxiliary/issue13507.rs | 1 - .../cast-to-unsized-trait-object-suggestion.rs | 8 ++++---- src/test/compile-fail/infinite-instantiation.rs | 2 +- src/test/compile-fail/issue-18959.rs | 3 ++- src/test/compile-fail/issue-19380.rs | 2 +- src/test/compile-fail/issue-19538.rs | 3 ++- src/test/compile-fail/object-safety-generics.rs | 5 +++-- src/test/compile-fail/object-safety-issue-22040.rs | 6 +++--- src/test/compile-fail/object-safety-mentions-Self.rs | 10 ++++++---- src/test/compile-fail/object-safety-no-static.rs | 5 +++-- src/test/compile-fail/object-safety-sized-2.rs | 5 +++-- src/test/compile-fail/object-safety-sized.rs | 5 +++-- .../object-safety-supertrait-mentions-Self.rs | 2 +- src/test/run-pass/issue-21058.rs | 4 ++-- 14 files changed, 34 insertions(+), 27 deletions(-) diff --git a/src/test/auxiliary/issue13507.rs b/src/test/auxiliary/issue13507.rs index 7d82e79f94911..78d0394a6e5ad 100644 --- a/src/test/auxiliary/issue13507.rs +++ b/src/test/auxiliary/issue13507.rs @@ -72,7 +72,6 @@ pub mod testtypes { // Tests TyTrait pub trait FooTrait { fn foo_method(&self) -> usize; - fn foo_static_method() -> usize; } // Tests TyStruct diff --git a/src/test/compile-fail/cast-to-unsized-trait-object-suggestion.rs b/src/test/compile-fail/cast-to-unsized-trait-object-suggestion.rs index 4e6ae96e3fc75..d18746cdf0ba5 100644 --- a/src/test/compile-fail/cast-to-unsized-trait-object-suggestion.rs +++ b/src/test/compile-fail/cast-to-unsized-trait-object-suggestion.rs @@ -9,12 +9,12 @@ // except according to those terms. fn main() { - &1 as Copy; + &1 as Send; //~^ ERROR cast to unsized type //~| HELP try casting to a reference instead: - //~| SUGGESTION &1 as &Copy; - Box::new(1) as Copy; + //~| SUGGESTION &1 as &Send; + Box::new(1) as Send; //~^ ERROR cast to unsized type //~| HELP try casting to a `Box` instead: - //~| SUGGESTION Box::new(1) as Box; + //~| SUGGESTION Box::new(1) as Box; } diff --git a/src/test/compile-fail/infinite-instantiation.rs b/src/test/compile-fail/infinite-instantiation.rs index 559e0e9a292a6..9b02bf4cb85a8 100644 --- a/src/test/compile-fail/infinite-instantiation.rs +++ b/src/test/compile-fail/infinite-instantiation.rs @@ -15,7 +15,7 @@ // so for now just live with it. // This test case was originally for issue #2258. -trait ToOpt { +trait ToOpt: Sized { fn to_option(&self) -> Option; } diff --git a/src/test/compile-fail/issue-18959.rs b/src/test/compile-fail/issue-18959.rs index ebda2481803a7..95176da9020d5 100644 --- a/src/test/compile-fail/issue-18959.rs +++ b/src/test/compile-fail/issue-18959.rs @@ -21,10 +21,11 @@ impl Foo for Thing { fn foo(b: &Bar) { b.foo(&0) //~^ ERROR the trait `Foo` is not implemented for the type `Bar` + //~| ERROR E0038 } fn main() { let mut thing = Thing; - let test: &Bar = &mut thing; //~ ERROR cannot convert to a trait object + let test: &Bar = &mut thing; //~ ERROR E0038 foo(test); } diff --git a/src/test/compile-fail/issue-19380.rs b/src/test/compile-fail/issue-19380.rs index dbc0e410cf95c..e24e6bbeb7bba 100644 --- a/src/test/compile-fail/issue-19380.rs +++ b/src/test/compile-fail/issue-19380.rs @@ -18,11 +18,11 @@ impl Qiz for Foo { } struct Bar { +//~^ ERROR E0038 foos: &'static [&'static (Qiz + 'static)] } const FOO : Foo = Foo; const BAR : Bar = Bar { foos: &[&FOO]}; -//~^ ERROR: cannot convert to a trait object because trait `Qiz` is not object-safe [E0038] fn main() { } diff --git a/src/test/compile-fail/issue-19538.rs b/src/test/compile-fail/issue-19538.rs index b9c90755b2c73..a619050058262 100644 --- a/src/test/compile-fail/issue-19538.rs +++ b/src/test/compile-fail/issue-19538.rs @@ -25,5 +25,6 @@ impl Bar for Thing { } fn main() { let mut thing = Thing; let test: &mut Bar = &mut thing; - //~^ ERROR cannot convert to a trait object because trait `Bar` is not object-safe + //~^ ERROR E0038 + //~| ERROR E0038 } diff --git a/src/test/compile-fail/object-safety-generics.rs b/src/test/compile-fail/object-safety-generics.rs index fd20accfa1e6b..63e5718537cf9 100644 --- a/src/test/compile-fail/object-safety-generics.rs +++ b/src/test/compile-fail/object-safety-generics.rs @@ -23,14 +23,15 @@ trait Quux { fn make_bar(t: &T) -> &Bar { t - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE method `bar` has generic type parameters } fn make_bar_explicit(t: &T) -> &Bar { t as &Bar - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE method `bar` has generic type parameters + //~| ERROR E0038 } fn make_quux(t: &T) -> &Quux { diff --git a/src/test/compile-fail/object-safety-issue-22040.rs b/src/test/compile-fail/object-safety-issue-22040.rs index edf32131b6875..f49ed42fe44d0 100644 --- a/src/test/compile-fail/object-safety-issue-22040.rs +++ b/src/test/compile-fail/object-safety-issue-22040.rs @@ -18,7 +18,7 @@ trait Expr: Debug + PartialEq { //#[derive(PartialEq)] #[derive(Debug)] -struct SExpr<'x> { +struct SExpr<'x> { //~ ERROR E0038 elements: Vec>, } @@ -43,8 +43,8 @@ impl <'x> Expr for SExpr<'x> { } fn main() { - let a: Box = Box::new(SExpr::new()); //~ ERROR trait `Expr` is not object-safe - let b: Box = Box::new(SExpr::new()); //~ ERROR trait `Expr` is not object-safe + let a: Box = Box::new(SExpr::new()); + let b: Box = Box::new(SExpr::new()); assert_eq!(a , b); } diff --git a/src/test/compile-fail/object-safety-mentions-Self.rs b/src/test/compile-fail/object-safety-mentions-Self.rs index b546774ccbd8c..55b780906355a 100644 --- a/src/test/compile-fail/object-safety-mentions-Self.rs +++ b/src/test/compile-fail/object-safety-mentions-Self.rs @@ -26,26 +26,28 @@ trait Quux { fn make_bar(t: &T) -> &Bar { t - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE method `bar` references the `Self` type in its arguments or return type } fn make_bar_explicit(t: &T) -> &Bar { t as &Bar - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE method `bar` references the `Self` type in its arguments or return type + //~| ERROR E0038 } fn make_baz(t: &T) -> &Baz { t - //~^ ERROR `Baz` is not object-safe + //~^ ERROR E0038 //~| NOTE method `bar` references the `Self` type in its arguments or return type } fn make_baz_explicit(t: &T) -> &Baz { t as &Baz - //~^ ERROR `Baz` is not object-safe + //~^ ERROR E0038 //~| NOTE method `bar` references the `Self` type in its arguments or return type + //~| ERROR E0038 } fn make_quux(t: &T) -> &Quux { diff --git a/src/test/compile-fail/object-safety-no-static.rs b/src/test/compile-fail/object-safety-no-static.rs index 6a010d49692d2..2dc7983d1b561 100644 --- a/src/test/compile-fail/object-safety-no-static.rs +++ b/src/test/compile-fail/object-safety-no-static.rs @@ -17,14 +17,15 @@ trait Foo { fn foo_implicit(b: Box) -> Box { b - //~^ ERROR cannot convert to a trait object + //~^ ERROR E0038 //~| NOTE method `foo` has no receiver } fn foo_explicit(b: Box) -> Box { b as Box - //~^ ERROR cannot convert to a trait object + //~^ ERROR E0038 //~| NOTE method `foo` has no receiver + //~| ERROR E0038 } fn main() { diff --git a/src/test/compile-fail/object-safety-sized-2.rs b/src/test/compile-fail/object-safety-sized-2.rs index 3a02461bbb223..401602bd681a3 100644 --- a/src/test/compile-fail/object-safety-sized-2.rs +++ b/src/test/compile-fail/object-safety-sized-2.rs @@ -19,14 +19,15 @@ trait Bar fn make_bar(t: &T) -> &Bar { t - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE the trait cannot require that `Self : Sized` } fn make_bar_explicit(t: &T) -> &Bar { t as &Bar - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE the trait cannot require that `Self : Sized` + //~| ERROR E0038 } fn main() { diff --git a/src/test/compile-fail/object-safety-sized.rs b/src/test/compile-fail/object-safety-sized.rs index bc214f6f3d962..29b4e4db65c36 100644 --- a/src/test/compile-fail/object-safety-sized.rs +++ b/src/test/compile-fail/object-safety-sized.rs @@ -17,14 +17,15 @@ trait Bar : Sized { fn make_bar(t: &T) -> &Bar { t - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE the trait cannot require that `Self : Sized` } fn make_bar_explicit(t: &T) -> &Bar { t as &Bar - //~^ ERROR `Bar` is not object-safe + //~^ ERROR E0038 //~| NOTE the trait cannot require that `Self : Sized` + //~| ERROR E0038 } fn main() { diff --git a/src/test/compile-fail/object-safety-supertrait-mentions-Self.rs b/src/test/compile-fail/object-safety-supertrait-mentions-Self.rs index d3f9dc73020fb..ba82635a4016e 100644 --- a/src/test/compile-fail/object-safety-supertrait-mentions-Self.rs +++ b/src/test/compile-fail/object-safety-supertrait-mentions-Self.rs @@ -24,7 +24,7 @@ fn make_bar>(t: &T) -> &Bar { fn make_baz(t: &T) -> &Baz { t - //~^ ERROR `Baz` is not object-safe + //~^ ERROR E0038 //~| NOTE the trait cannot use `Self` as a type parameter in the supertrait listing } diff --git a/src/test/run-pass/issue-21058.rs b/src/test/run-pass/issue-21058.rs index 5fe3434e499e1..0ca936878148b 100644 --- a/src/test/run-pass/issue-21058.rs +++ b/src/test/run-pass/issue-21058.rs @@ -21,10 +21,10 @@ fn main() { // str std::intrinsics::type_name::(), // Trait - std::intrinsics::type_name::(), + std::intrinsics::type_name::(), // Newtype std::intrinsics::type_name::(), // DST std::intrinsics::type_name::() - )}, ("[u8]", "str", "core::marker::Copy + 'static", "NT", "DST")); + )}, ("[u8]", "str", "core::marker::Send + 'static", "NT", "DST")); } From 92d16d961d01dfa5f16218ddc630df31b099d2aa Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 10:59:28 -0400 Subject: [PATCH 14/38] Fallout in tests -- break the object safety part into a separate file because error will be in future reported by wfcheck, which runs in a later stage than coherence --- ...erence-impl-trait-for-trait-object-safe.rs | 19 +++++++++++++++++++ .../coherence-impl-trait-for-trait.rs | 5 ----- 2 files changed, 19 insertions(+), 5 deletions(-) create mode 100644 src/test/compile-fail/coherence-impl-trait-for-trait-object-safe.rs diff --git a/src/test/compile-fail/coherence-impl-trait-for-trait-object-safe.rs b/src/test/compile-fail/coherence-impl-trait-for-trait-object-safe.rs new file mode 100644 index 0000000000000..ce6baeb204c93 --- /dev/null +++ b/src/test/compile-fail/coherence-impl-trait-for-trait-object-safe.rs @@ -0,0 +1,19 @@ +// Copyright 2015 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. + +// Test that we give suitable error messages when the user attempts to +// impl a trait `Trait` for its own object type. + +// If the trait is not object-safe, we give a more tailored message +// because we're such schnuckels: +trait NotObjectSafe { fn eq(&self, other: Self); } +impl NotObjectSafe for NotObjectSafe { } //~ ERROR E0372 + +fn main() { } diff --git a/src/test/compile-fail/coherence-impl-trait-for-trait.rs b/src/test/compile-fail/coherence-impl-trait-for-trait.rs index 332965cc94014..cd75b0e34f24b 100644 --- a/src/test/compile-fail/coherence-impl-trait-for-trait.rs +++ b/src/test/compile-fail/coherence-impl-trait-for-trait.rs @@ -24,9 +24,4 @@ impl Baz for Baz { } //~ ERROR E0371 trait Other { } impl Other for Baz { } // OK, Other not a supertrait of Baz -// If the trait is not object-safe, we give a more tailored message -// because we're such schnuckels: -trait NotObjectSafe { fn eq(&self, other: Self); } -impl NotObjectSafe for NotObjectSafe { } //~ ERROR E0372 - fn main() { } From 532fcb250fb888431b0049f68dc619a1f77e70a7 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 13:32:14 -0400 Subject: [PATCH 15/38] Fallout in tests -- break this test into three tests, since we later saw staging differences in terms of when errors were reported --- ...rait-bounds-on-structs-and-enums-in-fns.rs | 30 ++++++++++++++++ ...it-bounds-on-structs-and-enums-in-impls.rs | 35 +++++++++++++++++++ .../trait-bounds-on-structs-and-enums.rs | 17 --------- 3 files changed, 65 insertions(+), 17 deletions(-) create mode 100644 src/test/compile-fail/trait-bounds-on-structs-and-enums-in-fns.rs create mode 100644 src/test/compile-fail/trait-bounds-on-structs-and-enums-in-impls.rs diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums-in-fns.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums-in-fns.rs new file mode 100644 index 0000000000000..dbfda61f5525a --- /dev/null +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums-in-fns.rs @@ -0,0 +1,30 @@ +// Copyright 2014 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 { + x: T, +} + +enum Bar { + ABar(isize), + BBar(T), + CBar(usize), +} + +fn explode(x: Foo) {} +//~^ ERROR not implemented + +fn kaboom(y: Bar) {} +//~^ ERROR not implemented + +fn main() { +} diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums-in-impls.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums-in-impls.rs new file mode 100644 index 0000000000000..c647dd38ee38a --- /dev/null +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums-in-impls.rs @@ -0,0 +1,35 @@ +// Copyright 2014 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 { + x: T, +} + +enum Bar { + ABar(isize), + BBar(T), + CBar(usize), +} + +trait PolyTrait +{ + fn whatever(&self, t: T) {} +} + +struct Struct; + +impl PolyTrait> for Struct { +//~^ ERROR not implemented +} + +fn main() { +} diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs index 988961e7fa14a..e1b005b0c8533 100644 --- a/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs +++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs @@ -20,12 +20,6 @@ enum Bar { CBar(usize), } -fn explode(x: Foo) {} -//~^ ERROR not implemented - -fn kaboom(y: Bar) {} -//~^ ERROR not implemented - impl Foo { //~^ ERROR the trait `Trait` is not implemented fn uhoh() {} @@ -55,16 +49,5 @@ enum Enum { DictionaryLike { field: Bar }, //~ ERROR not implemented } -trait PolyTrait -{ - fn whatever(&self, t: T) {} -} - -struct Struct; - -impl PolyTrait> for Struct { -//~^ ERROR not implemented -} - fn main() { } From f4aaedb51e47022cdd6c8857976e209e9d135e3f Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 13:32:49 -0400 Subject: [PATCH 16/38] Fallout in tests -- break test into a run-pass and compile-fail component --- ...related-trait-in-method-without-default.rs | 39 +++++++++++++++++++ ...ted-types-projection-to-unrelated-trait.rs | 3 +- 2 files changed, 41 insertions(+), 1 deletion(-) create mode 100644 src/test/compile-fail/associated-types-projection-to-unrelated-trait-in-method-without-default.rs diff --git a/src/test/compile-fail/associated-types-projection-to-unrelated-trait-in-method-without-default.rs b/src/test/compile-fail/associated-types-projection-to-unrelated-trait-in-method-without-default.rs new file mode 100644 index 0000000000000..3f72391ff90c7 --- /dev/null +++ b/src/test/compile-fail/associated-types-projection-to-unrelated-trait-in-method-without-default.rs @@ -0,0 +1,39 @@ +// Copyright 2015 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. + +// Check that we get an error when you use `::Value` in +// the trait definition even if there is no default method. + +trait Get { + type Value; +} + +trait Other { + fn okay(&self, foo: U, bar: ::Value); + //~^ ERROR E0277 +} + +impl Get for () { + type Value = f32; +} + +impl Get for f64 { + type Value = u32; +} + +impl Other for () { + fn okay(&self, _foo: U, _bar: ::Value) { } +} + +impl Other for f64 { + fn okay(&self, _foo: U, _bar: ::Value) { } +} + +fn main() { } diff --git a/src/test/run-pass/associated-types-projection-to-unrelated-trait.rs b/src/test/run-pass/associated-types-projection-to-unrelated-trait.rs index 6070cff9a2952..8059db5204ee6 100644 --- a/src/test/run-pass/associated-types-projection-to-unrelated-trait.rs +++ b/src/test/run-pass/associated-types-projection-to-unrelated-trait.rs @@ -21,7 +21,8 @@ trait Get { } trait Other { - fn okay(&self, foo: U, bar: ::Value); + fn okay(&self, foo: U, bar: ::Value) + where Self: Get; } impl Get for () { From dee8b54b71e6cb8145fc00b64f35c736a70c6bcf Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 13:23:11 -0400 Subject: [PATCH 17/38] Fallout in tests --- misc error message changes, WF fixes --- ...closure-bounds-static-cant-capture-borrowed.rs | 4 +++- src/test/compile-fail/issue-18389.rs | 5 +---- src/test/compile-fail/issue-20005.rs | 1 + src/test/compile-fail/issue-23041.rs | 3 +-- src/test/compile-fail/issue-24013.rs | 2 +- src/test/compile-fail/issue-3907-2.rs | 3 ++- .../compile-fail/kindck-inherited-copy-bound.rs | 4 +++- ...assoc-type-in-supertrait-outlives-container.rs | 2 +- .../regions-close-object-into-object-1.rs | 2 +- .../regions-close-object-into-object-2.rs | 2 +- .../regions-close-object-into-object-3.rs | 2 +- .../regions-close-object-into-object-4.rs | 2 +- .../regions-close-object-into-object-5.rs | 11 +++++++++-- src/test/compile-fail/regions-enum-not-wf.rs | 6 ++++-- .../regions-outlives-projection-container-wc.rs | 3 ++- .../regions-outlives-projection-container.rs | 2 +- src/test/compile-fail/regions-struct-not-wf.rs | 9 ++++++--- src/test/compile-fail/trait-object-safety.rs | 3 ++- src/test/compile-fail/trait-test-2.rs | 6 ++++-- src/test/compile-fail/traits-negative-impls.rs | 15 +++++++++++++-- ...e-parameter-defaults-referencing-Self-ppaux.rs | 3 ++- src/test/compile-fail/variance-regions-direct.rs | 4 ++-- src/test/run-pass/issue-14254.rs | 2 +- src/test/run-pass/issue-5708.rs | 2 +- 24 files changed, 64 insertions(+), 34 deletions(-) diff --git a/src/test/compile-fail/closure-bounds-static-cant-capture-borrowed.rs b/src/test/compile-fail/closure-bounds-static-cant-capture-borrowed.rs index d27529bad4305..16ed73e9095e4 100644 --- a/src/test/compile-fail/closure-bounds-static-cant-capture-borrowed.rs +++ b/src/test/compile-fail/closure-bounds-static-cant-capture-borrowed.rs @@ -12,7 +12,9 @@ fn bar(blk: F) where F: FnOnce() + 'static { } fn foo(x: &()) { - bar(|| { //~ ERROR cannot infer an appropriate lifetime + bar(|| { + //~^ ERROR cannot infer + //~| ERROR does not fulfill let _ = x; }) } diff --git a/src/test/compile-fail/issue-18389.rs b/src/test/compile-fail/issue-18389.rs index 41be78dd7b96e..7d95082079f9f 100644 --- a/src/test/compile-fail/issue-18389.rs +++ b/src/test/compile-fail/issue-18389.rs @@ -11,10 +11,7 @@ use std::any::Any; use std::any::TypeId; -pub trait Pt {} -pub trait Rt {} - -trait Private { +trait Private { fn call(&self, p: P, r: R); } pub trait Public: Private< //~ ERROR private trait in exported type parameter bound diff --git a/src/test/compile-fail/issue-20005.rs b/src/test/compile-fail/issue-20005.rs index d91479a2e4e89..041289c2ccdbd 100644 --- a/src/test/compile-fail/issue-20005.rs +++ b/src/test/compile-fail/issue-20005.rs @@ -19,6 +19,7 @@ trait To { self //~ error: the trait `core::marker::Sized` is not implemented ) -> >::Result where Dst: From { From::from( //~ error: the trait `core::marker::Sized` is not implemented + //~^ ERROR E0277 self ) } diff --git a/src/test/compile-fail/issue-23041.rs b/src/test/compile-fail/issue-23041.rs index 68895759c5c2a..c08cdd72b3825 100644 --- a/src/test/compile-fail/issue-23041.rs +++ b/src/test/compile-fail/issue-23041.rs @@ -13,6 +13,5 @@ fn main() { fn bar(x:i32) ->i32 { 3*x }; let b:Box = Box::new(bar as fn(_)->_); - b.downcast_ref::_>(); - //~^ ERROR cannot determine a type for this expression: unconstrained type + b.downcast_ref::_>(); //~ ERROR E0101 } diff --git a/src/test/compile-fail/issue-24013.rs b/src/test/compile-fail/issue-24013.rs index 0adad8a88cbc9..df857a2e6eb1f 100644 --- a/src/test/compile-fail/issue-24013.rs +++ b/src/test/compile-fail/issue-24013.rs @@ -13,5 +13,5 @@ fn main() { let a = 1; let b = 2; unsafe {swap::<&mut _>(transmute(&a), transmute(&b))}; - //~^ ERROR cannot determine a type for this expression: unconstrained type + //~^ ERROR unable to infer enough type information about `_` } diff --git a/src/test/compile-fail/issue-3907-2.rs b/src/test/compile-fail/issue-3907-2.rs index 9a166a6752b7e..ee8bc7d6e2901 100644 --- a/src/test/compile-fail/issue-3907-2.rs +++ b/src/test/compile-fail/issue-3907-2.rs @@ -17,6 +17,7 @@ struct S { name: isize } -fn bar(_x: Foo) {} //~ ERROR the trait `core::marker::Sized` is not implemented +fn bar(_x: Foo) {} +//~^ ERROR E0277 fn main() {} diff --git a/src/test/compile-fail/kindck-inherited-copy-bound.rs b/src/test/compile-fail/kindck-inherited-copy-bound.rs index 066590252a54a..0731fbaf01c43 100644 --- a/src/test/compile-fail/kindck-inherited-copy-bound.rs +++ b/src/test/compile-fail/kindck-inherited-copy-bound.rs @@ -31,7 +31,9 @@ fn a() { fn b() { let x: Box<_> = box 3; let y = &x; - let z = &x as &Foo; //~ ERROR E0038 + let z = &x as &Foo; + //~^ ERROR E0038 + //~| ERROR E0038 } fn main() { } diff --git a/src/test/compile-fail/regions-assoc-type-in-supertrait-outlives-container.rs b/src/test/compile-fail/regions-assoc-type-in-supertrait-outlives-container.rs index 9a13541bd0b17..f2ff877cd8236 100644 --- a/src/test/compile-fail/regions-assoc-type-in-supertrait-outlives-container.rs +++ b/src/test/compile-fail/regions-assoc-type-in-supertrait-outlives-container.rs @@ -47,7 +47,7 @@ fn with_assoc<'a,'b>() { // outlive 'a. In this case, that means TheType<'b>::TheAssocType, // which is &'b (), must outlive 'a. - let _: &'a WithAssoc> = loop { }; //~ ERROR cannot infer + let _: &'a WithAssoc> = loop { }; //~ ERROR reference has a longer lifetime } fn main() { diff --git a/src/test/compile-fail/regions-close-object-into-object-1.rs b/src/test/compile-fail/regions-close-object-into-object-1.rs index 5472e09ba4be4..5d9818d624b7e 100644 --- a/src/test/compile-fail/regions-close-object-into-object-1.rs +++ b/src/test/compile-fail/regions-close-object-into-object-1.rs @@ -12,7 +12,7 @@ #![allow(warnings)] trait A { } -struct B<'a, T>(&'a (A+'a)); +struct B<'a, T:'a>(&'a (A+'a)); trait X { } diff --git a/src/test/compile-fail/regions-close-object-into-object-2.rs b/src/test/compile-fail/regions-close-object-into-object-2.rs index 1ef000852d561..6cef995665517 100644 --- a/src/test/compile-fail/regions-close-object-into-object-2.rs +++ b/src/test/compile-fail/regions-close-object-into-object-2.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] trait A { } -struct B<'a, T>(&'a (A+'a)); +struct B<'a, T:'a>(&'a (A+'a)); trait X { } impl<'a, T> X for B<'a, T> {} diff --git a/src/test/compile-fail/regions-close-object-into-object-3.rs b/src/test/compile-fail/regions-close-object-into-object-3.rs index b7dc759b2717f..3004245b15a24 100644 --- a/src/test/compile-fail/regions-close-object-into-object-3.rs +++ b/src/test/compile-fail/regions-close-object-into-object-3.rs @@ -12,7 +12,7 @@ #![allow(warnings)] trait A { } -struct B<'a, T>(&'a (A+'a)); +struct B<'a, T:'a>(&'a (A+'a)); trait X { } impl<'a, T> X for B<'a, T> {} diff --git a/src/test/compile-fail/regions-close-object-into-object-4.rs b/src/test/compile-fail/regions-close-object-into-object-4.rs index 247578d253ea0..bc5b7b7cf7874 100644 --- a/src/test/compile-fail/regions-close-object-into-object-4.rs +++ b/src/test/compile-fail/regions-close-object-into-object-4.rs @@ -11,7 +11,7 @@ #![feature(box_syntax)] trait A { } -struct B<'a, T>(&'a (A+'a)); +struct B<'a, T:'a>(&'a (A+'a)); trait X { } impl<'a, T> X for B<'a, T> {} diff --git a/src/test/compile-fail/regions-close-object-into-object-5.rs b/src/test/compile-fail/regions-close-object-into-object-5.rs index 253132e5f07d0..ac269a4d896f2 100644 --- a/src/test/compile-fail/regions-close-object-into-object-5.rs +++ b/src/test/compile-fail/regions-close-object-into-object-5.rs @@ -16,15 +16,22 @@ trait A fn get(&self) -> T { panic!() } } -struct B<'a, T>(&'a (A+'a)); +struct B<'a, T:'a>(&'a (A+'a)); trait X { fn foo(&self) {} } impl<'a, T> X for B<'a, T> {} fn f<'a, T, U>(v: Box+'static>) -> Box { - box B(&*v) as Box //~ ERROR the parameter type `T` may not live long enough + // oh dear! + box B(&*v) as Box //~^ ERROR the parameter type `T` may not live long enough + //~| WARNING the parameter type `T` may not live long enough + //~| WARNING the parameter type `T` may not live long enough + //~| ERROR the parameter type `T` may not live long enough + //~| WARNING the parameter type `T` may not live long enough + //~| ERROR the parameter type `T` may not live long enough + //~| ERROR the parameter type `T` may not live long enough } fn main() {} diff --git a/src/test/compile-fail/regions-enum-not-wf.rs b/src/test/compile-fail/regions-enum-not-wf.rs index 0165dbdabf3c2..3be9981787221 100644 --- a/src/test/compile-fail/regions-enum-not-wf.rs +++ b/src/test/compile-fail/regions-enum-not-wf.rs @@ -25,11 +25,13 @@ enum RefOk<'a, T:'a> { RefOkVariant1(&'a T) } -enum RefIndirect<'a, T> { //~ ERROR the parameter type `T` may not live long enough +enum RefIndirect<'a, T> { + //~^ ERROR the parameter type `T` may not live long enough RefIndirectVariant1(isize, RefOk<'a,T>) } -enum RefDouble<'a, 'b, T> { //~ ERROR reference has a longer lifetime than the data +enum RefDouble<'a, 'b, T> { + //~^ ERROR reference has a longer lifetime than the data RefDoubleVariant1(&'a &'b T) } diff --git a/src/test/compile-fail/regions-outlives-projection-container-wc.rs b/src/test/compile-fail/regions-outlives-projection-container-wc.rs index 2ceaea98d2797..71606ba812fac 100644 --- a/src/test/compile-fail/regions-outlives-projection-container-wc.rs +++ b/src/test/compile-fail/regions-outlives-projection-container-wc.rs @@ -41,7 +41,8 @@ fn with_assoc<'a,'b>() { // outlive 'a. In this case, that means TheType<'b>::TheAssocType, // which is &'b (), must outlive 'a. - let _: &'a WithAssoc> = loop { }; //~ ERROR cannot infer + let _: &'a WithAssoc> = loop { }; + //~^ ERROR reference has a longer lifetime } fn main() { diff --git a/src/test/compile-fail/regions-outlives-projection-container.rs b/src/test/compile-fail/regions-outlives-projection-container.rs index 6f5ebf2d1cecf..957e56fe5109f 100644 --- a/src/test/compile-fail/regions-outlives-projection-container.rs +++ b/src/test/compile-fail/regions-outlives-projection-container.rs @@ -45,7 +45,7 @@ fn with_assoc<'a,'b>() { // outlive 'a. In this case, that means TheType<'b>::TheAssocType, // which is &'b (), must outlive 'a. - let _: &'a WithAssoc> = loop { }; //~ ERROR cannot infer + let _: &'a WithAssoc> = loop { }; //~ ERROR reference has a longer lifetime } fn with_assoc1<'a,'b>() where 'b : 'a { diff --git a/src/test/compile-fail/regions-struct-not-wf.rs b/src/test/compile-fail/regions-struct-not-wf.rs index c22812c3d86dc..17831266f7e13 100644 --- a/src/test/compile-fail/regions-struct-not-wf.rs +++ b/src/test/compile-fail/regions-struct-not-wf.rs @@ -12,7 +12,8 @@ #![allow(dead_code)] -struct Ref<'a, T> { //~ ERROR the parameter type `T` may not live long enough +struct Ref<'a, T> { + //~^ ERROR the parameter type `T` may not live long enough field: &'a T } @@ -20,11 +21,13 @@ struct RefOk<'a, T:'a> { field: &'a T } -struct RefIndirect<'a, T> { //~ ERROR the parameter type `T` may not live long enough +struct RefIndirect<'a, T> { + //~^ ERROR the parameter type `T` may not live long enough field: RefOk<'a, T> } -struct DoubleRef<'a, 'b, T> { //~ ERROR reference has a longer lifetime than the data it references +struct DoubleRef<'a, 'b, T> { + //~^ ERROR reference has a longer lifetime than the data it references field: &'a &'b T } diff --git a/src/test/compile-fail/trait-object-safety.rs b/src/test/compile-fail/trait-object-safety.rs index d45d13556e121..baf239f5956d6 100644 --- a/src/test/compile-fail/trait-object-safety.rs +++ b/src/test/compile-fail/trait-object-safety.rs @@ -22,5 +22,6 @@ impl Tr for St { } fn main() { - let _: &Tr = &St; //~ ERROR cannot convert to a trait object because trait `Tr` is not + let _: &Tr = &St; //~ ERROR E0038 + //~^ ERROR E0038 } diff --git a/src/test/compile-fail/trait-test-2.rs b/src/test/compile-fail/trait-test-2.rs index b09b10ffa0aad..b11cbde292969 100644 --- a/src/test/compile-fail/trait-test-2.rs +++ b/src/test/compile-fail/trait-test-2.rs @@ -17,6 +17,8 @@ impl bar for u32 { fn dup(&self) -> u32 { *self } fn blah(&self) {} } fn main() { 10.dup::(); //~ ERROR does not take type parameters 10.blah::(); //~ ERROR incorrect number of type parameters - (box 10 as Box).dup(); //~ ERROR cannot convert to a trait object - //~^ ERROR the trait `bar` is not implemented for the type `bar` + (box 10 as Box).dup(); + //~^ ERROR E0038 + //~| ERROR E0038 + //~| ERROR E0277 } diff --git a/src/test/compile-fail/traits-negative-impls.rs b/src/test/compile-fail/traits-negative-impls.rs index 8dc977a8e490b..c37f45dcf50bb 100644 --- a/src/test/compile-fail/traits-negative-impls.rs +++ b/src/test/compile-fail/traits-negative-impls.rs @@ -32,12 +32,23 @@ fn dummy() { Outer(TestType); //~^ ERROR the trait `core::marker::Send` is not implemented for the type `dummy::TestType` + //~| ERROR the trait `core::marker::Send` is not implemented for the type `dummy::TestType` +} + +fn dummy1b() { + struct TestType; + impl !Send for TestType {} is_send(TestType); - //~^ ERROR the trait `core::marker::Send` is not implemented for the type `dummy::TestType` + //~^ ERROR the trait `core::marker::Send` is not implemented for the type `dummy1b::TestType` +} + +fn dummy1c() { + struct TestType; + impl !Send for TestType {} is_send((8, TestType)); - //~^ ERROR the trait `core::marker::Send` is not implemented for the type `dummy::TestType` + //~^ ERROR the trait `core::marker::Send` is not implemented for the type `dummy1c::TestType` } fn dummy2() { diff --git a/src/test/compile-fail/type-parameter-defaults-referencing-Self-ppaux.rs b/src/test/compile-fail/type-parameter-defaults-referencing-Self-ppaux.rs index 8cc531625d179..09687724656fa 100644 --- a/src/test/compile-fail/type-parameter-defaults-referencing-Self-ppaux.rs +++ b/src/test/compile-fail/type-parameter-defaults-referencing-Self-ppaux.rs @@ -22,5 +22,6 @@ impl MyAdd for i32 { fn main() { let x: i32 = 5; let y = x as MyAdd; - //~^ ERROR as `MyAdd` + //~^ ERROR E0038 + //~| ERROR cast to unsized type: `i32` as `MyAdd` } diff --git a/src/test/compile-fail/variance-regions-direct.rs b/src/test/compile-fail/variance-regions-direct.rs index da4d6c75227fc..319b81bde36ed 100644 --- a/src/test/compile-fail/variance-regions-direct.rs +++ b/src/test/compile-fail/variance-regions-direct.rs @@ -42,7 +42,7 @@ struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]] // contravariant context: #[rustc_variance] -struct Test5<'a, 'b> { //~ ERROR regions=[[+, o];[];[]] +struct Test5<'a, 'b:'a> { //~ ERROR regions=[[+, o];[];[]] x: extern "Rust" fn(&'a mut &'b isize), } @@ -52,7 +52,7 @@ struct Test5<'a, 'b> { //~ ERROR regions=[[+, o];[];[]] // argument list occurs in an invariant context. #[rustc_variance] -struct Test6<'a, 'b> { //~ ERROR regions=[[-, o];[];[]] +struct Test6<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]] x: &'a mut extern "Rust" fn(&'b isize), } diff --git a/src/test/run-pass/issue-14254.rs b/src/test/run-pass/issue-14254.rs index ed96eee6ddffb..9049ae0548fa9 100644 --- a/src/test/run-pass/issue-14254.rs +++ b/src/test/run-pass/issue-14254.rs @@ -10,7 +10,7 @@ // pretty-expanded FIXME #23616 -trait Foo { +trait Foo: Sized { fn bar(&self); fn baz(&self) { } fn bah(_: Option) { } diff --git a/src/test/run-pass/issue-5708.rs b/src/test/run-pass/issue-5708.rs index dfb560db10067..6ab3395109915 100644 --- a/src/test/run-pass/issue-5708.rs +++ b/src/test/run-pass/issue-5708.rs @@ -52,7 +52,7 @@ pub trait MyTrait { fn dummy(&self, t: T) -> T { panic!() } } -pub struct MyContainer<'a, T> { +pub struct MyContainer<'a, T:'a> { foos: Vec<&'a (MyTrait+'a)> , } From 7ed39c6d9bddb6f11b4681574cc0375446eb594e Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 7 Aug 2015 13:47:54 -0400 Subject: [PATCH 18/38] Fallout in tests -- explain an interesting test failure having to do with dropck and the new outlives rules --- src/test/compile-fail/dropck-object-cycle.rs | 57 +++++++++++++++++++ .../regions-early-bound-trait-param.rs | 7 ++- 2 files changed, 62 insertions(+), 2 deletions(-) create mode 100644 src/test/compile-fail/dropck-object-cycle.rs diff --git a/src/test/compile-fail/dropck-object-cycle.rs b/src/test/compile-fail/dropck-object-cycle.rs new file mode 100644 index 0000000000000..5432cbf402a0c --- /dev/null +++ b/src/test/compile-fail/dropck-object-cycle.rs @@ -0,0 +1,57 @@ +// Copyright 2014 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. + +// This test used to be part of a run-pass test, but revised outlives +// rule means that it no longer compiles. + +#![allow(unused_variables)] + +trait Trait<'a> { + fn long(&'a self) -> isize; + fn short<'b>(&'b self) -> isize; +} + +fn object_invoke1<'d>(x: &'d Trait<'d>) -> (isize, isize) { loop { } } + +trait MakerTrait { + fn mk() -> Self; +} + +fn make_val() -> T { + MakerTrait::mk() +} + +impl<'t> MakerTrait for Box+'static> { + fn mk() -> Box+'static> { loop { } } +} + +pub fn main() { + let m : Box = make_val(); + assert_eq!(object_invoke1(&*m), (4,5)); + //~^ ERROR `*m` does not live long enough + + // the problem here is that the full type of `m` is + // + // Box+'static> + // + // Here `'m` must be exactly the lifetime of the variable `m`. + // This is because of two requirements: + // 1. First, the basic type rules require that the + // type of `m`'s value outlives the lifetime of `m`. This puts a lower + // bound `'m`. + // + // 2. Meanwhile, the signature of `object_invoke1` requires that + // we create a reference of type `&'d Trait<'d>` for some `'d`. + // `'d` cannot outlive `'m`, so that forces the lifetime to be `'m`. + // + // This then conflicts with the dropck rules, which require that + // the type of `m` *strictly outlives* `'m`. Hence we get an + // error. +} diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs index 33889b27a872b..72a214f4c9ad0 100644 --- a/src/test/run-pass/regions-early-bound-trait-param.rs +++ b/src/test/run-pass/regions-early-bound-trait-param.rs @@ -42,7 +42,7 @@ fn field_invoke1<'f, 'g>(x: &'g Struct1<'f>) -> (isize,isize) { (l,s) } -struct Struct2<'h, 'i> { +struct Struct2<'h, 'i:'h> { f: &'h (Trait<'i>+'h) } @@ -126,7 +126,10 @@ pub fn main() { assert_eq!(field_invoke2(&s2), 3); let m : Box = make_val(); - assert_eq!(object_invoke1(&*m), (4,5)); + // assert_eq!(object_invoke1(&*m), (4,5)); + // ~~~~~~~~~~~~~~~~~~~ + // this call yields a compilation error; see compile-fail/dropck-object-cycle.rs + // for details. assert_eq!(object_invoke2(&*m), 5); // The RefMakerTrait above is pretty strange (i.e. it is strange From ff39ee9a90aea76ceb6d28536cc173714ec8157a Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 09:01:13 -0400 Subject: [PATCH 19/38] wip 082a011e2bd5c8254e6c1b2fdc97a6fcb2927a7f rm binary --- .../wf-trait-associated-type-trait | Bin 493092 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100755 src/test/compile-fail/wf-trait-associated-type-trait diff --git a/src/test/compile-fail/wf-trait-associated-type-trait b/src/test/compile-fail/wf-trait-associated-type-trait deleted file mode 100755 index a11cbc2cb1913080342cbaa4137a24eccc6542e0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 493092 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 z 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 RG0jii7;YQutc|JH{|57u<+cC- From b7e849bf6a866aa588a480dd6229aa4ea09a3f22 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 09:05:50 -0400 Subject: [PATCH 20/38] infer/mod.rs: add doc comment to RFC1214 variant --- src/librustc/middle/infer/mod.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 61c166e11d280..578b39af88cb4 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -189,6 +189,9 @@ pub struct TypeTrace<'tcx> { /// See `error_reporting.rs` for more details #[derive(Clone, Debug)] pub enum SubregionOrigin<'tcx> { + // Marker to indicate a constraint that only arises due to new + // provisions from RFC 1214. This will result in a warning, not an + // error. RFC1214Subregion(Rc>), // Arose from a subtyping relation From 0582fed63fa7207c4694e4c83adbecc46c089a77 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 09:06:22 -0400 Subject: [PATCH 21/38] middle/outlives.rs: fix typo --- src/librustc/middle/outlives.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc/middle/outlives.rs b/src/librustc/middle/outlives.rs index fa2b78b330d8b..1dbe9290c1e34 100644 --- a/src/librustc/middle/outlives.rs +++ b/src/librustc/middle/outlives.rs @@ -141,7 +141,7 @@ fn compute_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, // rule, which requires that `Pi: 'a` for all `i`. if !data.has_escaping_regions() { - // best case: no escaping reions, so push the + // best case: no escaping regions, so push the // projection and skip the subtree (thus // generating no constraints for Pi). out.push(Component::Projection(*data)); From 9c3a8664b6c6ab0e5650166220f870c3a0c2b60b Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 09:08:11 -0400 Subject: [PATCH 22/38] middle/outlives.rs: s/temp/subcomponents/ --- src/librustc/middle/outlives.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/librustc/middle/outlives.rs b/src/librustc/middle/outlives.rs index 1dbe9290c1e34..ec7dc5520ae3a 100644 --- a/src/librustc/middle/outlives.rs +++ b/src/librustc/middle/outlives.rs @@ -122,8 +122,8 @@ fn compute_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, } ty::TyBareFn(..) | ty::TyTrait(..) => { subtys.skip_current_subtree(); - let temp = capture_components(infcx, ty); - out.push(Component::RFC1214(temp)); + let subcomponents = capture_components(infcx, ty); + out.push(Component::RFC1214(subcomponents)); } ty::TyParam(p) => { out.push(Component::Param(p)); @@ -148,8 +148,8 @@ fn compute_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, } else { // fallback case: continue walking through and // constrain Pi. - let temp = capture_components(infcx, ty); - out.push(Component::EscapingProjection(temp)); + let subcomponents = capture_components(infcx, ty); + out.push(Component::EscapingProjection(subcomponents)); } subtys.skip_current_subtree(); } From c9a49f93ac8e9cdbaa22b33c9e3b9a9adffd360c Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 09:25:36 -0400 Subject: [PATCH 23/38] regionck.rs: remove dead fn type_strictly_outlives --- src/librustc_typeck/check/regionck.rs | 41 --------------------------- 1 file changed, 41 deletions(-) diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 1fed29ec68e71..fe40ade136da5 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -1562,47 +1562,6 @@ fn components_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, } } -/// Checks that all data reachable via `ty` *strictly* outlives `scope`. -/// This is used by dropck. -/// -/// CAUTION: It is mostly but not entirely equivalent to `T:'parent` -/// where `'parent` is the parent of `scope`. The difference is subtle -/// and has to do with trait objects, primarily. In particular, if you -/// have `Foo<'y>+'z`, then we require that `'z:'parent` but not -/// `'y:'parent` (same with lifetimes appearing in fn arguments). This -/// is because there is no actual reference to the trait object that -/// outlives `scope`, so we don't need to require that the type could -/// be named outside `scope`. Because trait objects are always -/// considered "suspicious" by dropck, if we don't add this special -/// case, you wind up with some kind of annoying and odd limitations -/// that crop up -/// `src/test/compile-fail/regions-early-bound-trait-param.rs`. -/// Basically there we have `&'foo Trait<'foo>+'bar`, and thus forcing -/// `'foo` to outlive `'parent` also forces the borrow to outlive -/// `'parent`, which is longer than should be necessary. The existence -/// of this "the same but different" predicate is somewhat bothersome -/// and questionable. -pub fn type_strictly_outlives<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, - origin: infer::SubregionOrigin<'tcx>, - ty: Ty<'tcx>, - scope: CodeExtent) -{ - debug!("type_strictly_outlives(ty={:?}, scope={:?})", - ty, scope); - - let span = origin.span(); - - let parent_region = - match rcx.tcx().region_maps.opt_encl_scope(scope) { - Some(parent_scope) => ty::ReScope(parent_scope), - None => rcx.tcx().sess.span_bug( - span, &format!("no enclosing scope found for scope: {:?}", - scope)), - }; - - type_must_outlive(rcx, origin, ty, parent_region); -} - fn param_ty_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, origin: infer::SubregionOrigin<'tcx>, region: ty::Region, From fb1b6fca3638f0e3edf5a1aca8cb379d95cf2ab8 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 09:54:06 -0400 Subject: [PATCH 24/38] regionck.rs: correct misuse of ty.regions() rather than regions() and add a test that was (incorrectly) failing to compile with existing code --- src/librustc_typeck/check/regionck.rs | 2 +- .../regions-outlives-projection-hrtype.rs | 36 +++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 src/test/compile-fail/regions-outlives-projection-hrtype.rs diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index fe40ade136da5..1d575128663dc 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -1785,7 +1785,7 @@ fn recursive_type_bound<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, let mut regions = ty.regions(); regions.retain(|r| !r.is_bound()); // ignore late-bound regions - bounds.push(VerifyBound::AllRegions(ty.regions())); + bounds.push(VerifyBound::AllRegions(regions)); // remove bounds that must hold, since they are not interesting bounds.retain(|b| !b.must_hold()); diff --git a/src/test/compile-fail/regions-outlives-projection-hrtype.rs b/src/test/compile-fail/regions-outlives-projection-hrtype.rs new file mode 100644 index 0000000000000..2d271b7be73e0 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-projection-hrtype.rs @@ -0,0 +1,36 @@ +// Copyright 2015 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. + +// Test for the outlives relation when applied to a projection on a +// type with bound regions. In this case, we are checking that +// ` fn(&'r T) as TheTrait>::TheType: 'a` If we're not +// careful, we could wind up with a constraint that `'r:'a`, but since +// `'r` is bound, that leads to badness. This test checks that +// everything works. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait TheTrait { + type TheType; +} + +fn wf() { } + +type FnType = for<'r> fn(&'r T); + +fn foo<'a,'b,T>() + where FnType: TheTrait +{ + wf::< as TheTrait>::TheType >(); +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful From 9c5cfea43da9b4e0372f240e01f58c977bd44d92 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 10:48:34 -0400 Subject: [PATCH 25/38] traits: consider whether origin is RFC1214 when caching, ensuring that the test rfc1214-warn-and-error.rs reports an error --- src/librustc/middle/traits/fulfill.rs | 29 ++++++++++----- src/librustc/middle/traits/mod.rs | 9 +++++ src/librustc/middle/traits/select.rs | 4 +- .../compile-fail/rfc1214-warn-and-error.rs | 37 +++++++++++++++++++ 4 files changed, 68 insertions(+), 11 deletions(-) create mode 100644 src/test/compile-fail/rfc1214-warn-and-error.rs diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs index 96637b92cef41..1fca66f137918 100644 --- a/src/librustc/middle/traits/fulfill.rs +++ b/src/librustc/middle/traits/fulfill.rs @@ -27,12 +27,13 @@ use super::ObligationCause; use super::ObligationCauseCode; use super::PredicateObligation; use super::project; +use super::RFC1214Warning; use super::select::SelectionContext; use super::Unimplemented; use super::util::predicate_for_builtin_bound; pub struct FulfilledPredicates<'tcx> { - set: HashSet> + set: HashSet<(RFC1214Warning, ty::Predicate<'tcx>)> } /// The fulfillment context is used to drive trait resolution. It @@ -190,7 +191,9 @@ impl<'tcx> FulfillmentContext<'tcx> { assert!(!obligation.has_escaping_regions()); - if self.is_duplicate_or_add(infcx.tcx, &obligation.predicate) { + let w = RFC1214Warning(obligation.cause.code.is_rfc1214()); + + if self.is_duplicate_or_add(infcx.tcx, w, &obligation.predicate) { debug!("register_predicate({:?}) -- already seen, skip", obligation); return; } @@ -253,7 +256,9 @@ impl<'tcx> FulfillmentContext<'tcx> { &self.predicates } - fn is_duplicate_or_add(&mut self, tcx: &ty::ctxt<'tcx>, + fn is_duplicate_or_add(&mut self, + tcx: &ty::ctxt<'tcx>, + w: RFC1214Warning, predicate: &ty::Predicate<'tcx>) -> bool { // This is a kind of dirty hack to allow us to avoid "rederiving" @@ -268,10 +273,12 @@ impl<'tcx> FulfillmentContext<'tcx> { // evaluating the 'nested obligations'. This cache lets us // skip those. - if self.errors_will_be_reported && predicate.is_global() { - tcx.fulfilled_predicates.borrow_mut().is_duplicate_or_add(predicate) + let will_warn_due_to_rfc1214 = w.0; + let errors_will_be_reported = self.errors_will_be_reported && !will_warn_due_to_rfc1214; + if errors_will_be_reported && predicate.is_global() { + tcx.fulfilled_predicates.borrow_mut().is_duplicate_or_add(w, predicate) } else { - self.duplicate_set.is_duplicate_or_add(predicate) + self.duplicate_set.is_duplicate_or_add(w, predicate) } } @@ -537,11 +544,13 @@ impl<'tcx> FulfilledPredicates<'tcx> { } } - pub fn is_duplicate(&self, p: &ty::Predicate<'tcx>) -> bool { - self.set.contains(p) + pub fn is_duplicate(&self, w: RFC1214Warning, p: &ty::Predicate<'tcx>) -> bool { + let key = (w, p.clone()); + self.set.contains(&key) } - fn is_duplicate_or_add(&mut self, p: &ty::Predicate<'tcx>) -> bool { - !self.set.insert(p.clone()) + fn is_duplicate_or_add(&mut self, w: RFC1214Warning, p: &ty::Predicate<'tcx>) -> bool { + let key = (w, p.clone()); + !self.set.insert(key) } } diff --git a/src/librustc/middle/traits/mod.rs b/src/librustc/middle/traits/mod.rs index 14ab6c505d05c..6c501b1a609c4 100644 --- a/src/librustc/middle/traits/mod.rs +++ b/src/librustc/middle/traits/mod.rs @@ -528,6 +528,15 @@ impl<'tcx> ObligationCause<'tcx> { } } +/// This marker is used in some caches to record whether the +/// predicate, if it is found to be false, will yield a warning (due +/// to RFC1214) or an error. We separate these two cases in the cache +/// so that if we see the same predicate twice, first resulting in a +/// warning, and next resulting in an error, we still report the +/// error, rather than considering it a duplicate. +#[derive(Copy, Clone, PartialEq, Eq, Hash)] +pub struct RFC1214Warning(bool); + impl<'tcx> ObligationCauseCode<'tcx> { pub fn is_rfc1214(&self) -> bool { match *self { diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 713b7394b59a1..f63523b77d60f 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -27,6 +27,7 @@ use super::{ObligationCauseCode, BuiltinDerivedObligation, ImplDerivedObligation use super::{SelectionError, Unimplemented, OutputTypeParameterMismatch}; use super::{ObjectCastObligation, Obligation}; use super::TraitNotObjectSafe; +use super::RFC1214Warning; use super::Selection; use super::SelectionResult; use super::{VtableBuiltin, VtableImpl, VtableParam, VtableClosure, @@ -445,7 +446,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // have been proven elsewhere. This cache only contains // predicates that are global in scope and hence unaffected by // the current environment. - if self.tcx().fulfilled_predicates.borrow().is_duplicate(&obligation.predicate) { + let w = RFC1214Warning(false); + if self.tcx().fulfilled_predicates.borrow().is_duplicate(w, &obligation.predicate) { return EvaluatedToOk; } diff --git a/src/test/compile-fail/rfc1214-warn-and-error.rs b/src/test/compile-fail/rfc1214-warn-and-error.rs new file mode 100644 index 0000000000000..50fd3fc961c1d --- /dev/null +++ b/src/test/compile-fail/rfc1214-warn-and-error.rs @@ -0,0 +1,37 @@ +// Copyright 2015 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. + +// Test that an RFC1214 warning from an earlier function (`foo`) does +// not suppress an error for the same problem (`WantEq`, +// `NotEq: !Eq`) in a later function (`bar)`. Earlier versions of the +// warning mechanism had an issue due to caching. + +#![allow(dead_code)] +#![allow(unused_variables)] + +struct WantEq { t: T } + +struct NotEq; + +trait Trait { } + +fn foo() { + let x: Box>> = loop { }; + //~^ WARN E0277 +} + +fn bar() { + wf::>(); + //~^ ERROR E0277 +} + +fn wf() { } + +fn main() { } From a264440ab0f498e1ab77b17d24c3d6988c721c27 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 11:17:15 -0400 Subject: [PATCH 26/38] outlives: convert outlives to use an exhaustive match, for better reliability. --- src/librustc/middle/outlives.rs | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/src/librustc/middle/outlives.rs b/src/librustc/middle/outlives.rs index ec7dc5520ae3a..b7fcc54692311 100644 --- a/src/librustc/middle/outlives.rs +++ b/src/librustc/middle/outlives.rs @@ -161,9 +161,28 @@ fn compute_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, compute_components(infcx, ty, out); } } - _ => { - // for all other types, just constrain the regions and - // keep walking to find any other types. + + // Most types do not introduce any region binders, nor + // involve any other subtle cases, and so the WF relation + // simply constraints any regions referenced directly by + // the type and then visits the types that are lexically + // contained within. (The comments refer to relevant rules + // from RFC1214.) + ty::TyBool(..) | // OutlivesScalar + ty::TyChar(..) | // OutlivesScalar + ty::TyInt(..) | // OutlivesScalar + ty::TyUint(..) | // OutlivesScalar + ty::TyFloat(..) | // OutlivesScalar + ty::TyEnum(..) | // OutlivesNominalType + ty::TyStruct(..) | // OutlivesNominalType + ty::TyBox(..) | // OutlivesNominalType (ish) + ty::TyStr(..) | // OutlivesScalar (ish) + ty::TyArray(..) | // ... + ty::TySlice(..) | // ... + ty::TyRawPtr(..) | // ... + ty::TyRef(..) | // OutlivesReference + ty::TyTuple(..) | // ... + ty::TyError(..) => { push_region_constraints(out, ty.regions()); } } @@ -188,4 +207,3 @@ fn push_region_constraints<'tcx>(out: &mut Vec>, regions: Vec Date: Tue, 11 Aug 2015 11:33:55 -0400 Subject: [PATCH 27/38] outlives.rs: remove use of ty.walk and replace with recursive of ty.walk_shallow, add add'l comments. --- src/librustc/middle/outlives.rs | 232 +++++++++++++++++--------------- 1 file changed, 125 insertions(+), 107 deletions(-) diff --git a/src/librustc/middle/outlives.rs b/src/librustc/middle/outlives.rs index b7fcc54692311..9e40910b8a66e 100644 --- a/src/librustc/middle/outlives.rs +++ b/src/librustc/middle/outlives.rs @@ -8,7 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// The outlines relation `T: 'a` or `'a: 'b`. +// The outlines relation `T: 'a` or `'a: 'b`. This code frequently +// refers to rules defined in RFC 1214 (`OutlivesFooBar`), so see that +// RFC for reference. use middle::infer::InferCtxt; use middle::ty::{self, RegionEscape, Ty}; @@ -67,123 +69,139 @@ pub fn components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, } fn compute_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, - ty0: Ty<'tcx>, + ty: Ty<'tcx>, out: &mut Vec>) { // Descend through the types, looking for the various "base" // components and collecting them into `out`. This is not written // with `collect()` because of the need to sometimes skip subtrees // in the `subtys` iterator (e.g., when encountering a // projection). - let mut subtys = ty0.walk(); - while let Some(ty) = subtys.next() { - match ty.sty { - ty::TyClosure(_, ref substs) => { - // FIXME(#27086). We do not accumulate from substs, since they - // don't represent reachable data. This means that, in - // practice, some of the lifetime parameters might not - // be in scope when the body runs, so long as there is - // no reachable data with that lifetime. For better or - // worse, this is consistent with fn types, however, - // which can also encapsulate data in this fashion - // (though it's somewhat harder, and typically - // requires virtual dispatch). - // - // Note that changing this (in a naive way, at least) - // causes regressions for what appears to be perfectly - // reasonable code like this: - // - // ``` - // fn foo<'a>(p: &Data<'a>) { - // bar(|q: &mut Parser| q.read_addr()) - // } - // fn bar(p: Box) { - // } - // ``` - // - // Note that `p` (and `'a`) are not used in the - // closure at all, but to meet the requirement that - // the closure type `C: 'static` (so it can be coerced - // to the object type), we get the requirement that - // `'a: 'static` since `'a` appears in the closure - // type `C`. - // - // A smarter fix might "prune" unused `func_substs` -- - // this would avoid breaking simple examples like - // this, but would still break others (which might - // indeed be invalid, depending on your POV). Pruning - // would be a subtle process, since we have to see - // what func/type parameters are used and unused, - // taking into consideration UFCS and so forth. - - for &upvar_ty in &substs.upvar_tys { - compute_components(infcx, upvar_ty, out); - } - subtys.skip_current_subtree(); + match ty.sty { + ty::TyClosure(_, ref substs) => { + // FIXME(#27086). We do not accumulate from substs, since they + // don't represent reachable data. This means that, in + // practice, some of the lifetime parameters might not + // be in scope when the body runs, so long as there is + // no reachable data with that lifetime. For better or + // worse, this is consistent with fn types, however, + // which can also encapsulate data in this fashion + // (though it's somewhat harder, and typically + // requires virtual dispatch). + // + // Note that changing this (in a naive way, at least) + // causes regressions for what appears to be perfectly + // reasonable code like this: + // + // ``` + // fn foo<'a>(p: &Data<'a>) { + // bar(|q: &mut Parser| q.read_addr()) + // } + // fn bar(p: Box) { + // } + // ``` + // + // Note that `p` (and `'a`) are not used in the + // closure at all, but to meet the requirement that + // the closure type `C: 'static` (so it can be coerced + // to the object type), we get the requirement that + // `'a: 'static` since `'a` appears in the closure + // type `C`. + // + // A smarter fix might "prune" unused `func_substs` -- + // this would avoid breaking simple examples like + // this, but would still break others (which might + // indeed be invalid, depending on your POV). Pruning + // would be a subtle process, since we have to see + // what func/type parameters are used and unused, + // taking into consideration UFCS and so forth. + + for &upvar_ty in &substs.upvar_tys { + compute_components(infcx, upvar_ty, out); } - ty::TyBareFn(..) | ty::TyTrait(..) => { - subtys.skip_current_subtree(); + } + + // Bare functions and traits are both binders. In the RFC, + // this means we would add the bound regions to the "bound + // regions list". In our representation, no such list is + // maintained explicitly, because bound regions themselves can + // be readily identified. However, because the outlives + // relation did not used to be applied to fn/trait-object + // arguments, we due wrap the resulting components in an + // RFC1214 wrapper so we can issue warnings. + ty::TyBareFn(..) | ty::TyTrait(..) => { + // OutlivesFunction, OutlivesObject, OutlivesFragment + let subcomponents = capture_components(infcx, ty); + out.push(Component::RFC1214(subcomponents)); + } + + // OutlivesTypeParameterEnv -- the actual checking that `X:'a` + // is implied by the environment is done in regionck. + ty::TyParam(p) => { + out.push(Component::Param(p)); + } + + // For projections, we prefer to generate an obligation like + // `>::Foo: 'a`, because this gives the + // regionck more ways to prove that it holds. However, + // regionck is not (at least currently) prepared to deal with + // higher-ranked regions that may appear in the + // trait-ref. Therefore, if we see any higher-ranke regions, + // we simply fallback to the most restrictive rule, which + // requires that `Pi: 'a` for all `i`. + ty::TyProjection(ref data) => { + if !data.has_escaping_regions() { + // best case: no escaping regions, so push the + // projection and skip the subtree (thus generating no + // constraints for Pi). This defers the choice between + // the rules OutlivesProjectionEnv, + // OutlivesProjectionTraitDef, and + // OutlivesProjectionComponents to regionck. + out.push(Component::Projection(*data)); + } else { + // fallback case: hard code + // OutlivesProjectionComponents. Continue walking + // through and constrain Pi. let subcomponents = capture_components(infcx, ty); - out.push(Component::RFC1214(subcomponents)); - } - ty::TyParam(p) => { - out.push(Component::Param(p)); - subtys.skip_current_subtree(); - } - ty::TyProjection(ref data) => { - // For projections, we prefer to generate an - // obligation like `>::Foo: 'a`, - // because this gives the regionck more ways to prove - // that it holds. However, regionck is not (at least - // currently) prepared to deal with higher-ranked - // regions that may appear in the - // trait-ref. Therefore, if we see any higher-ranke - // regions, we simply fallback to the most restrictive - // rule, which requires that `Pi: 'a` for all `i`. - - if !data.has_escaping_regions() { - // best case: no escaping regions, so push the - // projection and skip the subtree (thus - // generating no constraints for Pi). - out.push(Component::Projection(*data)); - } else { - // fallback case: continue walking through and - // constrain Pi. - let subcomponents = capture_components(infcx, ty); - out.push(Component::EscapingProjection(subcomponents)); - } - subtys.skip_current_subtree(); + out.push(Component::EscapingProjection(subcomponents)); } - ty::TyInfer(_) => { - let ty = infcx.resolve_type_vars_if_possible(&ty); - if let ty::TyInfer(infer_ty) = ty.sty { - out.push(Component::UnresolvedInferenceVariable(infer_ty)); - } else { - compute_components(infcx, ty, out); - } + } + + // If we encounter an inference variable, try to resolve it + // and proceed with resolved version. If we cannot resolve it, + // then record the unresolved variable as a component. + ty::TyInfer(_) => { + let ty = infcx.resolve_type_vars_if_possible(&ty); + if let ty::TyInfer(infer_ty) = ty.sty { + out.push(Component::UnresolvedInferenceVariable(infer_ty)); + } else { + compute_components(infcx, ty, out); } + } - // Most types do not introduce any region binders, nor - // involve any other subtle cases, and so the WF relation - // simply constraints any regions referenced directly by - // the type and then visits the types that are lexically - // contained within. (The comments refer to relevant rules - // from RFC1214.) - ty::TyBool(..) | // OutlivesScalar - ty::TyChar(..) | // OutlivesScalar - ty::TyInt(..) | // OutlivesScalar - ty::TyUint(..) | // OutlivesScalar - ty::TyFloat(..) | // OutlivesScalar - ty::TyEnum(..) | // OutlivesNominalType - ty::TyStruct(..) | // OutlivesNominalType - ty::TyBox(..) | // OutlivesNominalType (ish) - ty::TyStr(..) | // OutlivesScalar (ish) - ty::TyArray(..) | // ... - ty::TySlice(..) | // ... - ty::TyRawPtr(..) | // ... - ty::TyRef(..) | // OutlivesReference - ty::TyTuple(..) | // ... - ty::TyError(..) => { - push_region_constraints(out, ty.regions()); + // Most types do not introduce any region binders, nor + // involve any other subtle cases, and so the WF relation + // simply constraints any regions referenced directly by + // the type and then visits the types that are lexically + // contained within. (The comments refer to relevant rules + // from RFC1214.) + ty::TyBool(..) | // OutlivesScalar + ty::TyChar(..) | // OutlivesScalar + ty::TyInt(..) | // OutlivesScalar + ty::TyUint(..) | // OutlivesScalar + ty::TyFloat(..) | // OutlivesScalar + ty::TyEnum(..) | // OutlivesNominalType + ty::TyStruct(..) | // OutlivesNominalType + ty::TyBox(..) | // OutlivesNominalType (ish) + ty::TyStr(..) | // OutlivesScalar (ish) + ty::TyArray(..) | // ... + ty::TySlice(..) | // ... + ty::TyRawPtr(..) | // ... + ty::TyRef(..) | // OutlivesReference + ty::TyTuple(..) | // ... + ty::TyError(..) => { + push_region_constraints(out, ty.regions()); + for subty in ty.walk_shallow() { + compute_components(infcx, subty, out); } } } From 2b2a11363819176a37e70b996405ce226f533c7b Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 13:43:29 -0400 Subject: [PATCH 28/38] check/wf.rs: change to use correct span and older WF algorithm; at the time I reinstituted the old code, I hadn't given up yet and brought back the implicator. --- src/librustc_typeck/check/wf.rs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index 21f48d37799e7..47eb1f472c31d 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -178,11 +178,8 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { } } - let field_tys: Vec = - variants.iter().flat_map(|v| v.fields.iter().map(|f| f.ty)).collect(); - - for &field_ty in &field_tys { - fcx.register_wf_obligation(field_ty, item.span, traits::MiscObligation); + for field in variants.iter().flat_map(|v| v.fields.iter()) { + fcx.register_old_wf_obligation(field.ty, field.span, traits::MiscObligation); } }); } From 157422a0c7990234cc196793c41bea6302bbe488 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 14:20:27 -0400 Subject: [PATCH 29/38] Update test error messages based on changes to wfcheck; also, break apart the tests that tested many things at once. --- src/test/compile-fail/issue-16747.rs | 2 +- src/test/compile-fail/issue-19380.rs | 2 +- .../compile-fail/object-safety-issue-22040.rs | 9 +++-- src/test/compile-fail/regions-enum-not-wf.rs | 12 +++--- ...-outlives-nominal-type-enum-region-rev.rs} | 31 +--------------- ...ions-outlives-nominal-type-enum-region.rs} | 37 +++---------------- ...ons-outlives-nominal-type-enum-type-rev.rs | 29 +++++++++++++++ ...regions-outlives-nominal-type-enum-type.rs | 29 +++++++++++++++ ...outlives-nominal-type-struct-region-rev.rs | 29 +++++++++++++++ ...ons-outlives-nominal-type-struct-region.rs | 29 +++++++++++++++ ...s-outlives-nominal-type-struct-type-rev.rs | 29 +++++++++++++++ ...gions-outlives-nominal-type-struct-type.rs | 29 +++++++++++++++ .../compile-fail/regions-struct-not-wf.rs | 6 +-- .../compile-fail/regions-wf-trait-object.rs | 2 +- src/test/compile-fail/wf-array-elem-sized.rs | 4 +- .../wf-enum-fields-struct-variant.rs | 28 ++++++++++++++ src/test/compile-fail/wf-enum-fields.rs | 6 --- src/test/compile-fail/wf-in-fn-type-static.rs | 4 +- .../compile-fail/wf-in-obj-type-static.rs | 2 +- .../wf-outlives-ty-in-fn-or-trait.rs | 2 - 20 files changed, 231 insertions(+), 90 deletions(-) rename src/test/compile-fail/{regions-outlives-nominal-type-struct.rs => regions-outlives-nominal-type-enum-region-rev.rs} (56%) rename src/test/compile-fail/{regions-outlives-nominal-type-enum.rs => regions-outlives-nominal-type-enum-region.rs} (50%) create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-enum-type-rev.rs create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-enum-type.rs create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-struct-region-rev.rs create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-struct-region.rs create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-struct-type-rev.rs create mode 100644 src/test/compile-fail/regions-outlives-nominal-type-struct-type.rs create mode 100644 src/test/compile-fail/wf-enum-fields-struct-variant.rs diff --git a/src/test/compile-fail/issue-16747.rs b/src/test/compile-fail/issue-16747.rs index a3529c9ea90b6..dd7e8a869eca9 100644 --- a/src/test/compile-fail/issue-16747.rs +++ b/src/test/compile-fail/issue-16747.rs @@ -15,10 +15,10 @@ trait ListItem<'a> { trait Collection { fn len(&self) -> usize; } struct List<'a, T: ListItem<'a>> { + slice: &'a [T] //~^ ERROR the parameter type `T` may not live long enough //~| HELP consider adding an explicit lifetime bound //~| NOTE ...so that the reference type `&'a [T]` does not outlive the data it points at - slice: &'a [T] } impl<'a, T: ListItem<'a>> Collection for List<'a, T> { fn len(&self) -> usize { diff --git a/src/test/compile-fail/issue-19380.rs b/src/test/compile-fail/issue-19380.rs index e24e6bbeb7bba..aae77c90b6bf2 100644 --- a/src/test/compile-fail/issue-19380.rs +++ b/src/test/compile-fail/issue-19380.rs @@ -18,11 +18,11 @@ impl Qiz for Foo { } struct Bar { -//~^ ERROR E0038 foos: &'static [&'static (Qiz + 'static)] } const FOO : Foo = Foo; const BAR : Bar = Bar { foos: &[&FOO]}; +//~^ ERROR E0038 fn main() { } diff --git a/src/test/compile-fail/object-safety-issue-22040.rs b/src/test/compile-fail/object-safety-issue-22040.rs index f49ed42fe44d0..de419a259a24c 100644 --- a/src/test/compile-fail/object-safety-issue-22040.rs +++ b/src/test/compile-fail/object-safety-issue-22040.rs @@ -18,13 +18,14 @@ trait Expr: Debug + PartialEq { //#[derive(PartialEq)] #[derive(Debug)] -struct SExpr<'x> { //~ ERROR E0038 +struct SExpr<'x> { elements: Vec>, } impl<'x> PartialEq for SExpr<'x> { fn eq(&self, other:&SExpr<'x>) -> bool { println!("L1: {} L2: {}", self.elements.len(), other.elements.len()); + //~^ ERROR E0038 let result = self.elements.len() == other.elements.len(); println!("Got compare {}", result); @@ -43,8 +44,8 @@ impl <'x> Expr for SExpr<'x> { } fn main() { - let a: Box = Box::new(SExpr::new()); - let b: Box = Box::new(SExpr::new()); + let a: Box = Box::new(SExpr::new()); //~ ERROR E0038 + let b: Box = Box::new(SExpr::new()); //~ ERROR E0038 - assert_eq!(a , b); + // assert_eq!(a , b); } diff --git a/src/test/compile-fail/regions-enum-not-wf.rs b/src/test/compile-fail/regions-enum-not-wf.rs index 3be9981787221..e21f92bc9b885 100644 --- a/src/test/compile-fail/regions-enum-not-wf.rs +++ b/src/test/compile-fail/regions-enum-not-wf.rs @@ -12,13 +12,13 @@ #![allow(dead_code)] -enum Ref1<'a, T> { //~ ERROR the parameter type `T` may not live long enough - Ref1Variant1(&'a T) +enum Ref1<'a, T> { + Ref1Variant1(&'a T) //~ ERROR the parameter type `T` may not live long enough } -enum Ref2<'a, T> { //~ ERROR the parameter type `T` may not live long enough +enum Ref2<'a, T> { Ref2Variant1, - Ref2Variant2(isize, &'a T), + Ref2Variant2(isize, &'a T), //~ ERROR the parameter type `T` may not live long enough } enum RefOk<'a, T:'a> { @@ -26,13 +26,13 @@ enum RefOk<'a, T:'a> { } enum RefIndirect<'a, T> { - //~^ ERROR the parameter type `T` may not live long enough RefIndirectVariant1(isize, RefOk<'a,T>) + //~^ ERROR the parameter type `T` may not live long enough } enum RefDouble<'a, 'b, T> { - //~^ ERROR reference has a longer lifetime than the data RefDoubleVariant1(&'a &'b T) + //~^ ERROR reference has a longer lifetime than the data } fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-struct.rs b/src/test/compile-fail/regions-outlives-nominal-type-enum-region-rev.rs similarity index 56% rename from src/test/compile-fail/regions-outlives-nominal-type-struct.rs rename to src/test/compile-fail/regions-outlives-nominal-type-enum-region-rev.rs index fb3fdddae8879..db25a0698fed4 100644 --- a/src/test/compile-fail/regions-outlives-nominal-type-struct.rs +++ b/src/test/compile-fail/regions-outlives-nominal-type-enum-region-rev.rs @@ -16,39 +16,12 @@ #![feature(rustc_attrs)] #![allow(dead_code)] -mod variant_struct_region { - struct Foo<'a> { - x: &'a i32, - } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<'b> - } -} - mod rev_variant_struct_region { struct Foo<'a> { x: fn(&'a i32), } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<'b> - } -} - -mod variant_struct_type { - struct Foo { - x: T - } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<&'b i32> - } -} - -mod rev_variant_struct_type { - struct Foo { - x: fn(T) - } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<&'b i32> + enum Bar<'a,'b> { + V(&'a Foo<'b>) //~ ERROR reference has a longer lifetime } } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-enum.rs b/src/test/compile-fail/regions-outlives-nominal-type-enum-region.rs similarity index 50% rename from src/test/compile-fail/regions-outlives-nominal-type-enum.rs rename to src/test/compile-fail/regions-outlives-nominal-type-enum-region.rs index 6fb409326f1f7..403757042d2f3 100644 --- a/src/test/compile-fail/regions-outlives-nominal-type-enum.rs +++ b/src/test/compile-fail/regions-outlives-nominal-type-enum-region.rs @@ -16,39 +16,12 @@ #![feature(rustc_attrs)] #![allow(dead_code)] -mod variant_enum_region { - enum Foo<'a> { - V { x: &'a i32 } +mod variant_struct_region { + struct Foo<'a> { + x: &'a i32, } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<'b> - } -} - -mod rev_variant_enum_region { - enum Foo<'a> { - V { x: fn(&'a i32) } - } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<'b> - } -} - -mod variant_enum_type { - enum Foo { - V { x: T } - } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<&'b i32> - } -} - -mod rev_variant_enum_type { - enum Foo { - V { x: fn(T) } - } - struct Bar<'a,'b> { //~ ERROR reference has a longer lifetime - f: &'a Foo<&'b i32> + enum Bar<'a,'b> { + V(&'a Foo<'b>) //~ ERROR reference has a longer lifetime } } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-enum-type-rev.rs b/src/test/compile-fail/regions-outlives-nominal-type-enum-type-rev.rs new file mode 100644 index 0000000000000..cc294651db773 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-enum-type-rev.rs @@ -0,0 +1,29 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod rev_variant_struct_type { + struct Foo { + x: fn(T) + } + enum Bar<'a,'b> { + V(&'a Foo<&'b i32>) //~ ERROR reference has a longer lifetime + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-enum-type.rs b/src/test/compile-fail/regions-outlives-nominal-type-enum-type.rs new file mode 100644 index 0000000000000..e269767cc1683 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-enum-type.rs @@ -0,0 +1,29 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod variant_struct_type { + struct Foo { + x: T + } + enum Bar<'a,'b> { + F(&'a Foo<&'b i32>) //~ ERROR reference has a longer lifetime + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-struct-region-rev.rs b/src/test/compile-fail/regions-outlives-nominal-type-struct-region-rev.rs new file mode 100644 index 0000000000000..c7e6ace8b9224 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-struct-region-rev.rs @@ -0,0 +1,29 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod rev_variant_struct_region { + struct Foo<'a> { + x: fn(&'a i32), + } + struct Bar<'a,'b> { + f: &'a Foo<'b> //~ ERROR reference has a longer lifetime + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-struct-region.rs b/src/test/compile-fail/regions-outlives-nominal-type-struct-region.rs new file mode 100644 index 0000000000000..2fe6444c33aec --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-struct-region.rs @@ -0,0 +1,29 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod variant_struct_region { + struct Foo<'a> { + x: &'a i32, + } + struct Bar<'a,'b> { + f: &'a Foo<'b> //~ ERROR reference has a longer lifetime + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-struct-type-rev.rs b/src/test/compile-fail/regions-outlives-nominal-type-struct-type-rev.rs new file mode 100644 index 0000000000000..c4b631bce9874 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-struct-type-rev.rs @@ -0,0 +1,29 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod rev_variant_struct_type { + struct Foo { + x: fn(T) + } + struct Bar<'a,'b> { + f: &'a Foo<&'b i32> //~ ERROR reference has a longer lifetime + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-outlives-nominal-type-struct-type.rs b/src/test/compile-fail/regions-outlives-nominal-type-struct-type.rs new file mode 100644 index 0000000000000..1c9489444a6a3 --- /dev/null +++ b/src/test/compile-fail/regions-outlives-nominal-type-struct-type.rs @@ -0,0 +1,29 @@ +// Copyright 2014 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. + +// Test that a nominal type (like `Foo<'a>`) outlives `'b` if its +// arguments (like `'a`) outlive `'b`. +// +// Rule OutlivesNominalType from RFC 1214. + +#![feature(rustc_attrs)] +#![allow(dead_code)] + +mod variant_struct_type { + struct Foo { + x: T + } + struct Bar<'a,'b> { + f: &'a Foo<&'b i32> //~ ERROR reference has a longer lifetime + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/regions-struct-not-wf.rs b/src/test/compile-fail/regions-struct-not-wf.rs index 17831266f7e13..a7f1828970324 100644 --- a/src/test/compile-fail/regions-struct-not-wf.rs +++ b/src/test/compile-fail/regions-struct-not-wf.rs @@ -13,8 +13,8 @@ #![allow(dead_code)] struct Ref<'a, T> { - //~^ ERROR the parameter type `T` may not live long enough field: &'a T + //~^ ERROR the parameter type `T` may not live long enough } struct RefOk<'a, T:'a> { @@ -22,13 +22,13 @@ struct RefOk<'a, T:'a> { } struct RefIndirect<'a, T> { - //~^ ERROR the parameter type `T` may not live long enough field: RefOk<'a, T> + //~^ ERROR the parameter type `T` may not live long enough } struct DoubleRef<'a, 'b, T> { - //~^ ERROR reference has a longer lifetime than the data it references field: &'a &'b T + //~^ ERROR reference has a longer lifetime than the data it references } fn main() { } diff --git a/src/test/compile-fail/regions-wf-trait-object.rs b/src/test/compile-fail/regions-wf-trait-object.rs index 2ad1163052b37..e1f1fdaeb341d 100644 --- a/src/test/compile-fail/regions-wf-trait-object.rs +++ b/src/test/compile-fail/regions-wf-trait-object.rs @@ -14,8 +14,8 @@ trait TheTrait<'t>: 't { } struct Foo<'a,'b> { - //~^ ERROR lifetime bound not satisfied x: Box+'b> + //~^ ERROR reference has a longer lifetime } fn main() { } diff --git a/src/test/compile-fail/wf-array-elem-sized.rs b/src/test/compile-fail/wf-array-elem-sized.rs index aaae41c766762..c8b7f35b3aa58 100644 --- a/src/test/compile-fail/wf-array-elem-sized.rs +++ b/src/test/compile-fail/wf-array-elem-sized.rs @@ -13,8 +13,8 @@ #![feature(rustc_attrs)] #![allow(dead_code)] -struct Foo { //~ WARN E0277 - foo: [[u8]], +struct Foo { + foo: [[u8]], //~ WARN E0277 } #[rustc_error] diff --git a/src/test/compile-fail/wf-enum-fields-struct-variant.rs b/src/test/compile-fail/wf-enum-fields-struct-variant.rs new file mode 100644 index 0000000000000..5eb53e7edde6b --- /dev/null +++ b/src/test/compile-fail/wf-enum-fields-struct-variant.rs @@ -0,0 +1,28 @@ +// Copyright 2014 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. + +// Test that we check struct fields for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct IsCopy { + value: T +} + +enum AnotherEnum { + AnotherVariant { + f: IsCopy //~ ERROR E0277 + } +} + +#[rustc_error] +fn main() { } diff --git a/src/test/compile-fail/wf-enum-fields.rs b/src/test/compile-fail/wf-enum-fields.rs index 40a939350822b..76ad40f845768 100644 --- a/src/test/compile-fail/wf-enum-fields.rs +++ b/src/test/compile-fail/wf-enum-fields.rs @@ -22,11 +22,5 @@ enum SomeEnum { SomeVariant(IsCopy) //~ ERROR E0277 } -enum AnotherEnum { //~ ERROR E0277 - AnotherVariant { - f: IsCopy - } -} - #[rustc_error] fn main() { } diff --git a/src/test/compile-fail/wf-in-fn-type-static.rs b/src/test/compile-fail/wf-in-fn-type-static.rs index 08853c69d6dac..593c9435f6c75 100644 --- a/src/test/compile-fail/wf-in-fn-type-static.rs +++ b/src/test/compile-fail/wf-in-fn-type-static.rs @@ -18,12 +18,12 @@ struct MustBeCopy { t: T } -struct Foo { //~ WARN E0310 +struct Foo { // needs T: 'static x: fn() -> &'static T //~ WARN E0310 } -struct Bar { //~ WARN E0310 +struct Bar { // needs T: Copy x: fn(&'static T) //~ WARN E0310 } diff --git a/src/test/compile-fail/wf-in-obj-type-static.rs b/src/test/compile-fail/wf-in-obj-type-static.rs index 36c8f5be308c5..c697dfd50ad47 100644 --- a/src/test/compile-fail/wf-in-obj-type-static.rs +++ b/src/test/compile-fail/wf-in-obj-type-static.rs @@ -19,7 +19,7 @@ struct MustBeCopy { t: T } -struct Foo { //~ WARN E0310 +struct Foo { // needs T: 'static x: Object<&'static T> //~ WARN E0310 } diff --git a/src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs b/src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs index eca128f4a1380..dc0cbeff153a9 100644 --- a/src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs +++ b/src/test/compile-fail/wf-outlives-ty-in-fn-or-trait.rs @@ -18,13 +18,11 @@ trait Trait { } struct Foo<'a,T> { - //~^ WARN E0309 f: &'a fn(T), //~^ WARN E0309 } struct Bar<'a,T> { - //~^ WARN E0309 f: &'a Trait, //~^ WARN E0309 } From c106dd449ce9b8e0230a832810a9598274de27e3 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 14:32:01 -0400 Subject: [PATCH 30/38] traits/error_reporting.rs: always note obligation cause --- src/librustc/middle/traits/error_reporting.rs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index fb2db5089c978..467c752499b36 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -206,13 +206,10 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, // error message, report with that message if it does let custom_note = report_on_unimplemented(infcx, &trait_ref.0, obligation.cause.span); - if is_warning { - note_obligation_cause(infcx, obligation); - } else if let Some(s) = custom_note { + if let Some(s) = custom_note { infcx.tcx.sess.span_note(obligation.cause.span, &s); - } else { - note_obligation_cause(infcx, obligation); } + note_obligation_cause(infcx, obligation); } } From 213326cddd0fa470c347992f5b66e776a85864a7 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 11 Aug 2015 14:34:27 -0400 Subject: [PATCH 31/38] outlives.rs: correct typo --- src/librustc/middle/outlives.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/librustc/middle/outlives.rs b/src/librustc/middle/outlives.rs index 9e40910b8a66e..ee871332de31a 100644 --- a/src/librustc/middle/outlives.rs +++ b/src/librustc/middle/outlives.rs @@ -126,8 +126,8 @@ fn compute_components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, // maintained explicitly, because bound regions themselves can // be readily identified. However, because the outlives // relation did not used to be applied to fn/trait-object - // arguments, we due wrap the resulting components in an - // RFC1214 wrapper so we can issue warnings. + // arguments, we wrap the resulting components in an RFC1214 + // wrapper so we can issue warnings. ty::TyBareFn(..) | ty::TyTrait(..) => { // OutlivesFunction, OutlivesObject, OutlivesFragment let subcomponents = capture_components(infcx, ty); From fda9b8396057426e86409fd75c69d896b05c372e Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 12 Aug 2015 10:19:02 -0400 Subject: [PATCH 32/38] regionck.rs: add a delayed_span_bug call to validate an asserrtion --- src/librustc_typeck/check/regionck.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 1d575128663dc..49070c2d6e03f 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -1549,10 +1549,13 @@ fn components_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, outlives::Component::EscapingProjection(subcomponents) => { components_must_outlive(rcx, origin, subcomponents, region); } - outlives::Component::UnresolvedInferenceVariable(_) => { + outlives::Component::UnresolvedInferenceVariable(v) => { // ignore this, we presume it will yield an error // later, since if a type variable is not resolved by // this point it never will be + rcx.tcx().sess.delay_span_bug( + origin.span(), + &format!("unresolved inference variable in outlives: {:?}", v)); } outlives::Component::RFC1214(subcomponents) => { let suborigin = infer::RFC1214Subregion(Rc::new(origin)); From ad700abea4c6718628a4ceccccdad6a633f1dd9c Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 12 Aug 2015 15:03:19 -0400 Subject: [PATCH 33/38] ty.rs: document/cleanup required_region_bounds a bit --- src/librustc/middle/ty.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 9ccfce8d3049f..49bf0e580b9e0 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -6233,13 +6233,18 @@ impl<'tcx> ctxt<'tcx> { /// themselves. This should really be a unique type; `FreshTy(0)` is a /// popular choice. /// + /// NB: in some cases, particularly around higher-ranked bounds, + /// this function returns a kind of conservative approximation. + /// That is, all regions returned by this function are definitely + /// required, but there may be other region bounds that are not + /// returned, as well as requirements like `for<'a> T: 'a`. + /// /// Requires that trait definitions have been processed so that we can /// elaborate predicates and walk supertraits. pub fn required_region_bounds(&self, erased_self_ty: Ty<'tcx>, predicates: Vec>) - -> Vec - { + -> Vec { debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})", erased_self_ty, predicates); @@ -6268,11 +6273,7 @@ impl<'tcx> ctxt<'tcx> { // construct such an object, but this seems // correct even if that code changes). if t == erased_self_ty && !r.has_escaping_regions() { - if r.has_escaping_regions() { - Some(ty::ReStatic) - } else { - Some(r) - } + Some(r) } else { None } From 9f3f69efab08afc14674647667f7561d669e76c3 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 12 Aug 2015 17:55:50 -0400 Subject: [PATCH 34/38] regionck.rs: experimentally adopt a more conservative strategy for projection outlives relations that prefers not to add extract edges to region graph --- src/librustc_typeck/check/regionck.rs | 179 +++++++++++--------------- 1 file changed, 73 insertions(+), 106 deletions(-) diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 49070c2d6e03f..cc2ac42428b5f 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -1580,116 +1580,60 @@ fn param_ty_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, fn projection_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, origin: infer::SubregionOrigin<'tcx>, region: ty::Region, - projection_ty: ty::ProjectionTy<'tcx>) { + projection_ty: ty::ProjectionTy<'tcx>) +{ debug!("projection_must_outlive(region={:?}, projection_ty={:?}, origin={:?})", region, projection_ty, origin); - // This is a particularly thorny situation for inference, and for - // now we don't have a complete solution, we just do the best we - // can. The problem is that there are multiple ways for `>::Foo: 'r` to be satisfied: - // - // 1. If `Pi: 'r` forall i, it is satisfied. - // 2. If there is a suitable where-clause, it can be satisfied. - // 3. The trait declaration may declare `'static` bounds on `Foo` as well. - // - // The fact that there are so many options here makes this thorny. - // In the case of parameter relations like `T: 'r`, it's somewhat - // simpler, because checking such a relation does not affect - // inference. This is true because the region bounds we can - // derive for `T` never involve region variables -- they are - // always free regions. The only place a region variable can come - // is on the RHS, and in that case, the smaller the region, the - // better. This means that our current inference, which always - // infers the smallest region it can, can just be used, and we'll - // know what the smallest value for `'r` is when it's done. We can - // then compare that to the regions in the LHS, which are already - // as big as possible, and we're all done. - // - // Projections can in fact be this simple as well. In particular, - // if the parameters `P0..Pn` do not involve any region variables, - // that's the same situation. - // - // Where things get thorny is when region variables are involved, - // because in that case relating `Pi: 'r` may influence the - // inference process, since it could cause `'r` to be inferred to - // a larger value. But the problem is that if we add that as a - // constraint into our dataflow graph, we've essentially committed - // to using option 1 (above) to show that `>::Foo: 'r` is satisfied, and it may be that - // Option 1 does not apply, but Option 2 or 3 does. But we can't - // know that now. - // - // For now we choose to accept this. It's a conservative choice, - // so we can move to a more sophisticated inference model later. - // And it's sometimes possible to workaround by introducing - // explicit type parameters or type annotations. But it ain't - // great! - - let declared_bounds = projection_declared_bounds(rcx, origin.span(), projection_ty); - - debug!("projection_must_outlive: declared_bounds={:?}", - declared_bounds); - - // If we know that the projection outlives 'static, then we're done here. - if declared_bounds.contains(&ty::ReStatic) { + // This case is thorny for inference. The fundamental problem is + // that there are many cases where we have choice, and inference + // doesn't like choice (the current region inference in + // particular). :) First off, we have to choose between using the + // OutlivesProjectionEnv, OutlivesProjectionTraitDef, and + // OutlivesProjectionComponent rules, any one of which is + // sufficient. If there are no inference variables involved, it's + // not hard to pick the right rule, but if there are, we're in a + // bit of a catch 22: if we picked which rule we were going to + // use, we could add constraints to the region inference graph + // that make it apply, but if we don't add those constraints, the + // rule might not apply (but another rule might). For now, we err + // on the side of adding too few edges into the graph. + + // Compute the bounds we can derive from the environment or trait + // definition. We know that the projection outlives all the + // regions in this list. + let env_bounds = projection_declared_bounds(rcx, origin.span(), projection_ty); + + debug!("projection_must_outlive: env_bounds={:?}", + env_bounds); + + // If we know that the projection outlives 'static, then we're + // done here. + if env_bounds.contains(&ty::ReStatic) { + debug!("projection_must_outlive: 'static as declared bound"); return; } - // Determine whether any of regions that appear in the projection - // were declared as bounds by the user. This is typically a situation - // like this: - // - // trait Foo<'a> { - // type Bar: 'a; - // } - // - // where we are checking `>: '_#1r`. In such a - // case, if we use the conservative rule, we will check that - // BOTH of the following hold: - // - // T: _#1r - // _#0r: _#1r + // If declared bounds list is empty, the only applicable rule is + // OutlivesProjectionComponent. If there are inference variables, + // then, we can break down the outlives into more primitive + // components without adding unnecessary edges. // - // This is overkill, since the declared bounds tell us that the - // the latter is sufficient. - let intersection_bounds: Vec<_> = - projection_ty.trait_ref.substs.regions() - .iter() - .filter(|r| declared_bounds.contains(r)) - .collect(); - let intersection_bounds_needs_infer = - intersection_bounds.iter() - .any(|r| r.needs_infer()); - if intersection_bounds_needs_infer { - // If the upper bound(s) (`_#0r` in the above example) are - // region variables, then introduce edges into the inference - // graph, because we need to ensure that `_#0r` is inferred to - // something big enough. But if the upper bound has no - // inference, then fallback (below) to the verify path, where - // we just check after the fact that it was big enough. This - // is more flexible, because it only requires that there - // exists SOME intersection bound that is big enough, whereas - // this path requires that ALL intersection bounds be big - // enough. - debug!("projection_must_outlive: intersection_bounds={:?}", - intersection_bounds); - for &r in intersection_bounds { - rcx.fcx.mk_subr(origin.clone(), region, r); - } - return; - } - - // If there are no intersection bounds, but there are still - // inference variables involves, then fallback to the most - // conservative rule, where we require all components of the - // projection outlive the bound. - if - intersection_bounds.is_empty() && ( - projection_ty.trait_ref.substs.types.iter().any(|t| t.needs_infer()) || - projection_ty.trait_ref.substs.regions().iter().any(|r| r.needs_infer())) - { - debug!("projection_must_outlive: fallback to rule #1"); + // If there are *no* inference variables, however, we COULD do + // this, but we choose not to, because the error messages are less + // good. For example, a requirement like `T::Item: 'r` would be + // translated to a requirement that `T: 'r`; when this is reported + // to the user, it will thus say "T: 'r must hold so that T::Item: + // 'r holds". But that makes it sound like the only way to fix + // the problem is to add `T: 'r`, which isn't true. So, if there are no + // inference variables, we use a verify constraint instead of adding + // edges, which winds up enforcing the same condition. + let needs_infer = { + projection_ty.trait_ref.substs.types.iter().any(|t| t.needs_infer()) || + projection_ty.trait_ref.substs.regions().iter().any(|r| r.needs_infer()) + }; + if env_bounds.is_empty() && needs_infer { + debug!("projection_must_outlive: no declared bounds"); for &component_ty in &projection_ty.trait_ref.substs.types { type_must_outlive(rcx, origin.clone(), component_ty, region); @@ -1702,9 +1646,32 @@ fn projection_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, return; } - // Inform region inference that this generic must be properly - // bounded. - let verify_bound = projection_bound(rcx, origin.span(), declared_bounds, projection_ty); + // If we find that there is a unique declared bound `'b`, and this bound + // appears in the trait reference, then the best action is to require that `'b:'r`, + // so do that. This is best no matter what rule we use: + // + // - OutlivesProjectionEnv or OutlivesProjectionTraitDef: these would translate to + // the requirement that `'b:'r` + // - OutlivesProjectionComponent: this would require `'b:'r` in addition to other conditions + if !env_bounds.is_empty() && env_bounds[1..].iter().all(|b| *b == env_bounds[0]) { + let unique_bound = env_bounds[0]; + debug!("projection_must_outlive: unique declared bound = {:?}", unique_bound); + if projection_ty.trait_ref.substs.regions() + .iter() + .any(|r| env_bounds.contains(r)) + { + debug!("projection_must_outlive: unique declared bound appears in trait ref"); + rcx.fcx.mk_subr(origin.clone(), region, unique_bound); + return; + } + } + + // Fallback to verifying after the fact that there exists a + // declared bound, or that all the components appearing in the + // projection outlive; in some cases, this may add insufficient + // edges into the inference graph, leading to inference failures + // even though a satisfactory solution exists. + let verify_bound = projection_bound(rcx, origin.span(), env_bounds, projection_ty); let generic = GenericKind::Projection(projection_ty); rcx.fcx.infcx().verify_generic_bound(origin, generic.clone(), region, verify_bound); } From e1fa00bced4c020c7765786d76e2b53c7ae803cd Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 12 Aug 2015 20:58:47 -0400 Subject: [PATCH 35/38] add regression test for #27592. Fixes #27592. --- src/test/compile-fail/issue-27592.rs | 29 ++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 src/test/compile-fail/issue-27592.rs diff --git a/src/test/compile-fail/issue-27592.rs b/src/test/compile-fail/issue-27592.rs new file mode 100644 index 0000000000000..ccf5eabc1110d --- /dev/null +++ b/src/test/compile-fail/issue-27592.rs @@ -0,0 +1,29 @@ +// Copyright 2015 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. + +// Regression test for issue #27591. + +fn write<'a, F: ::std::ops::FnOnce()->::std::fmt::Arguments<'a> + 'a>(fcn: F) { + use std::fmt::Write; + let _ = match fcn() { a => write!(&mut Stream, "{}", a), }; +} + +struct Stream; +impl ::std::fmt::Write for Stream { + fn write_str(&mut self, _s: &str) -> ::std::fmt::Result { + Ok( () ) + } +} + +fn main() { + write(|| format_args!("{}", "Hello world")); + //~^ ERROR borrowed value does not live long enough + //~| ERROR borrowed value does not live long enough +} From 33200a369ae1aee29e2bcf2aa67f746ddc5e16cc Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 12 Aug 2015 20:59:01 -0400 Subject: [PATCH 36/38] expr_use_visitor: Remove FIXME that is no longer needed (and in fact causes errors, post rebase). Issue #27592 is still alive and well, whatever it is. --- src/librustc/middle/expr_use_visitor.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 4e09f9a86329a..e5ee2ca0d4022 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -274,7 +274,6 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { pub fn new(delegate: &'d mut Delegate<'tcx>, typer: &'t infer::InferCtxt<'a, 'tcx>) -> ExprUseVisitor<'d,'t,'a,'tcx> - where 'tcx: 't // FIXME(#27583) workaround apparent stage0 bug { ExprUseVisitor { typer: typer, From 401a2435521ad63a0d780a719f4f5cf9f8b6ae90 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 13 Aug 2015 05:10:47 -0400 Subject: [PATCH 37/38] astconv.rs: extended ast_ty_to_ty debugging --- src/librustc_typeck/astconv.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 64cde0fccabaa..345026bdae673 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1523,12 +1523,13 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, ast_ty: &ast::Ty) -> Ty<'tcx> { - debug!("ast_ty_to_ty(ast_ty={:?})", - ast_ty); + debug!("ast_ty_to_ty(id={:?}, ast_ty={:?})", + ast_ty.id, ast_ty); let tcx = this.tcx(); if let Some(&ty) = tcx.ast_ty_to_ty_cache.borrow().get(&ast_ty.id) { + debug!("ast_ty_to_ty: id={:?} ty={:?} (cached)", ast_ty.id, ty); return ty; } @@ -1667,6 +1668,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, } }; + debug!("ast_ty_to_ty: id={:?} ty={:?}", ast_ty.id, typ); tcx.ast_ty_to_ty_cache.borrow_mut().insert(ast_ty.id, typ); return typ; } From 7f8942c18d552837033dc543e03a4156200896e8 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 14 Aug 2015 09:26:19 -0400 Subject: [PATCH 38/38] Correct nits from @nrc --- src/librustc/middle/outlives.rs | 6 +++++- src/librustc/middle/wf.rs | 6 +++--- src/librustc_typeck/check/regionck.rs | 5 ----- 3 files changed, 8 insertions(+), 9 deletions(-) diff --git a/src/librustc/middle/outlives.rs b/src/librustc/middle/outlives.rs index ee871332de31a..9a2570d710d38 100644 --- a/src/librustc/middle/outlives.rs +++ b/src/librustc/middle/outlives.rs @@ -54,6 +54,10 @@ pub enum Component<'tcx> { // the future without breaking backwards compat. EscapingProjection(Vec>), + // This is a temporary marker indicating "outlives components" + // that are due to the new rules introduced by RFC 1214. For the + // time being, violations of these requirements generally induce + // warnings, not errors. RFC1214(Vec>), } @@ -64,7 +68,7 @@ pub fn components<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, -> Vec> { let mut components = vec![]; compute_components(infcx, ty0, &mut components); - debug!("outlives({:?}) = {:?}", ty0, components); + debug!("components({:?}) = {:?}", ty0, components); components } diff --git a/src/librustc/middle/wf.rs b/src/librustc/middle/wf.rs index d7808599895f5..670b9d72d868b 100644 --- a/src/librustc/middle/wf.rs +++ b/src/librustc/middle/wf.rs @@ -122,9 +122,9 @@ pub enum ImpliedBound<'tcx> { RegionSubProjection(ty::Region, ty::ProjectionTy<'tcx>), } -/// This routine computes the full set of well-formedness constraints -/// that must hold for the type `ty` to appear in a context with -/// lifetime `outer_region`. +/// Compute the implied bounds that a callee/impl can assume based on +/// the fact that caller/projector has ensured that `ty` is WF. See +/// the `ImpliedBound` type for more details. pub fn implied_bounds<'a,'tcx>( infcx: &'a InferCtxt<'a,'tcx>, body_id: ast::NodeId, diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index cc2ac42428b5f..ced3ee82de2bd 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -1732,11 +1732,6 @@ fn projection_bound<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, // see the extensive comment in projection_must_outlive - // this routine is not invoked in this case - assert!( - !projection_ty.trait_ref.substs.types.iter().any(|t| t.needs_infer()) && - !projection_ty.trait_ref.substs.regions().iter().any(|r| r.needs_infer())); - let ty = rcx.tcx().mk_projection(projection_ty.trait_ref, projection_ty.item_name); let recursive_bound = recursive_type_bound(rcx, span, ty);

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 RG0jii7;YQutc|JH{|57u<+cC- literal 0 HcmV?d00001 diff --git a/src/test/compile-fail/wf-trait-associated-type-trait.rs b/src/test/compile-fail/wf-trait-associated-type-trait.rs new file mode 100644 index 0000000000000..8c491e04c981d --- /dev/null +++ b/src/test/compile-fail/wf-trait-associated-type-trait.rs @@ -0,0 +1,26 @@ +// Copyright 2014 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. + +// Test that we check associated type default values for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +struct IsCopy { x: T } + +trait SomeTrait { + type Type1; + type Type2 = IsCopy; + //~^ WARN E0277 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-bound.rs b/src/test/compile-fail/wf-trait-bound.rs new file mode 100644 index 0000000000000..147b3ce236d42 --- /dev/null +++ b/src/test/compile-fail/wf-trait-bound.rs @@ -0,0 +1,25 @@ +// Copyright 2014 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. + +// Test that we check supertrait bounds for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +trait SomeTrait //~ WARN E0277 + where T: ExtraCopy +{ +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-default-fn-arg.rs b/src/test/compile-fail/wf-trait-default-fn-arg.rs new file mode 100644 index 0000000000000..57c6c1979f87e --- /dev/null +++ b/src/test/compile-fail/wf-trait-default-fn-arg.rs @@ -0,0 +1,29 @@ +// Copyright 2015 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. + +// Check that we test WF conditions for fn arguments. Because the +// current code is so goofy, this is only a warning for now. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +struct Bar { value: Box } + +trait Foo { + fn bar(&self, x: &Bar) { + //~^ WARN E0277 + // + // Here, Eq ought to be implemented. + } +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-default-fn-ret.rs b/src/test/compile-fail/wf-trait-default-fn-ret.rs new file mode 100644 index 0000000000000..939876403e54d --- /dev/null +++ b/src/test/compile-fail/wf-trait-default-fn-ret.rs @@ -0,0 +1,30 @@ +// Copyright 2015 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. + +// Check that we test WF conditions for fn arguments. Because the +// current code is so goofy, this is only a warning for now. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +struct Bar { value: Box } + +trait Foo { + fn bar(&self) -> Bar { + //~^ WARN E0277 + // + // Here, Eq ought to be implemented. + loop { } + } +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-default-fn-where-clause.rs b/src/test/compile-fail/wf-trait-default-fn-where-clause.rs new file mode 100644 index 0000000000000..b1c0d71fc5b3b --- /dev/null +++ b/src/test/compile-fail/wf-trait-default-fn-where-clause.rs @@ -0,0 +1,29 @@ +// Copyright 2015 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. + +// Check that we test WF conditions for fn arguments. Because the +// current code is so goofy, this is only a warning for now. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +trait Bar { } + +trait Foo { + fn bar(&self) where A: Bar { + //~^ WARN E0277 + // + // Here, Eq ought to be implemented. + } +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-fn-arg.rs b/src/test/compile-fail/wf-trait-fn-arg.rs new file mode 100644 index 0000000000000..ff263c85eb371 --- /dev/null +++ b/src/test/compile-fail/wf-trait-fn-arg.rs @@ -0,0 +1,27 @@ +// Copyright 2015 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. + +// Check that we test WF conditions for fn arguments in a trait definition. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +struct Bar { value: Box } + +trait Foo { + fn bar(&self, x: &Bar); + //~^ WARN E0277 + // + // Here, Eq ought to be implemented. +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-fn-ret.rs b/src/test/compile-fail/wf-trait-fn-ret.rs new file mode 100644 index 0000000000000..5c8f3030c2c21 --- /dev/null +++ b/src/test/compile-fail/wf-trait-fn-ret.rs @@ -0,0 +1,27 @@ +// Copyright 2015 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. + +// Check that we test WF conditions for fn return types in a trait definition. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +struct Bar { value: Box } + +trait Foo { + fn bar(&self) -> &Bar; + //~^ WARN E0277 + // + // Here, Eq ought to be implemented. +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-fn-where-clause.rs b/src/test/compile-fail/wf-trait-fn-where-clause.rs new file mode 100644 index 0000000000000..51b5475e51fba --- /dev/null +++ b/src/test/compile-fail/wf-trait-fn-where-clause.rs @@ -0,0 +1,27 @@ +// Copyright 2015 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. + +// Check that we test WF conditions for fn where clauses in a trait definition. + +#![feature(rustc_attrs)] +#![allow(dead_code)] +#![allow(unused_variables)] + +struct Bar { value: Box } + +trait Foo { + fn bar(&self) where Bar: Copy; + //~^ WARN E0277 + // + // Here, Eq ought to be implemented. +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/compile-fail/wf-trait-superbound.rs b/src/test/compile-fail/wf-trait-superbound.rs new file mode 100644 index 0000000000000..58ee766dad112 --- /dev/null +++ b/src/test/compile-fail/wf-trait-superbound.rs @@ -0,0 +1,23 @@ +// Copyright 2014 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. + +// Test that we check supertrait bounds for WFedness. + +#![feature(associated_type_defaults)] +#![feature(rustc_attrs)] +#![allow(dead_code)] + +trait ExtraCopy { } + +trait SomeTrait: ExtraCopy { //~ WARN E0277 +} + +#[rustc_error] +fn main() { } //~ ERROR compilation successful diff --git a/src/test/run-pass/project-defer-unification.rs b/src/test/run-pass/project-defer-unification.rs new file mode 100644 index 0000000000000..9a6ea2272fea7 --- /dev/null +++ b/src/test/run-pass/project-defer-unification.rs @@ -0,0 +1,105 @@ +// Copyright 2015 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. + +// A regression test extracted from image-0.3.11. The point of +// failure was in `index_colors` below. + +use std::ops::{Deref, DerefMut}; + +#[derive(Copy, Clone)] +pub struct Luma { pub data: [T; 1] } + +impl Pixel for Luma { + type Subpixel = T; +} + +pub struct ImageBuffer { + pixels: P, + c: Container, +} + +pub trait GenericImage: Sized { + type Pixel: Pixel; +} + +pub trait Pixel: Copy + Clone { + type Subpixel: Primitive; +} + +pub trait Primitive: Copy + PartialOrd + Clone { +} + +impl GenericImage for ImageBuffer +where P: Pixel + 'static, + Container: Deref + DerefMut, + P::Subpixel: 'static { + + type Pixel = P; +} + +impl Primitive for u8 { } + +impl ImageBuffer +where P: Pixel + 'static, + P::Subpixel: 'static, + Container: Deref +{ + pub fn pixels<'a>(&'a self) -> Pixels<'a, Self> { + loop { } + } + + pub fn pixels_mut(&mut self) -> PixelsMut