---

yaml
---
r: 139805
b: refs/heads/try2
c: 16e8af9
h: refs/heads/master
i:
  139803: bcec489
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 40e3577b0834794b2d44e6c527fda90d1adbc88e
+refs/heads/try2: 16e8af9e477fd5a6e7dcf668840144a97e3b1410
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/AUTHORS.txt

@@ -31,6 +31,7 @@ Bilal Husain <[email protected]>
 Bill Fallon <[email protected]>
 Brendan Eich <[email protected]>
 Brendan Zabarauskas <[email protected]>
+Brett Cannon <[email protected]>
 Brian Anderson <[email protected]>
 Brian J. Burg <[email protected]>
 Brian Leibig <[email protected]>
@@ -50,6 +51,7 @@ Dave Herman <[email protected]>
 David Forsythe <[email protected]>
 David Klein <[email protected]>
 David Rajchenbach-Teller <[email protected]>
+Diggory Hardy <[email protected]>
 Dimitri Krassovski <[email protected]>
 Donovan Preston <[email protected]>
 Drew Willcoxon <[email protected]>
@@ -76,9 +78,11 @@ Ian D. Bollinger <[email protected]>
 Ilyong Cho <[email protected]>
 Isaac Aggrey <[email protected]>
 Ivano Coppola <[email protected]>
+Jack Moffitt <[email protected]>
 Jacob Harris Cryer Kragh <[email protected]>
 Jacob Parker <[email protected]>
 Jakub Wieczorek <[email protected]>
+James Miller <[email protected]>
 Jason Orendorff <[email protected]>
 Jed Davis <[email protected]>
 Jeff Balogh <[email protected]>

branches/try2/src/librustc/metadata/encoder.rs

@@ -63,7 +63,7 @@ pub struct EncodeParams {
     reachable: reachable::map,
     reexports2: middle::resolve::ExportMap2,
     item_symbols: @mut HashMap<ast::node_id, ~str>,
-    discrim_symbols: @mut HashMap<ast::node_id, ~str>,
+    discrim_symbols: @mut HashMap<ast::node_id, @~str>,
     link_meta: LinkMeta,
     cstore: @mut cstore::CStore,
     encode_inlined_item: encode_inlined_item
@@ -90,7 +90,7 @@ pub struct EncodeContext {
     reachable: reachable::map,
     reexports2: middle::resolve::ExportMap2,
     item_symbols: @mut HashMap<ast::node_id, ~str>,
-    discrim_symbols: @mut HashMap<ast::node_id, ~str>,
+    discrim_symbols: @mut HashMap<ast::node_id, @~str>,
     link_meta: LinkMeta,
     cstore: @mut cstore::CStore,
     encode_inlined_item: encode_inlined_item,
@@ -285,7 +285,7 @@ fn encode_symbol(ecx: @EncodeContext, ebml_w: writer::Encoder, id: node_id) {
 fn encode_discriminant(ecx: @EncodeContext, ebml_w: writer::Encoder,
                        id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
-    ebml_w.writer.write(str::to_bytes(*ecx.discrim_symbols.get(&id)));
+    ebml_w.writer.write(str::to_bytes(**ecx.discrim_symbols.get(&id)));
     ebml_w.end_tag();
 }
 

branches/try2/src/librustc/middle/trans/base.rs

@@ -468,11 +468,9 @@ pub fn set_glue_inlining(f: ValueRef, t: ty::t) {
 
 // Double-check that we never ask LLVM to declare the same symbol twice. It
 // silently mangles such symbols, breaking our linkage model.
-pub fn note_unique_llvm_symbol(ccx: @CrateContext, +sym: ~str) {
-    // XXX: this should not be necessary
-    use core::container::Set;
+pub fn note_unique_llvm_symbol(ccx: @CrateContext, sym: @~str) {
     if ccx.all_llvm_symbols.contains(&sym) {
-        ccx.sess.bug(~"duplicate LLVM symbol: " + sym);
+        ccx.sess.bug(~"duplicate LLVM symbol: " + *sym);
     }
     ccx.all_llvm_symbols.insert(sym);
 }
@@ -2576,11 +2574,10 @@ pub fn trans_constant(ccx: @CrateContext, it: @ast::item) {
                 path_name(variant.node.name),
                 path_name(special_idents::descrim)
             ]);
-            let s = mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx));
+            let s = @mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx));
             let disr_val = vi[i].disr_val;
