---

yaml
---
r: 6923
b: refs/heads/master
c: 0490c36
h: refs/heads/master
i:
  6921: 810f878
  6919: 51d1753
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 8b580954fe140dd45db61d719a49065c3e31de95
+refs/heads/master: 0490c36143a525d3e17598531e47eab06381ae84

trunk/src/cargo/cargo.rs

@@ -203,7 +203,7 @@ fn try_parse_sources(filename: str, sources: map::hashmap<str, source>) {
         some(json::dict(_j)) {
             _j.items { |k, v|
                 sources.insert(k, parse_source(k, v));
-                #debug("source: %s", k);
+                log #fmt["source: %s", k];
             }
         }
         _ { fail "malformed sources.json"; }
@@ -269,11 +269,11 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
         ref: ref,
         tags: tags
     });
-    log_full(core::debug, "  Loaded package: " + src.name + "/" + name);
+    log "  Loaded package: " + src.name + "/" + name;
 }
 
 fn load_source_packages(&c: cargo, &src: source) {
-    log_full(core::debug, "Loading source: " + src.name);
+    log "Loading source: " + src.name;
     let dir = fs::connect(c.sourcedir, src.name);
     let pkgfile = fs::connect(dir, "packages.json");
     if !fs::path_exists(pkgfile) { ret; }
@@ -356,7 +356,7 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
     if ri != -1 {
         name = str::slice(name, 0u, ri as uint);
     }
-    #debug("Installing: %s", name);
+    log #fmt["Installing: %s", name];
     let old = fs::list_dir(".");
     let p = run::program_output("rustc", [name + ".rc"]);
     if p.status != 0 {
@@ -370,22 +370,22 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
     for ct: str in created {
         if (exec_suffix != "" && str::ends_with(ct, exec_suffix)) ||
             (exec_suffix == "" && !str::starts_with(ct, "./lib")) {
-            #debug("  bin: %s", ct);
+            log #fmt["  bin: %s", ct];
             // FIXME: need libstd fs::copy or something
             run::run_program("cp", [ct, c.bindir]);
         } else {
-            #debug("  lib: %s", ct);
+            log #fmt["  lib: %s", ct];
             run::run_program("cp", [ct, c.libdir]);
         }
     }
 }
 
 fn install_source(c: cargo, path: str) {
-    #debug("source: %s", path);
+    log #fmt["source: %s", path];
     fs::change_dir(path);
     let contents = fs::list_dir(".");
 
-    #debug("contents: %s", str::connect(contents, ", "));
+    log #fmt["contents: %s", str::connect(contents, ", ")];
 
     let cratefiles =
         vec::filter::<str>(contents, { |n| str::ends_with(n, ".rc") });

trunk/src/comp/back/link.rs

@@ -588,15 +588,15 @@ fn link_binary(sess: session::session,
         let long_libname =
             std::os::dylib_filename(#fmt("%s-%s-%s",
                                          lm.name, lm.extras_hash, lm.vers));
-        #debug("link_meta.name:  %s", lm.name);
-        #debug("long_libname: %s", long_libname);
-        #debug("out_filename: %s", out_filename);
-        #debug("dirname(out_filename): %s", fs::dirname(out_filename));
+        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_full(core::debug, "output: " + output);
+    log "output: " + output;
 
     // The default library location, we need this to find the runtime.
     // The location of crates will be determined as needed.
@@ -670,7 +670,7 @@ fn link_binary(sess: session::session,
 
     gcc_args += rpath::get_rpath_flags(sess, output);
 
-    #debug("gcc link args: %s", str::connect(gcc_args, " "));
+    log #fmt("gcc link args: %s", str::connect(gcc_args, " "));
     // We run 'gcc' here
     let prog = run::program_output(prog, gcc_args);
     if 0 != prog.status {

trunk/src/comp/back/rpath.rs

@@ -21,7 +21,7 @@ fn get_rpath_flags(sess: session::session, out_filename: str) -> [str] {
         ret [];
     }
 
-    #debug("preparing the RPATH!");
+    log "preparing the RPATH!";
 
     let cwd = os::getcwd();
     let sysroot = sess.filesearch().sysroot();
@@ -52,14 +52,14 @@ fn rpaths_to_flags(rpaths: [str]) -> [str] {
 fn get_rpaths(os: session::os, cwd: fs::path, sysroot: fs::path,
               output: fs::path, libs: [fs::path],
               target_triple: str) -> [str] {
-    #debug("cwd: %s", cwd);
-    #debug("sysroot: %s", sysroot);
-    #debug("output: %s", output);
-    #debug("libs:");
+    log #fmt("cwd: %s", cwd);
+    log #fmt("sysroot: %s", sysroot);
+    log #fmt("output: %s", output);
+    log #fmt("libs:");
     for libpath in libs {
-        #debug("    %s", libpath);
+        log #fmt("    %s", libpath);
     }
-    #debug("target_triple: %s", target_triple);
+    log #fmt("target_triple: %s", target_triple);
 
     // Use relative paths to the libraries. Binaries can be moved
     // as long as they maintain the relative relationship to the
@@ -74,9 +74,9 @@ fn get_rpaths(os: session::os, cwd: fs::path, sysroot: fs::path,
     let fallback_rpaths = [get_install_prefix_rpath(cwd, target_triple)];
 
     fn log_rpaths(desc: str, rpaths: [str]) {
-        #debug("%s rpaths:", desc);
+        log #fmt("%s rpaths:", desc);
         for rpath in rpaths {
-            #debug("    %s", rpath);
+            log #fmt("    %s", rpath);
         }
     }
 

trunk/src/comp/front/attr.rs

@@ -34,7 +34,7 @@ fn find_linkage_metas(attrs: [ast::attribute]) -> [@ast::meta_item] {
     for attr: ast::attribute in find_attrs_by_name(attrs, "link") {
         alt attr.node.value.node {
           ast::meta_list(_, items) { metas += items; }
-          _ { #debug("ignoring link attribute that has incorrect type"); }
+          _ { log "ignoring link attribute that has incorrect type"; }
         }
     }
     ret metas;
@@ -140,9 +140,9 @@ fn contains(haystack: [@ast::meta_item], needle: @ast::meta_item) -> bool {
     for item: @ast::meta_item in haystack {
         log #fmt["looking in %s",
                  syntax::print::pprust::meta_item_to_str(*item)];
-        if eq(item, needle) { #debug("found it!"); ret true; }
+        if eq(item, needle) { log "found it!"; ret true; }
     }
-    #debug("found it not :(");
+    log "found it not :(";
     ret false;
 }
 

trunk/src/comp/front/test.rs

@@ -51,7 +51,7 @@ fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     // we want to be main.
     fn nomain(&&item: @ast::item) -> option::t<@ast::item> {
         alt item.node {
-          ast::item_fn(f, _) {
+          ast::item_fn(_, _, _) {
             if item.ident == "main" {
                 option::none
             } else { option::some(item) }
@@ -79,22 +79,22 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) ->
    @ast::item {
 
     cx.path += [i.ident];
-    #debug("current path: %s", ast_util::path_name_i(cx.path));
+    log #fmt["current path: %s", ast_util::path_name_i(cx.path)];
 
     if is_test_fn(i) {
         alt i.node {
-          ast::item_fn(f, _) when f.decl.purity == ast::unsafe_fn {
+          ast::item_fn(decl, _, _) when decl.purity == ast::unsafe_fn {
             cx.sess.span_fatal(
                 i.span,
                 "unsafe functions cannot be used for tests");
           }
           _ {
-            #debug("this is a test function");
+            log "this is a test function";
             let test = {span: i.span,
                         path: cx.path, ignore: is_ignored(cx, i),
                         should_fail: should_fail(i)};
             cx.testfns += [test];
-            #debug("have %u test functions", vec::len(cx.testfns));
+            log #fmt["have %u test functions", vec::len(cx.testfns)];
           }
         }
     }
@@ -110,9 +110,9 @@ fn is_test_fn(i: @ast::item) -> bool {
 
     fn has_test_signature(i: @ast::item) -> bool {
         alt i.node {
-          ast::item_fn(f, tps) {
-            let input_cnt = vec::len(f.decl.inputs);
-            let no_output = f.decl.output.node == ast::ty_nil;
+          ast::item_fn(decl, tps, _) {
+            let input_cnt = vec::len(decl.inputs);
+            let no_output = decl.output.node == ast::ty_nil;
             let tparm_cnt = vec::len(tps);
             input_cnt == 0u && no_output && tparm_cnt == 0u
           }
@@ -177,7 +177,7 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item {
          node: item_,
          span: dummy_sp()};
 
-    #debug("Synthetic test module:\n%s\n", pprust::item_to_str(@item));
+    log #fmt["Synthetic test module:\n%s\n", pprust::item_to_str(@item)];
 
     ret @item;
 }
@@ -190,13 +190,12 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
     let ret_ty = mk_test_desc_vec_ty(cx);
 
     let decl: ast::fn_decl =
-        {inputs: [],
+        {proto: ast::proto_bare,
+         inputs: [],
          output: ret_ty,
          purity: ast::impure_fn,
-         il: ast::il_normal,
          cf: ast::return_val,
          constraints: []};
-    let proto = ast::proto_bare;
 
     // The vector of test_descs for this crate
     let test_descs = mk_test_desc_vec(cx);
@@ -205,9 +204,7 @@ fn mk_tests(cx: test_ctxt) -> @ast::item {
         default_block([], option::some(test_descs), cx.sess.next_node_id());
     let body = nospan(body_);
 
-    let fn_ = {decl: decl, proto: proto, body: body};
-
-    let item_ = ast::item_fn(fn_, []);
+    let item_ = ast::item_fn(decl, [], body);
     let item: ast::item =
         {ident: "tests",
          attrs: [],
@@ -242,7 +239,7 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
 }
 
 fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr {
-    #debug("building test vector from %u tests", vec::len(cx.testfns));
+    log #fmt["building test vector from %u tests", vec::len(cx.testfns)];
     let descs = [];
     for test: test in cx.testfns {
         let test_ = test; // Satisfy alias analysis
@@ -258,7 +255,7 @@ fn mk_test_desc_rec(cx: test_ctxt, test: test) -> @ast::expr {
     let span = test.span;
     let path = test.path;
 
-    #debug("encoding %s", ast_util::path_name_i(path));
+    log #fmt["encoding %s", ast_util::path_name_i(path)];
 
     let name_lit: ast::lit =
         nospan(ast::lit_str(ast_util::path_name_i(path)));
@@ -325,10 +322,10 @@ fn mk_test_wrapper(cx: test_ctxt,
         ast::stmt_expr(@call_expr, cx.sess.next_node_id()));
 
     let wrapper_decl: ast::fn_decl = {
+        proto: ast::proto_bare,
         inputs: [],
         output: @nospan(ast::ty_nil),
         purity: ast::impure_fn,
-        il: ast::il_normal,
         cf: ast::return_val,
         constraints: []
     };
@@ -341,20 +338,14 @@ fn mk_test_wrapper(cx: test_ctxt,
         rules: ast::default_blk
     });
 
-    let wrapper_fn: ast::_fn = {
-        decl: wrapper_decl,
-        proto: ast::proto_bare,
-        body: wrapper_body
-    };
-
     let wrapper_capture: @ast::capture_clause = @{
         copies: [],
         moves: []
     };
 
     let wrapper_expr: ast::expr = {
         id: cx.sess.next_node_id(),
-        node: ast::expr_fn(wrapper_fn, wrapper_capture),
+        node: ast::expr_fn(wrapper_decl, wrapper_body, wrapper_capture),
         span: span
     };
 
@@ -375,13 +366,12 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
     let ret_ty = nospan(ast::ty_nil);
 
     let decl: ast::fn_decl =
-        {inputs: [args_arg],
+        {proto: ast::proto_bare,
+         inputs: [args_arg],
          output: @ret_ty,
          purity: ast::impure_fn,
-         il: ast::il_normal,
          cf: ast::return_val,
          constraints: []};
-    let proto = ast::proto_bare;
 
     let test_main_call_expr = mk_test_main_call(cx);
 
@@ -390,9 +380,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
                       cx.sess.next_node_id());
     let body = {node: body_, span: dummy_sp()};
 
-    let fn_ = {decl: decl, proto: proto, body: body};
-
-    let item_ = ast::item_fn(fn_, []);
+    let item_ = ast::item_fn(decl, [], body);
     let item: ast::item =
         {ident: "main",
          attrs: [],

trunk/src/comp/lib/llvm.rs

@@ -1010,7 +1010,7 @@ fn type_to_str_inner(names: type_names, outer0: [TypeRef], ty: TypeRef) ->
       12 { ret "Opaque"; }
       13 { ret "Vector"; }
       14 { ret "Metadata"; }
-      _ { #error("unknown TypeKind %d", kind as int); fail; }
+      _ { log_err #fmt["unknown TypeKind %d", kind as int]; fail; }
     }
 }
 

trunk/src/comp/metadata/common.rs

@@ -62,8 +62,6 @@ const tag_crate_deps: uint = 0x25u;
 // A single crate dependency
 const tag_crate_dep: uint = 0x26u;
 
-const tag_items_data_item_inlineness: uint = 0x27u;
-
 const tag_crate_hash: uint = 0x28u;
 
 const tag_mod_impl: uint = 0x30u;