---

yaml
---
r: 155130
b: refs/heads/try2
c: 688ddf7
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 088c94ae96aa139db6b6f0c5640c720ff107ee0f
+refs/heads/try2: 688ddf79156aa01a2507412c9b766f48ef208b04
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/middle/kind.rs

@@ -5423,7 +5423,7 @@ impl BorrowKind {
          * Returns a mutability `m` such that an `&m T` pointer could
          * be used to obtain this borrow kind. Because borrow kinds
          * are richer than mutabilities, we sometimes have to pick a
-         * mutability that is stornger than necessary so that it at
+         * mutability that is stronger than necessary so that it at
          * least *would permit* the borrow in question.
          */
 

branches/try2/src/librustc/middle/ty.rs

@@ -555,11 +555,9 @@ pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) {
                             None);
                 match tcx.def_map.borrow().find(&pat.id) {
                     Some(def) => {
-                        let item_type = ty::lookup_item_type(tcx, def.def_id());
-                        let substitutions = fcx.infcx().fresh_substs_for_type(
-                            pat.span, &item_type.generics);
+                        let struct_ty = fcx.instantiate_item_type(pat.span, def.def_id());
                         check_struct_pat(pcx, pat.span, fields.as_slice(),
-                                         etc, def.def_id(), &substitutions);
+                                         etc, def.def_id(), &struct_ty.substs);
                     }
                     None => {
                         tcx.sess.span_bug(pat.span,

branches/try2/src/librustc/middle/typeck/check/_match.rs

@@ -82,6 +82,7 @@ obtained the type `Foo`, we would never match this method.
 
 use middle::subst;
 use middle::subst::Subst;
+use middle::traits;
 use middle::ty::*;
 use middle::ty;
 use middle::typeck::astconv::AstConv;
@@ -91,7 +92,6 @@ use middle::typeck::infer;
 use middle::typeck::MethodCallee;
 use middle::typeck::{MethodOrigin, MethodParam};
 use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure, MethodObject};
-use middle::typeck::{param_index};
 use middle::typeck::check::regionmanip::replace_late_bound_regions_in_fn_sig;
 use middle::typeck::TypeAndSubsts;
 use util::common::indenter;
@@ -538,14 +538,12 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
             return
         }
 
-        let vcx = self.fcx.vtable_context();
-
         // Get the tupled type of the arguments.
         let arguments_type = *closure_function_type.sig.inputs.get(0);
         let return_type = closure_function_type.sig.output;
 
         let closure_region =
-            vcx.infcx.next_region_var(infer::MiscVariable(self.span));
+            self.fcx.infcx().next_region_var(infer::MiscVariable(self.span));
         let unboxed_closure_type = ty::mk_unboxed_closure(self.tcx(),
                                                           closure_did,
                                                           closure_region);
@@ -555,7 +553,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
             rcvr_substs: subst::Substs::new_trait(
                 vec![arguments_type, return_type],
                 vec![],
-                *vcx.infcx.next_ty_vars(1).get(0)),
+                *self.fcx.infcx().next_ty_vars(1).get(0)),
             method_ty: method,
             origin: MethodStaticUnboxedClosure(closure_did),
         });
