Normalize parameter environment with its own substitution

Otherwise, the substitution is carried out from outside perspective,
which would be against the very purpose of `ParameterEnvironment`.

Closes rust-lang#21750
Closes rust-lang#22077

Author: edwardw

src/librustc/middle/traits/mod.rs

@@ -413,10 +413,10 @@ pub fn normalize_param_env_or_error<'a,'tcx>(unnormalized_env: ty::ParameterEnvi
     }
 }
 
-pub fn normalize_param_env<'a,'tcx>(param_env: &ty::ParameterEnvironment<'a,'tcx>,
-                                    cause: ObligationCause<'tcx>)
-                                    -> Result<ty::ParameterEnvironment<'a,'tcx>,
-                                              Vec<FulfillmentError<'tcx>>>
+fn normalize_param_env<'a,'tcx>(param_env: &ty::ParameterEnvironment<'a,'tcx>,
+                                cause: ObligationCause<'tcx>)
+                                -> Result<ty::ParameterEnvironment<'a,'tcx>,
+                                          Vec<FulfillmentError<'tcx>>>
 {
     let tcx = param_env.tcx;
 

src/librustc/middle/traits/project.rs

@@ -21,7 +21,7 @@ use super::VtableImplData;
 use super::util;
 
 use middle::infer;
-use middle::subst::{Subst, Substs};
+use middle::subst::Substs;
 use middle::ty::{self, AsPredicate, ReferencesError, RegionEscape,
                  HasProjectionTypes, ToPolyTraitRef, Ty};
 use middle::ty_fold::{self, TypeFoldable, TypeFolder};
@@ -849,36 +849,38 @@ fn confirm_impl_candidate<'cx,'tcx>(
     impl_vtable: VtableImplData<'tcx, PredicateObligation<'tcx>>)
     -> (Ty<'tcx>, Vec<PredicateObligation<'tcx>>)
 {
+    let tcx = selcx.tcx();
     // there don't seem to be nicer accessors to these:
-    let impl_items_map = selcx.tcx().impl_items.borrow();
-    let impl_or_trait_items_map = selcx.tcx().impl_or_trait_items.borrow();
+    let impl_items_map = tcx.impl_items.borrow();
+    let impl_or_trait_items_map = tcx.impl_or_trait_items.borrow();
 
     let impl_items = &impl_items_map[impl_vtable.impl_def_id];
-    let mut impl_ty = None;
-    for impl_item in impl_items {
-        let assoc_type = match impl_or_trait_items_map[impl_item.def_id()] {
-            ty::TypeTraitItem(ref assoc_type) => assoc_type.clone(),
-            ty::MethodTraitItem(..) => { continue; }
-        };
-
-        if assoc_type.name != obligation.predicate.item_name {
-            continue;
-        }
-
-        let impl_poly_ty = ty::lookup_item_type(selcx.tcx(), assoc_type.def_id);
-        impl_ty = Some(impl_poly_ty.ty.subst(selcx.tcx(), &impl_vtable.substs));
-        break;
-    }
+    let assoc_type =
+        impl_items
+            .iter()
+            .filter_map(|item| {
+                match impl_or_trait_items_map[item.def_id()] {
+                    ty::TypeTraitItem(ref assoc_type)
+                    if assoc_type.name == obligation.predicate.item_name => {
+                        Some(assoc_type)
+                    }
+                    _ => None
+                }
+            })
+            .next();
 
-    match impl_ty {
-        Some(ty) => (ty, impl_vtable.nested.into_vec()),
+    match assoc_type {
+        Some(assoc_type) => {
+            let impl_ty = selcx.instantiate_assoc_type(assoc_type,
+                                                       &impl_vtable.substs);
+            (impl_ty, impl_vtable.nested.into_vec())
+        },
         None => {
-            // This means that the impl is missing a
-            // definition for the associated type. This error
-            // ought to be reported by the type checker method
-            // `check_impl_items_against_trait`, so here we
-            // just return ty_err.
-            (selcx.tcx().types.err, vec!())
+            // This means that the impl is missing a definition for the
+            // associated type. This error ought to be reported by the
+            // type checker method `check_impl_items_against_trait`, so
+            // here we just return ty_err.
+            (tcx.types.err, vec![])
         }
     }
 }

src/librustc/middle/traits/select.rs

@@ -33,7 +33,7 @@ use super::{util};
 
 use middle::fast_reject;
 use middle::subst::{Subst, Substs, TypeSpace, VecPerParamSpace};
-use middle::ty::{self, RegionEscape, ToPolyTraitRef, Ty};
+use middle::ty::{self, AssociatedType, RegionEscape, ToPolyTraitRef, Ty};
 use middle::infer;
 use middle::infer::{InferCtxt, TypeFreshener};
 use middle::ty_fold::TypeFoldable;
@@ -2195,6 +2195,25 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ///////////////////////////////////////////////////////////////////////////
     // Miscellany
 
+    pub fn instantiate_assoc_type(&self,
+                                  assoc_ty: &AssociatedType,
+                                  impl_substs: &Substs<'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
+            };
+
+        poly_ty.ty.subst(self.tcx(), substs)
+    }
+
     fn push_stack<'o,'s:'o>(&mut self,
                             previous_stack: Option<&'s TraitObligationStack<'s, 'tcx>>,
                             obligation: &'o TraitObligation<'tcx>)

src/librustc/middle/ty.rs

@@ -80,7 +80,7 @@ use std::vec::{CowVec, IntoIter};
 use collections::enum_set::{EnumSet, CLike};
 use std::collections::{HashMap, HashSet};
 use syntax::abi;
-use syntax::ast::{CrateNum, DefId, Ident, ItemTrait, LOCAL_CRATE};
+use syntax::ast::{CrateNum, DefId, Ident, ItemTrait, DUMMY_NODE_ID, LOCAL_CRATE};
 use syntax::ast::{MutImmutable, MutMutable, Name, NamedField, NodeId};
 use syntax::ast::{StmtExpr, StmtSemi, StructField, UnnamedField, Visibility};
 use syntax::ast_util::{self, is_local, lit_is_str, local_def, PostExpansionMethod};
@@ -2135,6 +2135,13 @@ impl<'tcx> TraitRef<'tcx> {
 pub struct ParameterEnvironment<'a, 'tcx:'a> {
     pub tcx: &'a ctxt<'tcx>,
 
+    /// Item the parameter environment is associated with. For `ItemImpl` or
+    /// `ItemFn`, this is the item itself; for `MethodImplItem`, however, this
+    /// is the implementation (container) it is in. A certain method may make
+    /// use of associated types, which are at the container level. So we need
+    /// to know this when instantiating associated types for methods.
+    pub def_id: DefId,
+
     /// See `construct_free_substs` for details.
     pub free_substs: Substs<'tcx>,
 
@@ -2161,6 +2168,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
     {
         ParameterEnvironment {
             tcx: self.tcx,
+            def_id: self.def_id,
             free_substs: self.free_substs.clone(),
             implicit_region_bound: self.implicit_region_bound,
             caller_bounds: caller_bounds,
@@ -2180,6 +2188,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                                 let method_bounds = &method_ty.predicates;
                                 construct_parameter_environment(
                                     cx,
+                                    method_ty.container.id(),
                                     method.span,
                                     method_generics,
                                     method_bounds,
@@ -2217,6 +2226,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                                 let method_bounds = &method_ty.predicates;
                                 construct_parameter_environment(
                                     cx,
+                                    method_ty.container.id(),
                                     method.span,
                                     method_generics,
                                     method_bounds,
@@ -2246,6 +2256,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                         let fn_predicates = lookup_predicates(cx, fn_def_id);
 
                         construct_parameter_environment(cx,
+                                                        fn_def_id,
                                                         item.span,
                                                         &fn_scheme.generics,
                                                         &fn_predicates,
@@ -2260,6 +2271,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                         let scheme = lookup_item_type(cx, def_id);
                         let predicates = lookup_predicates(cx, def_id);
                         construct_parameter_environment(cx,
+                                                        def_id,
                                                         item.span,
                                                         &scheme.generics,
                                                         &predicates,
@@ -6305,6 +6317,7 @@ impl Variance {
 /// are no free type/lifetime parameters in scope.
 pub fn empty_parameter_environment<'a,'tcx>(cx: &'a ctxt<'tcx>) -> ParameterEnvironment<'a,'tcx> {
     ty::ParameterEnvironment { tcx: cx,
+                               def_id: local_def(DUMMY_NODE_ID),
                                free_substs: Substs::empty(),
                                caller_bounds: Vec::new(),
                                implicit_region_bound: ty::ReEmpty,
@@ -6361,6 +6374,7 @@ pub fn construct_free_substs<'a,'tcx>(
 /// See `ParameterEnvironment` struct def'n for details
 pub fn construct_parameter_environment<'a,'tcx>(
     tcx: &'a ctxt<'tcx>,
+    def_id: DefId,
     span: Span,
     generics: &ty::Generics<'tcx>,
     generic_predicates: &ty::GenericPredicates<'tcx>,
@@ -6411,6 +6425,7 @@ pub fn construct_parameter_environment<'a,'tcx>(
 
     let unnormalized_env = ty::ParameterEnvironment {
         tcx: tcx,
+        def_id: def_id,
         free_substs: free_substs,
         implicit_region_bound: ty::ReScope(free_id_outlive.to_code_extent()),
         caller_bounds: predicates,

src/librustc_typeck/check/assoc.rs

@@ -29,7 +29,8 @@ pub fn normalize_associated_types_in<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
     debug!("normalize_associated_types_in(value={})", value.repr(infcx.tcx));
     let mut selcx = SelectionContext::new(infcx, typer);
     let cause = ObligationCause::new(span, body_id, MiscObligation);
-    let Normalized { value: result, obligations } = traits::normalize(&mut selcx, cause, value);
+    let Normalized { value: result,
+                     obligations } = traits::normalize(&mut selcx, cause, value);
     debug!("normalize_associated_types_in: result={} predicates={}",
            result.repr(infcx.tcx),
            obligations.repr(infcx.tcx));

src/librustc_typeck/check/wf.rs

@@ -139,6 +139,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
         reject_non_type_param_bounds(ccx.tcx, item.span, &type_predicates);
         let param_env =
             ty::construct_parameter_environment(ccx.tcx,
+                                                item_def_id,
                                                 item.span,
                                                 &type_scheme.generics,
                                                 &type_predicates,

src/test/compile-fail/issue-22077.rs

@@ -0,0 +1,26 @@
+// 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.
+
+trait Fun {
+    type Output;
+    fn call<'x>(&'x self) -> Self::Output;
+}
+
+struct Holder { x: String }
+
+impl<'a> Fun for Holder {
+    type Output = &'a str;
+    fn call<'b>(&'b self) -> &'b str {
+    //~^ ERROR method `call` has an incompatible type for trait
+        &self.x[..]
+    }
+}
+
+fn main() {}

src/test/run-pass/issue-21750.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 <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 Arg<A> {
+    fn arg(&self) -> A;
+}
+
+pub trait Traversal {
+    type Item;
+    fn foreach<F: Arg<Self::Item>>(F);
+}
+
+impl<'a> Traversal for i32 {
+    type Item = &'a i32;
+    fn foreach<F: Arg<&'a i32>>(f: F) {
+        f.arg();
+    }
+}
+
+impl<'a> Traversal for u8 {
+    type Item = &'a u8;
+    // A more verbose way to refer to the associated type. Should also work
+    // nonetheless.
+    fn foreach<F: Arg<<Self as Traversal>::Item>>(f: F) {
+        let _ = f.arg();
+    }
+}
+
+fn main() {}