---

yaml
---
r: 79402
b: refs/heads/snap-stage3
c: c7352e6
h: refs/heads/master
v: v3

Author: pnkfelix

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 124eb2119c78651cfaaa7a046a101fa2e20f83ca
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 3c3ae1d0e26c9ae0906dc57daa14bb9e4627e3c8
+refs/heads/snap-stage3: c7352e6403331b0464d1b1e1ccfc9a0f7b67e50b
 refs/heads/try: ac820906c0e53eab79a98ee64f7231f57c3887b4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/rt.mk

@@ -76,6 +76,7 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \
               rt/rust_crate_map.cpp \
+              rt/rust_log.cpp \
               rt/isaac/randport.cpp \
               rt/miniz.cpp \
               rt/memory_region.cpp \

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -307,9 +307,8 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
     // Try to elide redundant long paths
     fn shorten(path: &Path) -> ~str {
         let filename = path.filename();
-        let p = path.pop();
-        let dir = p.filename();
-        fmt!("%s/%s", dir.unwrap_or_default(""), filename.unwrap_or_default(""))
+        let dir = path.pop().filename();
+        fmt!("%s/%s", dir.unwrap_or_default(~""), filename.unwrap_or_default(~""))
     }
 
     test::DynTestName(fmt!("[%s] %s",

branches/snap-stage3/src/compiletest/runtest.rs

@@ -880,7 +880,7 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
     let dirs = os::list_dir_path(&Path(tstr));
     for file in dirs.iter() {
 
-        if (file.filetype() == Some(".so")) {
+        if (file.filetype() == Some(~".so")) {
 
             let copy_result = procsrv::run("", config.adb_path,
                 [~"push", file.to_str(), config.adb_test_dir.clone()],

branches/snap-stage3/src/libextra/ebml.rs

@@ -410,7 +410,7 @@ pub mod reader {
         }
 
         fn read_bool(&mut self) -> bool {
-            doc_as_u8(self.next_doc(EsBool)) != 0
+            doc_as_u8(self.next_doc(EsBool)) as bool
         }
 
         fn read_f64(&mut self) -> f64 {

branches/snap-stage3/src/librust/rust.rs

@@ -162,8 +162,7 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
 fn cmd_test(args: &[~str]) -> ValidUsage {
     match args {
         [ref filename] => {
-            let p = Path(*filename);
-            let test_exec = p.filestem().unwrap() + "test~";
+            let test_exec = Path(*filename).filestem().unwrap() + "test~";
             invoke("rustc", &[~"--test", filename.to_owned(),
                               ~"-o", test_exec.to_owned()], rustc::main_args);
             let exit_code = run::process_status(~"./" + test_exec, []);
@@ -176,8 +175,7 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
 fn cmd_run(args: &[~str]) -> ValidUsage {
     match args {
         [ref filename, ..prog_args] => {
-            let p = Path(*filename);
-            let exec = p.filestem().unwrap() + "~";
+            let exec = Path(*filename).filestem().unwrap() + "~";
             invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
                    rustc::main_args);
             let exit_code = run::process_status(~"./"+exec, prog_args);

branches/snap-stage3/src/librustc/back/link.rs

@@ -35,7 +35,7 @@ use std::run;
 use std::str;
 use std::vec;
 use syntax::ast;
-use syntax::ast_map::{path, path_mod, path_name, path_pretty_name};
+use syntax::ast_map::{path, path_mod, path_name};
 use syntax::attr;
 use syntax::attr::{AttrMetaMethods};
 use syntax::print::pprust;
@@ -667,7 +667,8 @@ pub fn truncated_hash_result(symbol_hasher: &mut hash::State) -> ~str {
 pub fn symbol_hash(tcx: ty::ctxt,
                    symbol_hasher: &mut hash::State,
                    t: ty::t,
-                   link_meta: LinkMeta) -> @str {
+                   link_meta: LinkMeta)
+                   -> @str {
     // NB: do *not* use abbrevs here as we want the symbol names
     // to be independent of one another in the crate.
 
@@ -722,7 +723,7 @@ pub fn sanitize(s: &str) -> ~str {
             'a' .. 'z'
             | 'A' .. 'Z'
             | '0' .. '9'
-            | '_' | '.' => result.push_char(c),
+            | '_' => result.push_char(c),
 
             _ => {
                 let mut tstr = ~"";
@@ -743,65 +744,19 @@ pub fn sanitize(s: &str) -> ~str {
     return result;
 }
 
-pub fn mangle(sess: Session, ss: path,
-              hash: Option<&str>, vers: Option<&str>) -> ~str {
-    // Follow C++ namespace-mangling style, see
-    // http://en.wikipedia.org/wiki/Name_mangling for more info.
-    //
-    // It turns out that on OSX you can actually have arbitrary symbols in
-    // function names (at least when given to LLVM), but this is not possible
-    // when using unix's linker. Perhaps one day when we just a linker from LLVM
-    // we won't need to do this name mangling. The problem with name mangling is
-    // that it seriously limits the available characters. For example we can't
-    // have things like @T or ~[T] in symbol names when one would theoretically
-    // want them for things like impls of traits on that type.
-    //
-    // To be able to work on all platforms and get *some* reasonable output, we
-    // use C++ name-mangling.
-
-    let mut n = ~"_ZN"; // _Z == Begin name-sequence, N == nested
-
-    let push = |s: &str| {
-        let sani = sanitize(s);
-        n.push_str(fmt!("%u%s", sani.len(), sani));
-    };
+pub fn mangle(sess: Session, ss: path) -> ~str {
+    // Follow C++ namespace-mangling style
 
-    // First, connect each component with <len, name> pairs.
-    for s in ss.iter() {
-        match *s {
-            path_name(s) | path_mod(s) | path_pretty_name(s, _) => {
-                push(sess.str_of(s))
-            }
-        }
-    }
+    let mut n = ~"_ZN"; // Begin name-sequence.
 
-    // next, if any identifiers are "pretty" and need extra information tacked
-    // on, then use the hash to generate two unique characters. For now
-    // hopefully 2 characters is enough to avoid collisions.
-    static EXTRA_CHARS: &'static str =
-        "abcdefghijklmnopqrstuvwxyz\
-         ABCDEFGHIJKLMNOPQRSTUVWXYZ\
-         0123456789";
-    let mut hash = match hash { Some(s) => s.to_owned(), None => ~"" };
     for s in ss.iter() {
         match *s {
-            path_pretty_name(_, extra) => {
-                let hi = (extra >> 32) as u32 as uint;
-                let lo = extra as u32 as uint;
-                hash.push_char(EXTRA_CHARS[hi % EXTRA_CHARS.len()] as char);
-                hash.push_char(EXTRA_CHARS[lo % EXTRA_CHARS.len()] as char);
+            path_name(s) | path_mod(s) => {
+                let sani = sanitize(sess.str_of(s));
+                n.push_str(fmt!("%u%s", sani.len(), sani));
             }
-            _ => {}
         }
     }
-    if hash.len() > 0 {
-        push(hash);
-    }
-    match vers {
-        Some(s) => push(s),
-        None => {}
-    }
-
     n.push_char('E'); // End name-sequence.
     n
 }
@@ -810,15 +765,10 @@ pub fn exported_name(sess: Session,
                      path: path,
                      hash: &str,
                      vers: &str) -> ~str {
-    // The version will get mangled to have a leading '_', but it makes more
-    // sense to lead with a 'v' b/c this is a version...
-    let vers = if vers.len() > 0 && !char::is_XID_start(vers.char_at(0)) {
-        "v" + vers
-    } else {
-        vers.to_owned()
-    };
-
-    mangle(sess, path, Some(hash), Some(vers.as_slice()))
+    mangle(sess,
+           vec::append_one(
+               vec::append_one(path, path_name(sess.ident_of(hash))),
+               path_name(sess.ident_of(vers))))
 }
 
 pub fn mangle_exported_name(ccx: &mut CrateContext,
@@ -836,33 +786,31 @@ pub fn mangle_internal_name_by_type_only(ccx: &mut CrateContext,
     let s = ppaux::ty_to_short_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
     return mangle(ccx.sess,
-                  ~[path_name(ccx.sess.ident_of(name)),
-                    path_name(ccx.sess.ident_of(s))],
-                  Some(hash.as_slice()),
-                  None);
+        ~[path_name(ccx.sess.ident_of(name)),
+          path_name(ccx.sess.ident_of(s)),
+          path_name(ccx.sess.ident_of(hash))]);
 }
 
 pub fn mangle_internal_name_by_type_and_seq(ccx: &mut CrateContext,
-                                            t: ty::t,
-                                            name: &str) -> ~str {
+                                         t: ty::t,
+                                         name: &str) -> ~str {
     let s = ppaux::ty_to_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
     return mangle(ccx.sess,
-                  ~[path_name(ccx.sess.ident_of(s)),
-                    path_name(gensym_name(name))],
-                  Some(hash.as_slice()),
-                  None);
+        ~[path_name(ccx.sess.ident_of(s)),
+          path_name(ccx.sess.ident_of(hash)),
+          path_name(gensym_name(name))]);
 }
 
 pub fn mangle_internal_name_by_path_and_seq(ccx: &mut CrateContext,
                                             mut path: path,
                                             flav: &str) -> ~str {
     path.push(path_name(gensym_name(flav)));
-    mangle(ccx.sess, path, None, None)
+    mangle(ccx.sess, path)
 }
 
 pub fn mangle_internal_name_by_path(ccx: &mut CrateContext, path: path) -> ~str {
-    mangle(ccx.sess, path, None, None)
+    mangle(ccx.sess, path)
 }
 
 pub fn mangle_internal_name_by_seq(_ccx: &mut CrateContext, flav: &str) -> ~str {
@@ -1004,13 +952,13 @@ pub fn link_args(sess: Session,
     let cstore = sess.cstore;
     let r = cstore::get_used_crate_files(cstore);
     for cratepath in r.iter() {
-        if cratepath.filetype() == Some(".rlib") {
+        if cratepath.filetype() == Some(~".rlib") {
             args.push(cratepath.to_str());
             loop;
         }
         let dir = cratepath.dirname();
         if dir != ~"" { args.push(~"-L" + dir); }
-        let libarg = unlib(sess.targ_cfg, cratepath.filestem().unwrap().to_owned());
+        let libarg = unlib(sess.targ_cfg, cratepath.filestem().unwrap());
         args.push(~"-l" + libarg);
     }
 

branches/snap-stage3/src/librustc/metadata/common.rs

@@ -188,10 +188,6 @@ pub static tag_impls_impl: uint = 0x84;
 pub static tag_items_data_item_inherent_impl: uint = 0x85;
 pub static tag_items_data_item_extension_impl: uint = 0x86;
 
-pub static tag_path_elt_pretty_name: uint = 0x87;
-pub static tag_path_elt_pretty_name_ident: uint = 0x88;
-pub static tag_path_elt_pretty_name_extra: uint = 0x89;
-
 pub struct LinkMeta {
     name: @str,
     vers: @str,

branches/snap-stage3/src/librustc/metadata/decoder.rs

@@ -303,15 +303,6 @@ fn item_path(item_doc: ebml::Doc) -> ast_map::path {
         } else if tag == tag_path_elt_name {
             let str = elt_doc.as_str_slice();
             result.push(ast_map::path_name(token::str_to_ident(str)));
-        } else if tag == tag_path_elt_pretty_name {
-            let name_doc = reader::get_doc(elt_doc,
-                                           tag_path_elt_pretty_name_ident);
-            let extra_doc = reader::get_doc(elt_doc,
-                                            tag_path_elt_pretty_name_extra);
-            let str = name_doc.as_str_slice();
-            let extra = reader::doc_as_u64(extra_doc);
-            result.push(ast_map::path_pretty_name(token::str_to_ident(str),
-                                                  extra));
         } else {
             // ignore tag_path_len element
         }

branches/snap-stage3/src/librustc/metadata/encoder.rs

@@ -359,21 +359,12 @@ fn encode_path(ecx: &EncodeContext,
     fn encode_path_elt(ecx: &EncodeContext,
                        ebml_w: &mut writer::Encoder,
                        elt: ast_map::path_elt) {
-        match elt {
-            ast_map::path_mod(n) => {
-                ebml_w.wr_tagged_str(tag_path_elt_mod, ecx.tcx.sess.str_of(n));
-            }
-            ast_map::path_name(n) => {
-                ebml_w.wr_tagged_str(tag_path_elt_name, ecx.tcx.sess.str_of(n));
-            }
-            ast_map::path_pretty_name(n, extra) => {
-                ebml_w.start_tag(tag_path_elt_pretty_name);
-                ebml_w.wr_tagged_str(tag_path_elt_pretty_name_ident,
-                                     ecx.tcx.sess.str_of(n));
-                ebml_w.wr_tagged_u64(tag_path_elt_pretty_name_extra, extra);
-                ebml_w.end_tag();
-            }
-        }
+        let (tag, name) = match elt {
+          ast_map::path_mod(name) => (tag_path_elt_mod, name),
+          ast_map::path_name(name) => (tag_path_elt_name, name)
+        };
+
+        ebml_w.wr_tagged_str(tag, ecx.tcx.sess.str_of(name));
     }
 
     ebml_w.start_tag(tag_path);

branches/snap-stage3/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -95,6 +95,11 @@ impl visit::Visitor<@mut GatherLoanCtxt> for GatherLoanVisitor {
     fn visit_local(&mut self, l:@Local, e:@mut GatherLoanCtxt) {
         gather_loans_in_local(self, l, e);
     }
+
+    // #7740: Do not visit items here, not even fn items nor methods
+    // of impl items; the outer loop in borrowck/mod will visit them
+    // for us in turn.  Thus override visit_item's walk with a no-op.
+    fn visit_item(&mut self, _:@ast::item, _:@mut GatherLoanCtxt) { }
 }
 
 pub fn gather_loans(bccx: @BorrowckCtxt,
@@ -135,10 +140,8 @@ fn gather_loans_in_fn(v: &mut GatherLoanVisitor,
                       id: ast::NodeId,
                       this: @mut GatherLoanCtxt) {
     match fk {
-        // Do not visit items here, the outer loop in borrowck/mod
-        // will visit them for us in turn.
         &visit::fk_item_fn(*) | &visit::fk_method(*) => {
-            return;
+            fail!("cannot occur, due to visit_item override");
         }
 
         // Visit closures as part of the containing item.

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -77,7 +77,7 @@ use std::local_data;
 use extra::time;
 use extra::sort;
 use syntax::ast::Ident;
-use syntax::ast_map::{path, path_elt_to_str, path_name, path_pretty_name};
+use syntax::ast_map::{path, path_elt_to_str, path_name};
 use syntax::ast_util::{local_def};
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
@@ -2219,7 +2219,7 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
               }
               let v = ccx.const_values.get_copy(&item.id);
               unsafe {
-                  if !(llvm::LLVMConstIntGetZExtValue(v) != 0) {
+                  if !(llvm::LLVMConstIntGetZExtValue(v) as bool) {
                       ccx.sess.span_fatal(expr.span, "static assertion failed");
                   }
               }
@@ -2627,7 +2627,8 @@ pub fn register_method(ccx: @mut CrateContext,
     let mty = ty::node_id_to_type(ccx.tcx, id);
 
     let mut path = (*path).clone();
-    path.push(path_pretty_name(m.ident, token::gensym("meth") as u64));
+    path.push(path_name(gensym_name("meth")));
+    path.push(path_name(m.ident));
 
     let sym = exported_name(ccx, path, mty, m.attrs);
 

branches/snap-stage3/src/librustc/middle/trans/common.rs

@@ -948,8 +948,7 @@ pub fn path_str(sess: session::Session, p: &[path_elt]) -> ~str {
     let mut first = true;
     for e in p.iter() {
         match *e {
-            ast_map::path_name(s) | ast_map::path_mod(s) |
-            ast_map::path_pretty_name(s, _) => {
+            ast_map::path_name(s) | ast_map::path_mod(s) => {
                 if first {
                     first = false
                 } else {

branches/snap-stage3/src/librustc/middle/trans/meth.rs

@@ -34,7 +34,7 @@ use middle::trans::type_::Type;
 
 use std::c_str::ToCStr;
 use std::vec;
-use syntax::ast_map::{path, path_mod, path_name, path_pretty_name};
+use syntax::ast_map::{path, path_mod, path_name};
 use syntax::ast_util;
 use syntax::{ast, ast_map};
 use syntax::visit;
@@ -254,7 +254,7 @@ pub fn trans_static_method_callee(bcx: @mut Block,
     } else {
         let path = csearch::get_item_path(bcx.tcx(), method_id);
         match path[path.len()-1] {
-            path_pretty_name(s, _) | path_name(s) => { s }
+            path_name(s) => { s }
             path_mod(_) => { fail!("path doesn't have a name?") }
         }
     };

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -2696,7 +2696,6 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                         }, t_e, None);
                     }
 
-                    let t1 = structurally_resolved_type(fcx, e.span, t_1);
                     let te = structurally_resolved_type(fcx, e.span, t_e);
                     let t_1_is_char = type_is_char(fcx, expr.span, t_1);
 
@@ -2711,9 +2710,6 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                                 fmt!("only `u8` can be cast as `char`, not `%s`", actual)
                             }, t_e, None);
                         }
-                    } else if ty::get(t1).sty == ty::ty_bool {
-                        fcx.tcx().sess.span_err(expr.span,
-                                                "cannot cast as `bool`, compare with zero instead");
                     } else if type_is_region_ptr(fcx, expr.span, t_e) &&
                         type_is_unsafe_ptr(fcx, expr.span, t_1) {