Also fix #22066

Author: edwardw

src/librustc/middle/traits/project.rs

@@ -561,8 +561,7 @@ fn assemble_candidates_from_trait_def<'cx,'tcx>(
     };
 
     // If so, extract what we know from the trait and try to come up with a good answer.
-    let trait_predicates = ty::lookup_predicates(selcx.tcx(), trait_ref.def_id);
-    let bounds = trait_predicates.instantiate(selcx.tcx(), trait_ref.substs);
+    let bounds = selcx.instantiate_trait_predicates(&trait_ref);
     assemble_candidates_from_predicates(selcx, obligation, obligation_trait_ref,
                                         candidate_set, bounds.predicates.into_vec());
 }

src/librustc/middle/traits/select.rs

@@ -33,14 +33,15 @@ use super::{util};
 
 use middle::fast_reject;
 use middle::subst::{Subst, Substs, TypeSpace, VecPerParamSpace};
-use middle::ty::{self, AssociatedType, RegionEscape, ToPolyTraitRef, Ty};
+use middle::ty::{self, AssociatedType, RegionEscape, ToPolyTraitRef, TraitRef, Ty};
 use middle::infer;
 use middle::infer::{InferCtxt, TypeFreshener};
 use middle::ty_fold::TypeFoldable;
 use std::cell::RefCell;
 use std::collections::hash_map::HashMap;
 use std::rc::Rc;
-use syntax::{abi, ast};
+use syntax::abi;
+use syntax::ast::{self, DefId};
 use util::common::ErrorReported;
 use util::ppaux::Repr;
 
@@ -2201,19 +2202,33 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                                   -> Ty<'tcx>
     {
         let poly_ty = ty::lookup_item_type(self.tcx(), assoc_ty.def_id);
-        let substs =
-            if self.param_env().def_id == assoc_ty.container.id() {
-                // If the associated type we are about to instantiate is
-                // defined in the item current parameter environment is
-                // associated with, we are obliged to use free substitutions.
-                &self.param_env().free_substs
-            } else {
-                impl_substs
-            };
-
+        let substs = self.maybe_pick_free_substs(assoc_ty.container.id(), impl_substs);
         poly_ty.ty.subst(self.tcx(), substs)
     }
 
+    pub fn instantiate_trait_predicates(&self,
+                                        trait_ref: &Rc<TraitRef<'tcx>>)
+                                        -> ty::InstantiatedPredicates<'tcx>
+    {
+        let trait_predicates = ty::lookup_predicates(self.tcx(), trait_ref.def_id);
+        let substs = self.maybe_pick_free_substs(trait_ref.def_id, trait_ref.substs);
+        trait_predicates.instantiate(self.tcx(), substs)
+    }
+
+    fn maybe_pick_free_substs(&self,
+                              target_def_id: DefId,
+                              substs: &'cx Substs<'tcx>)
+                              -> &'cx Substs<'tcx>
+    {
+        // The free substitutions take precedence over the given one if
+        // current parameter environment is associated with `target_def_id`.
+        if self.param_env().def_id == target_def_id {
+            &self.param_env().free_substs
+        } else {
+            substs
+        }
+    }
+
     fn push_stack<'o,'s:'o>(&mut self,
                             previous_stack: Option<&'s TraitObligationStack<'s, 'tcx>>,
                             obligation: &'o TraitObligation<'tcx>)

src/test/compile-fail/regions-assoc-type-region-bound-in-trait-not-met.rs

@@ -22,12 +22,12 @@ impl<'a> Foo<'a> for &'a i16 {
 }
 
 impl<'a> Foo<'static> for &'a i32 {
-    //~^ ERROR cannot infer
+    //~^ ERROR does not fulfill the required lifetime
     type Value = &'a i32;
 }
 
 impl<'a,'b> Foo<'b> for &'a i64 {
-    //~^ ERROR cannot infer
+    //~^ ERROR does not fulfill the required lifetime
     type Value = &'a i32;
 }
 

src/test/compile-fail/regions-assoc-type-static-bound-in-trait-not-met.rs

@@ -17,7 +17,7 @@ trait Foo {
 }
 
 impl<'a> Foo for &'a i32 {
-    //~^ ERROR cannot infer
+    //~^ ERROR does not fulfill the required lifetime
     type Value = &'a i32;
 }
 

src/test/run-pass/issue-22066.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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub trait LineFormatter<'a> {
+    type Iter: Iterator<Item=&'a str> + 'a;
+    fn iter(&'a self, line: &'a str) -> Self::Iter;
+
+    fn dimensions(&'a self, line: &'a str) {
+        for grapheme in self.iter(line) {
+            let _ = grapheme.len();
+        }
+    }
+}
+
+fn main() {}