---

yaml
---
r: 128439
b: refs/heads/auto
c: 61b9036
h: refs/heads/master
i:
  128437: 4839d7a
  128435: df0231c
  128431: 16e101d
v: v3

Author: kaseyc

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 776c17f476c4be92f6cfe4dab528886973ea8c03
+refs/heads/auto: 61b9036bb8612d6330f9cb6bb3b52219bebe1802
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/README.md

@@ -19,7 +19,7 @@ for the 'std' and 'extra' libraries.
 To generate HTML documentation from one source file/crate, do something like:
 
 ~~~~
-rustdoc --output-dir html-doc/ --output-format html ../src/libstd/path.rs
+rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
 ~~~~
 
 (This, of course, requires a working build of the `rustdoc` tool.)

branches/auto/src/libnum/bigint.rs

@@ -59,7 +59,7 @@
 use Integer;
 use rand::Rng;
 
-use std::{cmp, fmt, hash};
+use std::{cmp, fmt};
 use std::default::Default;
 use std::from_str::FromStr;
 use std::num::CheckedDiv;
@@ -150,22 +150,6 @@ impl Default for BigUint {
     fn default() -> BigUint { Zero::zero() }
 }
 
-impl<S: hash::Writer> hash::Hash<S> for BigUint {
-    fn hash(&self, state: &mut S) {
-        // hash 0 in case it's all 0's
-        0u32.hash(state);
-
-        let mut found_first_value = false;
-        for elem in self.data.iter().rev() {
-            // don't hash any leading 0's, they shouldn't affect the hash
-            if found_first_value || *elem != 0 {
-                found_first_value = true;
-                elem.hash(state);
-            }
-        }
-    }
-}
-
 impl fmt::Show for BigUint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.to_str_radix(10))
@@ -897,13 +881,6 @@ impl fmt::Show for BigInt {
     }
 }
 