@@ -618,7 +616,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
         self.push_inherent_candidates_from_bounds_inner(
             &[trait_ref.clone()],
-            |_this, new_trait_ref, m, method_num, _bound_num| {
+            |_this, new_trait_ref, m, method_num| {
                 let vtable_index =
                     get_method_index(tcx, &*new_trait_ref,
                                      trait_ref.clone(), method_num);
@@ -633,7 +631,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                     rcvr_substs: new_trait_ref.substs.clone(),
                     method_ty: Rc::new(m),
                     origin: MethodObject(MethodObject {
-                        trait_id: new_trait_ref.def_id,
+                        trait_ref: new_trait_ref,
                         object_trait_id: did,
                         method_num: method_num,
                         real_index: vtable_index
@@ -652,22 +650,20 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
             rcvr_ty,
             param_ty.space,
             param_ty.idx,
-            restrict_to,
-            param_index { space: param_ty.space, index: param_ty.idx });
+            restrict_to);
     }
 
 
     fn push_inherent_candidates_from_bounds(&mut self,
                                             self_ty: ty::t,
                                             space: subst::ParamSpace,
                                             index: uint,
-                                            restrict_to: Option<DefId>,
-                                            param: param_index) {
+                                            restrict_to: Option<DefId>) {
         let bounds =
             self.fcx.inh.param_env.bounds.get(space, index).trait_bounds
             .as_slice();
         self.push_inherent_candidates_from_bounds_inner(bounds,
-            |this, trait_ref, m, method_num, bound_num| {
+            |this, trait_ref, m, method_num| {
                 match restrict_to {
                     Some(trait_did) => {
                         if trait_did != trait_ref.def_id {
@@ -701,10 +697,8 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                     rcvr_substs: trait_ref.substs.clone(),
                     method_ty: m,
                     origin: MethodParam(MethodParam {
-                        trait_id: trait_ref.def_id,
+                        trait_ref: trait_ref,
                         method_num: method_num,
-                        param_num: param,
-                        bound_num: bound_num,
                     })
                 })
         })
@@ -718,15 +712,16 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
         mk_cand: |this: &mut LookupContext,
                   tr: Rc<TraitRef>,
                   m: Rc<ty::Method>,
-                  method_num: uint,
-                  bound_num: uint|
-                  -> Option<Candidate>) {
+                  method_num: uint|
+                  -> Option<Candidate>)
+    {
         let tcx = self.tcx();
-        let mut next_bound_idx = 0; // count only trait bounds
-
-        ty::each_bound_trait_and_supertraits(tcx, bounds, |bound_trait_ref| {
-            let this_bound_idx = next_bound_idx;
-            next_bound_idx += 1;
+        let mut cache = HashSet::new();
+        for bound_trait_ref in traits::transitive_bounds(tcx, bounds) {
+            // Already visited this trait, skip it.
+            if !cache.insert(bound_trait_ref.def_id) {
+                continue;
+            }
 
             let trait_items = ty::trait_items(tcx, bound_trait_ref.def_id);
             match trait_items.iter().position(|ti| {
@@ -745,8 +740,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                     match mk_cand(self,
                                   bound_trait_ref,
                                   method,
-                                  pos,
-                                  this_bound_idx) {
+                                  pos) {
                         Some(cand) => {
                             debug!("pushing inherent candidate for param: {}",
                                    cand.repr(self.tcx()));
@@ -761,8 +755,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                     // check next trait or bound
                 }
             }
-            true
-        });
+        }
     }
 
 
@@ -773,7 +766,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
         let impl_items = self.tcx().impl_items.borrow();
         for impl_infos in self.tcx().inherent_impls.borrow().find(&did).iter() {
-            for impl_did in impl_infos.borrow().iter() {
+            for impl_did in impl_infos.iter() {
                 let items = impl_items.get(impl_did);
                 self.push_candidates_from_impl(*impl_did,
                                                items.as_slice(),
@@ -825,11 +818,10 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
         // determine the `self` of the impl with fresh
         // variables for each parameter:
         let span = self.self_expr.map_or(self.span, |e| e.span);
-        let vcx = self.fcx.vtable_context();
         let TypeAndSubsts {
             substs: impl_substs,
             ty: impl_ty
-        } = impl_self_ty(&vcx, span, impl_did);
+        } = impl_self_ty(self.fcx, span, impl_did);
 
         let condition = match method.explicit_self {
             ByReferenceExplicitSelfCategory(_, mt) if mt == MutMutable =>
@@ -877,7 +869,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                        adjustment {:?} for {}", adjustment, self.ty_to_string(self_ty));
                 match adjustment {
                     Some((self_expr_id, adj)) => {
-                        self.fcx.write_adjustment(self_expr_id, adj);
+                        self.fcx.write_adjustment(self_expr_id, self.span, adj);
                     }
                     None => {}
                 }
@@ -1109,7 +1101,9 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
             ty_err => None,
 
-            ty_infer(TyVar(_)) => {
+            ty_infer(TyVar(_)) |
+            ty_infer(SkolemizedTy(_)) |
+            ty_infer(SkolemizedIntTy(_)) => {
                 self.bug(format!("unexpected type: {}",
                                  self.ty_to_string(self_ty)).as_slice());
             }
@@ -1150,6 +1144,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                         Some(self_expr_id) => {
                             self.fcx.write_adjustment(
                                 self_expr_id,
+                                self.span,
                                 ty::AutoDerefRef(ty::AutoDerefRef {
                                     autoderefs: autoderefs,
                                     autoref: Some(kind(region, *mutbl))
@@ -1209,7 +1204,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
             // return something so we don't get errors for every mutability
             return Some(MethodCallee {
-                origin: relevant_candidates.get(0).origin,
+                origin: relevant_candidates.get(0).origin.clone(),
                 ty: ty::mk_err(),
                 substs: subst::Substs::empty()
             });
@@ -1237,12 +1232,14 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                        candidate_b.repr(self.tcx()));
                 match (&candidate_a.origin, &candidate_b.origin) {
                     (&MethodParam(ref p1), &MethodParam(ref p2)) => {
-                        let same_trait = p1.trait_id == p2.trait_id;
-                        let same_method = p1.method_num == p2.method_num;
-                        let same_param = p1.param_num == p2.param_num;
-                        // The bound number may be different because
-                        // multiple bounds may lead to the same trait
-                        // impl
+                        let same_trait =
+                            p1.trait_ref.def_id == p2.trait_ref.def_id;
+                        let same_method =
+                            p1.method_num == p2.method_num;
+                        // it's ok to compare self-ty with `==` here because
+                        // they are always a TyParam
+                        let same_param =
+                            p1.trait_ref.self_ty() == p2.trait_ref.self_ty();
                         same_trait && same_method && same_param
                     }
                     _ => false
@@ -1369,13 +1366,13 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
             }
         }
 
-        self.fcx.add_region_obligations_for_parameters(
-            self.span,
+        self.fcx.add_obligations_for_parameters(
+            traits::ObligationCause::misc(self.span),
             &all_substs,
             &candidate.method_ty.generics);
 
         MethodCallee {
-            origin: candidate.origin,
+            origin: candidate.origin.clone(),
             ty: fty,
             substs: all_substs
         }
@@ -1452,10 +1449,10 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
             MethodStaticUnboxedClosure(_) => bad = false,
             // FIXME: does this properly enforce this on everything now
             // that self has been merged in? -sully
-            MethodParam(MethodParam { trait_id: trait_id, .. }) |
-            MethodObject(MethodObject { trait_id: trait_id, .. }) => {
+            MethodParam(MethodParam { trait_ref: ref trait_ref, .. }) |
+            MethodObject(MethodObject { trait_ref: ref trait_ref, .. }) => {
                 bad = self.tcx().destructor_for_type.borrow()
-                          .contains_key(&trait_id);
+                          .contains_key(&trait_ref.def_id);
             }
         }
 
@@ -1602,10 +1599,10 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                 self.report_static_candidate(idx, did)
             }
             MethodParam(ref mp) => {
-                self.report_param_candidate(idx, (*mp).trait_id)
+                self.report_param_candidate(idx, mp.trait_ref.def_id)
             }
             MethodObject(ref mo) => {
-                self.report_trait_candidate(idx, mo.trait_id)
+                self.report_trait_candidate(idx, mo.trait_ref.def_id)
             }
         }
     }