---

yaml
---
r: 78700
b: refs/heads/try
c: b7cbd8a
h: refs/heads/master
v: v3

Author: olsonjeffery

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 25ed29a0edb3d48fef843a0b818ee68faf2252da
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 60fba4d7d677ec098e6a43014132fe99f7547363
-refs/heads/try: 23bfa600a0f91f1ea62ea3f3783c358a7cb7da45
+refs/heads/try: b7cbd8a8fd69d7a2b540e3b4f9e808810fc1ddc0
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/librustc/middle/liveness.rs

@@ -1617,7 +1617,7 @@ impl Liveness {
 
     pub fn should_warn(&self, var: Variable) -> Option<@str> {
         let name = self.ir.variable_name(var);
-        if name.len() == 0 || name[0] == ('_' as u8) { None } else { Some(name) }
+        if name[0] == ('_' as u8) { None } else { Some(name) }
     }
 
     pub fn warn_about_unused_args(&self, decl: &fn_decl, entry_ln: LiveNode) {

branches/try/src/librustc/middle/trans/meth.rs

@@ -577,23 +577,20 @@ fn emit_vtable_methods(bcx: @mut Block,
 
     let trait_method_def_ids = ty::trait_method_def_ids(tcx, trt_id);
     do trait_method_def_ids.map |method_def_id| {
-        let ident = ty::method(tcx, *method_def_id).ident;
-        // The substitutions we have are on the impl, so we grab
-        // the method type from the impl to substitute into.
-        let m_id = method_with_name(ccx, impl_id, ident);
-        let m = ty::method(tcx, m_id);
-        debug!("(making impl vtable) emitting method %s at subst %s",
-               m.repr(tcx),
-               substs.repr(tcx));
+        let im = ty::method(tcx, *method_def_id);
         let fty = ty::subst_tps(tcx,
                                 substs,
                                 None,
-                                ty::mk_bare_fn(tcx, m.fty.clone()));
-        if m.generics.has_type_params() || ty::type_has_self(fty) {
+                                ty::mk_bare_fn(tcx, im.fty.clone()));
+        if im.generics.has_type_params() || ty::type_has_self(fty) {
             debug!("(making impl vtable) method has self or type params: %s",
-                   tcx.sess.str_of(ident));
+                   tcx.sess.str_of(im.ident));
             C_null(Type::nil().ptr_to())
         } else {
+            debug!("(making impl vtable) adding method to vtable: %s",
+                   tcx.sess.str_of(im.ident));
+            let m_id = method_with_name(ccx, impl_id, im.ident);
+
             trans_fn_ref_with_vtables(bcx, m_id, 0,
                                       substs, Some(vtables)).llfn
         }

branches/try/src/librustc/middle/typeck/check/method.rs

@@ -938,18 +938,9 @@ impl<'self> LookupContext<'self> {
 
         // static methods should never have gotten this far:
         assert!(candidate.method_ty.explicit_self != sty_static);
-
-        let transformed_self_ty = match candidate.origin {
-            method_object(*) => {
-                // For annoying reasons, we've already handled the
-                // substitution for object calls.
-                candidate.method_ty.transformed_self_ty.unwrap()
-            }
-            _ => {
-                ty::subst(tcx, &candidate.rcvr_substs,
-                          candidate.method_ty.transformed_self_ty.unwrap())
-            }
-        };
+        let transformed_self_ty =
+            ty::subst(tcx, &candidate.rcvr_substs,
+                      candidate.method_ty.transformed_self_ty.unwrap());
 
         // Determine the values for the type parameters of the method.
         // If they were not explicitly supplied, just construct fresh

branches/try/src/librustc/middle/typeck/check/mod.rs

@@ -3092,6 +3092,7 @@ pub fn ty_param_bounds_and_ty_for_def(fcx: @mut FnCtxt,
                                       sp: span,
                                       defn: ast::def)
                                    -> ty_param_bounds_and_ty {
+
     match defn {
       ast::def_arg(nid, _) | ast::def_local(nid, _) | ast::def_self(nid, _) |
       ast::def_binding(nid, _) => {
@@ -3148,8 +3149,7 @@ pub fn instantiate_path(fcx: @mut FnCtxt,
     let ty_param_count = tpt.generics.type_param_defs.len();
     let ty_substs_len = pth.types.len();
 
-    debug!("tpt=%s ty_param_count=%? ty_substs_len=%?",
-           tpt.repr(fcx.tcx()),
+    debug!("ty_param_count=%? ty_substs_len=%?",
            ty_param_count,
            ty_substs_len);
 

branches/try/src/librustc/middle/typeck/collect.rs

@@ -346,10 +346,9 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt,
         let substd_type_param_defs = m.generics.type_param_defs.subst(tcx, &substs);
         new_type_param_defs.push_all(*substd_type_param_defs);
 
-        debug!("static method %s type_param_defs=%s ty=%s, substs=%s",
+        debug!("static method %s type_param_defs=%s substs=%s",
                m.def_id.repr(tcx),
                new_type_param_defs.repr(tcx),
-               ty.repr(tcx),
                substs.repr(tcx));
 
         tcx.tcache.insert(m.def_id,
@@ -894,8 +893,8 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::item) {
       }
       ast::item_trait(ref generics, _, ref trait_methods) => {
           let _trait_def = trait_def_of_item(ccx, it);
+          ensure_trait_methods(ccx, it.id);
 
-          // Run convert_methods on the provided methods.
           let (_, provided_methods) =
               split_trait_methods(*trait_methods);
           let untransformed_rcvr_ty = ty::mk_self(tcx, local_def(it.id));
@@ -905,11 +904,6 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::item) {
                                   untransformed_rcvr_ty,
                                   &ty_generics, generics,
                                   it.vis);
-
-          // We need to do this *after* converting methods, since
-          // convert_methods produces a tcache entry that is wrong for
-          // static trait methods. This is somewhat unfortunate.
-          ensure_trait_methods(ccx, it.id);
       }
       ast::item_struct(struct_def, ref generics) => {
         ensure_no_ty_param_bounds(ccx, it.span, generics, "structure");

branches/try/src/librustpkg/tests.rs

@@ -678,7 +678,6 @@ fn rustpkg_local_pkg() {
 }
 
 #[test]
-#[ignore (reason = "test makes bogus assumptions about build directory layout: issue #8690")]
 fn package_script_with_default_build() {
     let dir = create_local_package(&PkgId::new("fancy-lib"));
     debug!("dir = %s", dir.to_str());