---

yaml
---
r: 227516
b: refs/heads/try
c: 1af7266
h: refs/heads/master
v: v3

Author: arielb1

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 73fb19c04ac227fe2aad2c618f76b6eb05dd7ec9
+refs/heads/try: 1af72660a76605a485866ba3a80a79d331586a0a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/liblibc/lib.rs

@@ -146,10 +146,7 @@ pub use funcs::bsd43::*;
 #[link(name = "m")]
 extern {}
 
-// When compiling rust with musl, statically include libc.a in liblibc.rlib.
-// A cargo build of the libc crate will therefore automatically pick up the
-// libc.a symbols because liblibc is transitively linked to by the stdlib.
-#[cfg(all(target_env = "musl", not(feature = "cargo-build"), not(test)))]
+#[cfg(all(target_env = "musl", not(test)))]
 #[link(name = "c", kind = "static")]
 extern {}
 

branches/try/src/librustc_typeck/check/method/probe.rs

@@ -398,11 +398,19 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         }
 
         let (impl_ty, impl_substs) = self.impl_ty_and_substs(impl_def_id);
-        let impl_ty = self.fcx.instantiate_type_scheme(self.span, &impl_substs, &impl_ty);
+
+        // We can't use instantiate_type_scheme here as it will pollute
+        // the fcx's fulfillment context if this probe is rolled back.
+        let cause = traits::ObligationCause::misc(self.span, self.fcx.body_id);
+        let mut selcx = &mut traits::SelectionContext::new(self.fcx.infcx(), self.fcx);
+        let traits::Normalized { value: impl_ty, .. } =
+            traits::normalize(selcx, cause, &impl_ty.subst(self.tcx(), &impl_substs));
 
         // Determine the receiver type that the method itself expects.
         let xform_self_ty =
             self.xform_self_ty(&item, impl_ty, &impl_substs);
+        debug!("assemble_inherent_impl_probe: self ty = {:?}",
+               xform_self_ty.repr(self.tcx()));
 
         self.inherent_candidates.push(Candidate {
             xform_self_ty: xform_self_ty,

branches/try/src/librustc_typeck/constrained_type_params.rs

@@ -19,21 +19,10 @@ pub enum Parameter {
     Region(ty::EarlyBoundRegion),
 }
 
-/// Returns the list of parameters that are constrained by the type `ty`
-/// - i.e. the value of each parameter in the list is uniquely determined
-/// by `ty` (see RFC 447).
 pub fn parameters_for_type<'tcx>(ty: Ty<'tcx>) -> Vec<Parameter> {
-    let mut result = vec![];
-    ty::maybe_walk_ty(ty, |t| {
-        if let ty::TyProjection(..) = t.sty {
-            false // projections are not injective.
-        } else {
-            result.append(&mut parameters_for_type_shallow(t));
-            // non-projection type constructors are injective.
-            true
-        }
-    });
-    result
+    ty.walk()
+      .flat_map(|ty| parameters_for_type_shallow(ty))
+      .collect()
 }
 
 pub fn parameters_for_trait_ref<'tcx>(trait_ref: &ty::TraitRef<'tcx>) -> Vec<Parameter> {

branches/try/src/librustdoc/html/render.rs

@@ -456,15 +456,13 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::Result<String> {
             let did = ast_util::local_def(pid);
             match paths.get(&did) {
                 Some(&(ref fqp, _)) => {
-                    // Needed to determine `self` type.
-                    let parent_basename = Some(fqp[fqp.len() - 1].clone());
                     search_index.push(IndexItem {
                         ty: shortty(item),
                         name: item.name.clone().unwrap(),
                         path: fqp[..fqp.len() - 1].connect("::"),
                         desc: shorter(item.doc_value()),
                         parent: Some(did),
-                        search_type: get_index_search_type(&item, parent_basename),
+                        search_type: None,
                     });
                 },
                 None => {}

branches/try/src/test/compile-fail/issue-26262.rs renamed to branches/try/src/test/run-pass/issue-25679.rs

@@ -8,25 +8,21 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Check that projections don't count as constraining type parameters.
-
-struct S<T>(T);
-
-trait Tr { type Assoc; fn test(); }
+trait Device {
+    type Resources;
+}
+struct Foo<D, R>(D, R);
 
-impl<T: Tr> S<T::Assoc> {
-//~^ ERROR the type parameter `T` is not constrained
-    fn foo(self, _: T) {
-        T::test();
-    }
+impl<D: Device, S> Foo<D, S> {
+    fn present(&self) {}
 }
 
-trait Trait1<T> { type Bar; }
-trait Trait2<'x> { type Foo; }
+struct Res;
+struct Dev;
 
-impl<'a,T: Trait2<'a>> Trait1<<T as Trait2<'a>>::Foo> for T {
-//~^ ERROR the lifetime parameter `'a` is not constrained
-    type Bar = &'a ();
-}
+impl Device for Dev { type Resources = Res; }
 
-fn main() {}
+fn main() {
+    let foo = Foo(Dev, Res);
+    foo.present();
+}