typeck/kind -- stop using old trait framework.

- Unify the "well-formedness" checking that typeck was already doing with what
  was taking place in kind.
- Move requirements that things be sized into typeck.
- I left the checking on upvars in kind, though I think it should eventually be
  refactored into regionck (which would perhaps be renamed).

This reflects a general plan to convert typeck so that it registers
obligations or other pending things for conditions it cannot check
eventually. This makes it easier to identify all the conditions that
apply to an AST expression, but can also influence inference in somec
cases (e.g., `Send` implies `'static`, so I already had to promote a lot
of the checking that `kind.rs` was doing into typeck, this branch just
continues the process).

Author: nikomatsakis

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.
          */
 

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,

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)
             }
         }
     }