---

yaml
---
r: 95015
b: refs/heads/dist-snap
c: fe9b1e2
h: refs/heads/master
i:
  95013: 2a021b0
  95011: c386adf
  95007: 0031a0d
v: v3

Author: sfackler

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 3ae895360c89b27bee7f076fded1c99691bd057e
+refs/heads/dist-snap: fe9b1e29fc9cc1983fdf17355d7b8956b63d9b55
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/Makefile.in

@@ -141,11 +141,11 @@ endif
 
 # version-string calculation
 CFG_GIT_DIR := $(CFG_SRC_DIR).git
-CFG_RELEASE = 0.9-pre
+CFG_RELEASE = 0.8
 CFG_VERSION = $(CFG_RELEASE)
 # windows exe's need numeric versions - don't use anything but
 # numbers and dots here
-CFG_VERSION_WIN = 0.9
+CFG_VERSION_WIN = 0.8
 
 ifneq ($(wildcard $(CFG_GIT)),)
 ifneq ($(wildcard $(CFG_GIT_DIR)),)

branches/dist-snap/mk/clean.mk

@@ -54,8 +54,9 @@ clean-misc:
 	$(Q)rm -Rf rust-stage0-*.tar.bz2 $(PKG_NAME)-*.tar.gz dist
 	$(Q)rm -Rf $(foreach ext, \
                  html aux cp fn ky log pdf pg toc tp vr cps, \
-                 $(wildcard doc/*.$(ext)))
-	$(Q)find doc/std doc/extra -mindepth 1 | xargs rm -Rf
+                 $(wildcard doc/*.$(ext) \
+                            doc/*/*.$(ext) \
+                            doc/*/*/*.$(ext)))
 	$(Q)rm -Rf doc/version.md
 	$(Q)rm -Rf $(foreach sub, index styles files search javascript, \
                  $(wildcard doc/*/$(sub)))

branches/dist-snap/src/etc/kate/rust.xml

@@ -7,7 +7,7 @@
 	<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">
 	<!ENTITY rustIntSuf "([iu](8|16|32|64)?)?">
 ]>
-<language name="Rust" version="0.9-pre" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="0.8" kateversion="2.4" section="Sources" extensions="*.rs;*.rc" mimetype="text/x-rust" priority="15">
 <highlighting>
 	<list name="fn">
 		<item> fn </item>

branches/dist-snap/src/etc/monodebug.pl

@@ -0,0 +1,79 @@
+#!/usr/bin/perl
+
+#
+# This is a tool that helps with debugging incorrect monomorphic instance collapse.
+#
+# To use:
+#    $ RUST_LOG=rustc::middle::trans::monomorphize rustc ARGS 2>&1 >log.txt
+#    $ ./monodebug.pl log.txt
+#
+# This will show all generics that got collapsed. You can inspect this list to find the instances
+# that were mistakenly combined into one. Fixes will (most likely) be applied to type_use.rs.
+#
+# Questions about this tool go to pcwalton.
+#
+
+use strict;
+use warnings;
+use Data::Dumper qw(Dumper);
+use Text::Balanced qw(extract_bracketed);
+
+my %funcs;
+while (<>) {
+    chomp;
+    /^rust: ~"monomorphic_fn\((.*)"$/ or next;
+    my $text = $1;
+    $text =~ /fn_id=(\{ crate: \d+, node: \d+ \} \([^)]+\)), real_substs=(.*?), substs=(.*?), hash_id = \@\{ (.*) \}$/ or next;
+    my ($fn_id, $real_substs, $substs, $hash_id) = ($1, $2, $3, $4);
+
+    #print "$hash_id\n";
+    $hash_id =~ /^def: { crate: \d+, node: \d+ }, params: ~\[ (.*) \], impl_did_opt: (?:None|Some\({ crate: \d+, node: \d+ }\))$/ or next;
+    my $params = $1;
+
+    my @real_substs;
+    @real_substs = $real_substs =~ /\\"(.*?)\\"/g;
+
+    my @mono_params;
+    while (1) {
+        $params =~ s/^, //;
+        if ($params =~ s/^mono_precise//) {
+            extract_bracketed($params, '()');
+            push @mono_params, 'precise';
+            next;
+        }
+        if ($params =~ s/^mono_repr//) {
+            my $sub = extract_bracketed($params, '()');
+            push @mono_params, "repr($sub)";
+            next;
+        }
+        if ($params =~ s/^mono_any//) {
+            push @mono_params, "any";
+            next;
+        }
+        last;
+    }
+
+    my @key_params;
+    for (my $i = 0; $i < @mono_params; ++$i) {
+        if ($mono_params[$i] eq 'precise') {
+            push @key_params, 'precise(' . $real_substs[$i] . ')';
+        } else {
+            push @key_params, $mono_params[$i];
+        }
+    }
+
+    my $key = "$fn_id with " . (join ', ', @key_params);
+    $funcs{$key}{$real_substs} = 1;
+}
+
+while (my ($key, $substs) = each %funcs) {
+    my @params = keys %$substs;
+    next if @params == 1;
+
+    print "$key\n";
+    print(('-' x (length $key)), $/);
+    for my $param (@params) {
+        print "$param\n";
+    }
+    print "\n";
+}

branches/dist-snap/src/etc/zsh/_rust

@@ -71,6 +71,7 @@ _rustc_opts_debug=(
     'count-type-sizes:count the sizes of aggregate types'
     'meta-stats:gather metadata statistics'
     'no-opt:do not optimize, even if -O is passed'
+    'no-monomorphic-collapse:do not collapse template instantiations'
     'print-link-args:Print the arguments passed to the linker'
     'gc:Garbage collect shared data (experimental)'
     'jit:Execute using JIT (experimental)'

branches/dist-snap/src/libextra/base64.rs

@@ -13,19 +13,19 @@ use std::str;
 
 /// Available encoding character sets
 pub enum CharacterSet {
-    /// The standard character set (uses `+` and `/`)
+    /// The standard character set (uses '+' and '/')
     Standard,
-    /// The URL safe character set (uses `-` and `_`)
+    /// The URL safe character set (uses '-' and '_')
     UrlSafe
 }
 
-/// Contains configuration parameters for `to_base64`.
+/// Contains configuration parameters for to_base64
 pub struct Config {
     /// Character set to use
     char_set: CharacterSet,
-    /// True to pad output with `=` characters
+    /// True to pad output with '=' characters
     pad: bool,
-    /// `Some(len)` to wrap lines at `len`, `None` to disable line wrapping
+    /// Some(len) to wrap lines at len, None to disable line wrapping
     line_length: Option<uint>
 }
 
@@ -68,7 +68,7 @@ impl<'self> ToBase64 for &'self [u8] {
      *
      * fn main () {
      *     let str = [52,32].to_base64(standard);
-     *     println!("{}", str);
+     *     printfln!("%s", str);
      * }
      * ```
      */
@@ -177,11 +177,11 @@ impl<'self> FromBase64 for &'self str {
      *
      * fn main () {
      *     let hello_str = "Hello, World".to_base64(standard);
-     *     println!("{}", hello_str);
+     *     printfln!("%s", hello_str);
      *     let bytes = hello_str.from_base64();
-     *     println!("{:?}", bytes);
+     *     printfln!("%?", bytes);
      *     let result_str = str::from_utf8(bytes);
-     *     println!("{}", result_str);
+     *     printfln!("%s", result_str);
      * }
      * ```
      */

branches/dist-snap/src/libextra/bitv.rs

@@ -116,7 +116,7 @@ struct BigBitv {
 }
 
 /**
- * A mask that has a 1 for each defined bit in the n'th element of a `BigBitv`,
+ * a mask that has a 1 for each defined bit in the nth element of a big_bitv,
  * assuming n bits.
  */
 #[inline]
@@ -284,7 +284,7 @@ impl Bitv {
      * Calculates the union of two bitvectors
      *
      * Sets `self` to the union of `self` and `v1`. Both bitvectors must be
-     * the same length. Returns `true` if `self` changed.
+     * the same length. Returns 'true' if `self` changed.
     */
     #[inline]
     pub fn union(&mut self, v1: &Bitv) -> bool { self.do_op(Union, v1) }
@@ -293,7 +293,7 @@ impl Bitv {
      * Calculates the intersection of two bitvectors
      *
      * Sets `self` to the intersection of `self` and `v1`. Both bitvectors
-     * must be the same length. Returns `true` if `self` changed.
+     * must be the same length. Returns 'true' if `self` changed.
     */
     #[inline]
     pub fn intersect(&mut self, v1: &Bitv) -> bool {
@@ -395,7 +395,7 @@ impl Bitv {
         self.do_op(Difference, v)
     }
 
-    /// Returns `true` if all bits are 1
+    /// Returns true if all bits are 1
     #[inline]
     pub fn is_true(&self) -> bool {
       match self.rep {
@@ -417,7 +417,7 @@ impl Bitv {
         self.iter().invert()
     }
 
-    /// Returns `true` if all bits are 0
+    /// Returns true if all bits are 0
     pub fn is_false(&self) -> bool {
       match self.rep {
         Small(ref b) => b.is_false(self.nbits),
@@ -433,18 +433,18 @@ impl Bitv {
     }
 
     /**
-     * Converts `self` to a vector of `uint` with the same length.
+     * Converts `self` to a vector of uint with the same length.
      *
-     * Each `uint` in the resulting vector has either value `0u` or `1u`.
+     * Each uint in the resulting vector has either value 0u or 1u.
      */
     pub fn to_vec(&self) -> ~[uint] {
         vec::from_fn(self.nbits, |x| self.init_to_vec(x))
     }
 
     /**
      * Organise the bits into bytes, such that the first bit in the
-     * `Bitv` becomes the high-order bit of the first byte. If the
-     * size of the `Bitv` is not a multiple of 8 then trailing bits
+     * bitv becomes the high-order bit of the first byte. If the
+     * size of the bitv is not a multiple of 8 then trailing bits
      * will be filled-in with false/0
      */
     pub fn to_bytes(&self) -> ~[u8] {
@@ -472,7 +472,7 @@ impl Bitv {
     }
 
     /**
-     * Transform `self` into a `[bool]` by turning each bit into a `bool`.
+     * Transform self into a [bool] by turning each bit into a bool
      */
     pub fn to_bools(&self) -> ~[bool] {
         vec::from_fn(self.nbits, |i| self[i])
@@ -498,7 +498,7 @@ impl Bitv {
 
 
     /**
-     * Compare a bitvector to a vector of `bool`.
+     * Compare a bitvector to a vector of bool.
      *
      * Both the bitvector and vector must have the same length.
      */
@@ -519,9 +519,9 @@ impl Bitv {
 }
 
 /**
- * Transform a byte-vector into a `Bitv`. Each byte becomes 8 bits,
+ * Transform a byte-vector into a bitv. Each byte becomes 8 bits,
  * with the most significant bits of each byte coming first. Each
- * bit becomes `true` if equal to 1 or `false` if equal to 0.
+ * bit becomes true if equal to 1 or false if equal to 0.
  */
 pub fn from_bytes(bytes: &[u8]) -> Bitv {
     from_fn(bytes.len() * 8, |i| {
@@ -532,15 +532,15 @@ pub fn from_bytes(bytes: &[u8]) -> Bitv {
 }
 
 /**
- * Transform a `[bool]` into a `Bitv` by converting each `bool` into a bit.
+ * Transform a [bool] into a bitv by converting each bool into a bit.
  */
 pub fn from_bools(bools: &[bool]) -> Bitv {
     from_fn(bools.len(), |i| bools[i])
 }
 
 /**
- * Create a `Bitv` of the specified length where the value at each
- * index is `f(index)`.
+ * Create a bitv of the specified length where the value at each
+ * index is f(index).
  */
 pub fn from_fn(len: uint, f: &fn(index: uint) -> bool) -> Bitv {
     let mut bitv = Bitv::new(len, false);
@@ -571,7 +571,7 @@ fn iterate_bits(base: uint, bits: uint, f: &fn(uint) -> bool) -> bool {
     return true;
 }
 
-/// An iterator for `Bitv`.
+/// An iterator for Bitv
 pub struct BitvIterator<'self> {
     priv bitv: &'self Bitv,
     priv next_idx: uint,
@@ -631,12 +631,12 @@ impl<'self> RandomAccessIterator<bool> for BitvIterator<'self> {
 ///
 /// It should also be noted that the amount of storage necessary for holding a
 /// set of objects is proportional to the maximum of the objects when viewed
-/// as a `uint`.
+/// as a uint.
 #[deriving(Clone)]
 pub struct BitvSet {
     priv size: uint,
 
-    // In theory this is a `Bitv` instead of always a `BigBitv`, but knowing that
+    // In theory this is a Bitv instead of always a BigBitv, but knowing that
     // there's an array of storage makes our lives a whole lot easier when
     // performing union/intersection/etc operations
     priv bitv: BigBitv
@@ -861,7 +861,7 @@ impl MutableSet<uint> for BitvSet {
 }
 
 impl BitvSet {
-    /// Visits each of the words that the two bit vectors (`self` and `other`)
+    /// Visits each of the words that the two bit vectors (self and other)
     /// both have in common. The three yielded arguments are (bit location,
     /// w1, w2) where the bit location is the number of bits offset so far,
     /// and w1/w2 are the words coming from the two vectors self, other.
@@ -874,13 +874,13 @@ impl BitvSet {
             .map(|((i, &w), o_store)| (i * uint::bits, w, o_store[i]))
     }
 
-    /// Visits each word in `self` or `other` that extends beyond the other. This
+    /// Visits each word in self or other that extends beyond the other. This
     /// will only iterate through one of the vectors, and it only iterates
     /// over the portion that doesn't overlap with the other one.
     ///
-    /// The yielded arguments are a `bool`, the bit offset, and a word. The `bool`
-    /// is true if the word comes from `self`, and `false` if it comes from
-    /// `other`.
+    /// The yielded arguments are a bool, the bit offset, and a word. The bool
+    /// is true if the word comes from 'self', and false if it comes from
+    /// 'other'.
     fn outlier_iter<'a>(&'a self, other: &'a BitvSet)
         -> Map<'static, ((uint, &'a uint), uint), (bool, uint, uint),
                Zip<Enumerate<vec::VecIterator<'a, uint>>, Repeat<uint>>> {

branches/dist-snap/src/libextra/extra.rs

@@ -21,7 +21,7 @@ Rust extras are part of the standard Rust distribution.
 */
 
 #[link(name = "extra",
-       vers = "0.9-pre",
+       vers = "0.8",
        uuid = "122bed0b-c19b-4b82-b0b7-7ae8aead7297",
        url = "https://github.com/mozilla/rust/tree/master/src/libextra")];
 

branches/dist-snap/src/libextra/future.rs

@@ -19,7 +19,7 @@
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = extra::future::spawn (|| fib(5000) );
  * make_a_sandwich();
- * println!("fib(5000) = {}", delayed_fib.get())
+ * printfln!("fib(5000) = %?", delayed_fib.get())
  * ```
  */