-            // XXX: Bad copy.
-            note_unique_llvm_symbol(ccx, copy s);
-            let discrim_gvar = str::as_c_str(s, |buf| {
+            note_unique_llvm_symbol(ccx, s);
+            let discrim_gvar = str::as_c_str(*s, |buf| {
                 unsafe {
                     llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
                 }

branches/try2/src/librustc/middle/trans/common.rs

@@ -173,7 +173,7 @@ pub struct CrateContext {
      link_meta: LinkMeta,
      enum_sizes: @mut HashMap<ty::t, uint>,
      discrims: @mut HashMap<ast::def_id, ValueRef>,
-     discrim_symbols: @mut HashMap<ast::node_id, ~str>,
+     discrim_symbols: @mut HashMap<ast::node_id, @~str>,
      tydescs: @mut HashMap<ty::t, @mut tydesc_info>,
      // Set when running emit_tydescs to enforce that no more tydescs are
      // created.
@@ -215,7 +215,7 @@ pub struct CrateContext {
      symbol_hasher: @hash::State,
      type_hashcodes: @mut HashMap<ty::t, @str>,
      type_short_names: @mut HashMap<ty::t, ~str>,
-     all_llvm_symbols: @mut HashSet<~str>,
+     all_llvm_symbols: @mut HashSet<@~str>,
      tcx: ty::ctxt,
      maps: astencode::Maps,
      stats: @mut Stats,

branches/try2/src/librustc/middle/trans/glue.rs

@@ -684,15 +684,14 @@ pub fn declare_tydesc(ccx: @CrateContext, t: ty::t) -> @mut tydesc_info {
     let llalign = llalign_of(ccx, llty);
     let addrspace = declare_tydesc_addrspace(ccx, t);
     //XXX this triggers duplicate LLVM symbols
-    let name = if false /*ccx.sess.opts.debuginfo*/ {
+    let name = @(if false /*ccx.sess.opts.debuginfo*/ {
         mangle_internal_name_by_type_only(ccx, t, ~"tydesc")
     } else {
         mangle_internal_name_by_seq(ccx, ~"tydesc")
-    };
-    // XXX: Bad copy.
-    note_unique_llvm_symbol(ccx, copy name);
-    debug!("+++ declare_tydesc %s %s", ppaux::ty_to_str(ccx.tcx, t), name);
-    let gvar = str::as_c_str(name, |buf| {
+    });
+    note_unique_llvm_symbol(ccx, name);
+    debug!("+++ declare_tydesc %s %s", ppaux::ty_to_str(ccx.tcx, t), *name);
+    let gvar = str::as_c_str(*name, |buf| {
         unsafe {
             llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type, buf)
         }
@@ -718,17 +717,16 @@ pub fn declare_generic_glue(ccx: @CrateContext, t: ty::t, llfnty: TypeRef,
                             +name: ~str) -> ValueRef {
     let _icx = ccx.insn_ctxt("declare_generic_glue");
     let name = name;
-    let mut fn_nm;
     //XXX this triggers duplicate LLVM symbols
-    if false /*ccx.sess.opts.debuginfo*/ {
-        fn_nm = mangle_internal_name_by_type_only(ccx, t, (~"glue_" + name));
+    let fn_nm = @(if false /*ccx.sess.opts.debuginfo*/ {
+        mangle_internal_name_by_type_only(ccx, t, (~"glue_" + name))
     } else {
-        fn_nm = mangle_internal_name_by_seq(ccx, (~"glue_" + name));
-    }
-    debug!("%s is for type %s", fn_nm, ppaux::ty_to_str(ccx.tcx, t));
+        mangle_internal_name_by_seq(ccx, (~"glue_" + name))
+    });
+    debug!("%s is for type %s", *fn_nm, ppaux::ty_to_str(ccx.tcx, t));
     // XXX: Bad copy.
-    note_unique_llvm_symbol(ccx, copy fn_nm);
-    let llfn = decl_cdecl_fn(ccx.llmod, fn_nm, llfnty);
+    note_unique_llvm_symbol(ccx, fn_nm);
+    let llfn = decl_cdecl_fn(ccx.llmod, *fn_nm, llfnty);
     set_glue_inlining(llfn, t);
     return llfn;
 }

branches/try2/src/libstd/base64.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -27,6 +27,21 @@ static CHARS: [char, ..64] = [
 ];
 
 impl<'self> ToBase64 for &'self [u8] {
+    /**
+     * Turn a vector of `u8` bytes into a base64 string.
+     *
+     * *Example*:
+     *
+     * ~~~~
+     * extern mod std;
+     * use std::base64::ToBase64;
+     *
+     * fn main () {
+     *     let str = [52,32].to_base64();
+     *     println(fmt!("%s", str));
+     * }
+     * ~~~~
+     */
     fn to_base64(&self) -> ~str {
         let mut s = ~"";
         let len = self.len();
@@ -74,6 +89,23 @@ impl<'self> ToBase64 for &'self [u8] {
 }
 
 impl<'self> ToBase64 for &'self str {
+    /**
+     * Convert any string (literal, `@`, `&`, or `~`) to base64 encoding.
+     *
+     *
+     * *Example*:
+     *
+     * ~~~~
+     * extern mod std;
+     * use std::base64::ToBase64;
+     *
+     * fn main () {
+     *     let str = "Hello, World".to_base64();
+     *     println(fmt!("%s",str));
+     * }
+     * ~~~~
+     *
+     */
     fn to_base64(&self) -> ~str {
         str::to_bytes(*self).to_base64()
     }
@@ -84,6 +116,25 @@ pub trait FromBase64 {
 }
 
 impl FromBase64 for ~[u8] {
+    /**
+     * Convert base64 `u8` vector into u8 byte values.
+     * Every 4 encoded characters is converted into 3 octets, modulo padding.
+     *
+     * *Example*:
+     *
+     * ~~~~
+     * extern mod std;
+     * use std::base64::ToBase64;
+     * use std::base64::FromBase64;
+     *
+     * fn main () {
+     *     let str = [52,32].to_base64();
+     *     println(fmt!("%s", str));
+     *     let bytes = str.from_base64();
+     *     println(fmt!("%?",bytes));
+     * }
+     * ~~~~
+     */
     fn from_base64(&self) -> ~[u8] {
         if self.len() % 4u != 0u { fail!(~"invalid base64 length"); }
 
@@ -144,6 +195,33 @@ impl FromBase64 for ~[u8] {
 }
 
 impl FromBase64 for ~str {
+    /**
+     * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
+     * to the byte values it encodes.
+     *
+     * You can use the `from_bytes` function in `core::str`
+     * to turn a `[u8]` into a string with characters corresponding to those values.
+     *
+     * *Example*:
+     *
+     * This converts a string literal to base64 and back.
+     *
+     * ~~~~
+     * extern mod std;
+     * use std::base64::ToBase64;
+     * use std::base64::FromBase64;
+     * use core::str;
+     *
+     * fn main () {
+     *     let hello_str = "Hello, World".to_base64();
+     *     println(fmt!("%s",hello_str));
+     *     let bytes = hello_str.from_base64();
+     *     println(fmt!("%?",bytes));
+     *     let result_str = str::from_bytes(bytes);
+     *     println(fmt!("%s",result_str));
+     * }
+     * ~~~~
+     */
     fn from_base64(&self) -> ~[u8] {
         str::to_bytes(*self).from_base64()
     }