---

yaml
---
r: 6718
b: refs/heads/master
c: a87d80f
h: refs/heads/master
v: v3

Author: Elly Jones

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: aa3d58c8c0a2e52b2893328a8d1940e5fbd41303
+refs/heads/master: a87d80f6e28f28b091f11bd55dd4c4a51b165a91

trunk/src/cargo/cargo.rs

@@ -154,12 +154,13 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
         name = str::slice(name, 0u, ri as uint);
     }
     log #fmt["Installing: %s", name];
-    let old = fs::list_dir(".");
-    run::run_program("rustc", [cf]);
-    let new = fs::list_dir(".");
+    let old = vec::map({|x| str::slice(x, 2u, str::byte_len(x))}, fs::list_dir("."));
+    run::run_program("rustc", [name + ".rc"]);
+    let new = vec::map({|x| str::slice(x, 2u, str::byte_len(x))}, fs::list_dir("."));
     let created = vec::filter::<str>({ |n| !vec::member::<str>(n, old) }, new);
     for ct: str in created {
-        if str::ends_with(ct, os::exec_suffix()) {
+        if (os::exec_suffix() != "" && str::ends_with(ct, os::exec_suffix())) ||
+           (os::exec_suffix() == "" && !str::starts_with(ct, "lib")) {
             log #fmt["  bin: %s", ct];
             // FIXME: need libstd fs::copy or something
             run::run_program("cp", [ct, c.bindir]);

trunk/src/comp/back/abi.rs

@@ -73,8 +73,9 @@ const fn_field_code: int = 0;
 const fn_field_box: int = 1;
 
 const closure_elt_tydesc: int = 0;
-const closure_elt_ty_params: int = 1;
-const closure_elt_bindings: int = 2;
+const closure_elt_bindings: int = 1;
+//const closure_elt_n_ty_params: int = 2;
+const closure_elt_ty_params: int = 2; // 3;
 
 const vec_elt_fill: int = 0;
 

trunk/src/comp/back/link.rs

@@ -588,16 +588,9 @@ fn link_binary(sess: session::session,
         let long_libname =
             std::os::dylib_filename(#fmt("%s-%s-%s",
                                          lm.name, lm.extras_hash, lm.vers));
-        log "link_meta.name: " + lm.name;
-        log "long_libname: " + long_libname;
-        log "out_filename: " + out_filename;
-        log "dirname(out_filename): " + fs::dirname(out_filename);
-
         fs::connect(fs::dirname(out_filename), long_libname)
     } else { out_filename };
 
-    log "output: " + output;
-
     // The default library location, we need this to find the runtime.
     // The location of crates will be determined as needed.
     let stage: str = "-L" + sess.filesearch().get_target_lib_path();

trunk/src/comp/back/upcall.rs

@@ -17,8 +17,7 @@ type upcalls =
      shared_malloc: ValueRef,
      shared_free: ValueRef,
      mark: ValueRef,
-     create_shared_type_desc: ValueRef,
-     free_shared_type_desc: ValueRef,
+     clone_type_desc: ValueRef,
      get_type_desc: ValueRef,
      vec_grow: ValueRef,
      vec_push: ValueRef,
@@ -65,11 +64,9 @@ fn declare_upcalls(targ_cfg: @session::config,
               dv("shared_free", [T_ptr(T_i8())]),
           mark:
               d("mark", [T_ptr(T_i8())], int_t),
-          create_shared_type_desc:
-              d("create_shared_type_desc", [T_ptr(tydesc_type)],
+          clone_type_desc:
+              d("clone_type_desc", [T_ptr(tydesc_type)],
                 T_ptr(tydesc_type)),
-          free_shared_type_desc:
-              dv("free_shared_type_desc", [T_ptr(tydesc_type)]),
           get_type_desc:
               d("get_type_desc",
                 [T_ptr(T_nil()), size_t,

trunk/src/comp/driver/rustc.rs

@@ -561,10 +561,7 @@ fn build_output_filenames(ifile: str, ofile: option::t<str>,
         obj_filename = base_filename + "." + suffix;
 
         if sess.building_library() {
-            let dirname = fs::dirname(base_filename);
-            let basename = fs::basename(base_filename);
-            let dylibname = std::os::dylib_filename(basename);
-            saved_out_filename = fs::connect(dirname, dylibname);
+            saved_out_filename = std::os::dylib_filename(base_filename);
         } else {
             saved_out_filename = base_filename;
         }

trunk/src/comp/middle/shape.rs

@@ -51,7 +51,6 @@ const shape_obj: u8 = 19u8;
 const shape_res: u8 = 20u8;
 const shape_var: u8 = 21u8;
 const shape_uniq: u8 = 22u8;
-const shape_opaque_closure: u8 = 23u8; // the closure itself.
 
 // FIXME: This is a bad API in trans_common.
 fn C_u8(n: u8) -> ValueRef { ret trans_common::C_u8(n as uint); }
@@ -385,6 +384,9 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint],
         }
         add_substr(s, sub);
       }
+      ty::ty_fn(_, _, _, _, _) {
+        s += [shape_fn];
+      }
       ty::ty_native_fn(_, _) { s += [shape_u32]; }
       ty::ty_obj(_) { s += [shape_obj]; }
       ty::ty_res(did, raw_subt, tps) {
@@ -410,18 +412,19 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint],
             s += [shape_var, n as u8];
         } else {
             // Find the type parameter in the parameter list.
-            alt vec::position(n, ty_param_map) {
-              some(i) { s += [shape_var, i as u8]; }
-              none. { fail "ty param not found in ty_param_map"; }
+            let found = false;
+            let i = 0u;
+            while i < vec::len(ty_param_map) {
+                if n == ty_param_map[i] {
+                    s += [shape_var, i as u8];
+                    found = true;
+                    break;
+                }
+                i += 1u;
             }
+            assert (found);
         }
       }
-      ty::ty_fn(_, _, _, _, _) {
-        s += [shape_fn];
-      }
-      ty::ty_opaque_closure. {
-        s += [shape_opaque_closure];
-      }
     }
 
     ret s;