Change:
I'm getting an internal compiler error with this code. My repro involves a couple of other packages; here's the : And here's : I don't claim the code should compile cleanly (I encountered the bug originally when fiddling around with generic params I didn't fully understand), but I get a compiler panic. Here's the output from : : Backtrace: Possibly-related closed issues: , , ,
I've encountered a similar ICE with the latest stable: The problem arised while trying to sort out some trait constraints, apparently adding a clause was my source code change that triggered the issue. If needed I can put the offending code online, but I'm afraid it won't be a minimal example.

Discussion:
use rustc::ty::subst::Substs; use rustc::traits; use rustc::ty::{self, LvaluePreference, NoPreference, PreferMutLvalue, Ty}; <ins> use rustc::ty::subst::Subst; </ins> use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow, OverloadedDeref}; use rustc::ty::fold::TypeFoldable; use rustc::infer::{self, InferOk};

// Adjust the self expression the user provided and obtain the adjusted type. let self_ty = self.adjust_self_ty(unadjusted_self_ty, &pick); <del> // Make sure nobody calls `drop()` explicitly. self.enforce_illegal_method_limitations(&pick); </del> // Create substitutions for the method's type parameters. let rcvr_substs = self.fresh_receiver_substs(self_ty, &pick); let all_substs = self.instantiate_method_substs(&pick, segment, rcvr_substs);

// Create the final signature for the method, replacing late-bound regions. let (method_sig, method_predicates) = self.instantiate_method_sig(&pick, all_substs); <ins> // Unify the (adjusted) self type with what the method expects. // // SUBTLE: if we want good error messages, because of "guessing" while matching // traits, no trait system method can be called before this point because they // could alter our Self-type, except for normalizing the receiver from the // signature (which is also done during probing). let method_sig_rcvr = self.normalize_associated_types_in(self.span, &method_sig.inputs()[0]); self.unify_receivers(self_ty, method_sig_rcvr); let (method_sig, method_predicates) = self.normalize_associated_types_in(self.span, &(method_sig, method_predicates)); // Make sure nobody calls `drop()` explicitly. self.enforce_illegal_method_limitations(&pick); </ins> // If there is a `Self: Sized` bound and `Self` is a trait object, it is possible that // something which derefs to `Self` actually implements the trait and the caller // wanted to make a static dispatch on it but forgot to import the trait.

// appropriate hint suggesting to import the trait. let illegal_sized_bound = self.predicates_require_illegal_sized_bound(&method_predicates); <del> // Unify the (adjusted) self type with what the method expects. self.unify_receivers(self_ty, method_sig.inputs()[0]); </del> // Add any trait/regions obligations specified on the method's type parameters. // We won't add these if we encountered an illegal sized bound, so that we can use // a custom error in that case.

/////////////////////////////////////////////////////////////////////////// // <ins> // NOTE: this returns the *unnormalized* predicates and method sig. Because of // inference guessing, the predicates and method signature can't be normalized // until we unify the `Self` type. </ins> fn instantiate_method_sig(&mut self, pick: &probe::Pick<'tcx>, all_substs: &'tcx Substs<'tcx>)

let def_id = pick.item.def_id; let method_predicates = self.tcx.predicates_of(def_id) .instantiate(self.tcx, all_substs); <del> let method_predicates = self.normalize_associated_types_in(self.span, &method_predicates); </del> debug!("method_predicates after subst = {:?}", method_predicates);

debug!("late-bound lifetimes from method instantiated, method_sig={:?}", method_sig); <del> let method_sig = self.instantiate_type_scheme(self.span, all_substs, &method_sig); </del> <ins> let method_sig = method_sig.subst(self.tcx, all_substs); </ins> debug!("type scheme substituted, method_sig={:?}", method_sig); (method_sig, method_predicates)

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <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. struct Params; pub trait Plugin<E: ?Sized> { type Error; } pub trait Pluggable { fn get_ref<P: Plugin<Self>>(&mut self) -> Option<P::Error> { None } } struct Foo; impl Plugin<Foo> for Params { type Error = (); } impl<T: Copy> Pluggable for T {} fn handle(req: &mut i32) { req.get_ref::<Params>(); //~^ ERROR the trait bound `Params: Plugin<i32>` is not satisfied } fn main() {} </ins>