-impl<S: hash::Writer> hash::Hash<S> for BigInt {
-    fn hash(&self, state: &mut S) {
-        (self.sign == Plus).hash(state);
-        self.data.hash(state);
-    }
-}
-
 impl FromStr for BigInt {
     #[inline]
     fn from_str(s: &str) -> Option<BigInt> {
@@ -1432,7 +1409,6 @@ mod biguint_tests {
     use std::num::CheckedDiv;
     use std::rand::task_rng;
     use std::u64;
-    use std::hash::hash;
 
     #[test]
     fn test_from_slice() {
@@ -1484,19 +1460,6 @@ mod biguint_tests {
         }
     }
 
-    #[test]
-    fn test_hash() {
-        let a = BigUint::new(vec!());
-        let b = BigUint::new(vec!(0));
-        let c = BigUint::new(vec!(1));
-        let d = BigUint::new(vec!(1,0,0,0,0,0));
-        let e = BigUint::new(vec!(0,0,0,0,0,1));
-        assert!(hash(&a) == hash(&b));
-        assert!(hash(&b) != hash(&c));
-        assert!(hash(&c) == hash(&d));
-        assert!(hash(&d) != hash(&e));
-    }
-
     #[test]
     fn test_bitand() {
         fn check(left: &[BigDigit],
@@ -2294,7 +2257,6 @@ mod bigint_tests {
     use std::num::{ToPrimitive, FromPrimitive};
     use std::rand::task_rng;
     use std::u64;
-    use std::hash::hash;
 
     #[test]
     fn test_from_biguint() {
@@ -2352,21 +2314,6 @@ mod bigint_tests {
         }
     }
 
-    #[test]
-    fn test_hash() {
-        let a = BigInt::new(Zero, vec!());
-        let b = BigInt::new(Zero, vec!(0));
-        let c = BigInt::new(Plus, vec!(1));
-        let d = BigInt::new(Plus, vec!(1,0,0,0,0,0));
-        let e = BigInt::new(Plus, vec!(0,0,0,0,0,1));
-        let f = BigInt::new(Minus, vec!(1));
-        assert!(hash(&a) == hash(&b));
-        assert!(hash(&b) != hash(&c));
-        assert!(hash(&c) == hash(&d));
-        assert!(hash(&d) != hash(&e));
-        assert!(hash(&c) != hash(&f));
-    }
-
     #[test]
     fn test_convert_i64() {
         fn check(b1: BigInt, i: i64) {

branches/auto/src/libnum/lib.rs

@@ -43,7 +43,6 @@
 //! [newt]: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
 
 #![feature(macro_rules)]
-#![feature(default_type_params)]
 
 #![crate_name = "num"]
 #![experimental]

branches/auto/src/librustc/middle/trans/debuginfo.rs

@@ -53,12 +53,13 @@ This file consists of three conceptual sections:
 3. Minor utility functions
 
 
-## Recursive Types Some kinds of types, such as structs and enums can be
-recursive. That means that the type definition of some type X refers to some
-other type which in turn (transitively) refers to X. This introduces cycles into
-the type referral graph. A naive algorithm doing an on-demand, depth-first
-traversal of this graph when describing types, can get trapped in an endless
-loop when it reaches such a cycle.
+## Recursive Types
+
+Some kinds of types, such as structs and enums can be recursive. That means that
+the type definition of some type X refers to some other type which in turn (transitively)
+refers to X. This introduces cycles into the type referral graph. A naive algorithm doing
+an on-demand, depth-first traversal of this graph when describing types, can get trapped
+in an endless loop when it reaches such a cycle.
 
 For example, the following simple type for a singly-linked list...
 
@@ -96,10 +97,12 @@ traversal at the type members after the type has been registered with the cache.
 the future)
 
 
-## Source Locations and Line Information In addition to data type descriptions
-the debugging information must also allow to map machine code locations back to
-source code locations in order to be useful. This functionality is also handled
-in this module. The following functions allow to control source mappings:
+## Source Locations and Line Information
+
+In addition to data type descriptions the debugging information must also allow
+to map machine code locations back to source code locations in order to be useful.
+This functionality is also handled in this module. The following functions allow
+to control source mappings:
 
 + set_source_location()
 + clear_source_location()
@@ -139,10 +142,12 @@ of the prologue, however, they are ignored by LLVM's prologue detection. The
 source location emission is still disabled, so there is no need to do anything
 special with source location handling here.
 
-## Unique Type Identification In order for link-time optimization to work
-properly, LLVM needs a unique type identifier that tells it across compilation
-units which types are the same as others. This type identifier is created by
-TypeMap::get_unique_type_id_of_type() using the following algorithm:
+## Unique Type Identification
+
+In order for link-time optimization to work properly, LLVM needs a unique type
+identifier that tells it across compilation units which types are the same as
+others. This type identifier is created by TypeMap::get_unique_type_id_of_type()
+using the following algorithm:
 
 (1) Primitive types have their name as ID
 (2) Structs, enums and traits have a multipart identifier

branches/auto/src/librustc/middle/typeck/check/_match.rs

@@ -355,7 +355,8 @@ pub fn check_struct_pat_fields(pcx: &pat_ctxt,
     }
 }
 
-pub fn check_struct_pat(pcx: &pat_ctxt, span: Span,
+pub fn check_struct_pat(pcx: &pat_ctxt, _pat_id: ast::NodeId, span: Span,
+                        _expected: ty::t, _path: &ast::Path,
                         fields: &[ast::FieldPat], etc: bool,
                         struct_id: ast::DefId,
                         substitutions: &subst::Substs) {
@@ -528,7 +529,8 @@ pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) {
                     },
                 }
 
-                check_struct_pat(pcx, pat.span, fields.as_slice(), etc, cid, substs);
+                check_struct_pat(pcx, pat.id, pat.span, expected, path,
+                                 fields.as_slice(), etc, cid, substs);
             }
             ty::ty_enum(eid, ref substs) => {
                 check_struct_like_enum_variant_pat(pcx,
@@ -555,11 +557,15 @@ pub fn check_pat(pcx: &pat_ctxt, pat: &ast::Pat, expected: ty::t) {
                             None);
                 match tcx.def_map.borrow().find(&pat.id) {
                     Some(def) => {
-                        let item_type = ty::lookup_item_type(tcx, def.def_id());
-                        let substitutions = fcx.infcx().fresh_substs_for_type(
-                            pat.span, &item_type.generics);
-                        check_struct_pat(pcx, pat.span, fields.as_slice(),
-                                         etc, def.def_id(), &substitutions);
+                         check_struct_pat(pcx,
+                                          pat.id,
+                                          pat.span,
+                                          ty::mk_err(),
+                                          path,
+                                          fields.as_slice(),
+                                          etc,
+                                          def.def_id(),
+                                          &subst::Substs::empty());
                     }
                     None => {
                         tcx.sess.span_bug(pat.span,