---

yaml
---
r: 128887
b: refs/heads/try
c: 9b0f89d
h: refs/heads/master
i:
  128885: d158d51
  128883: 1091523
  128879: 017076f
v: v3

Author: Jakub Wieczorek

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 3f57c8988dfd2eba8fb751fe72dde503a6ebf2c6
+refs/heads/try: 9b0f89d342de06b035c108186f0243a3bdc7528b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/etc/emacs/rust-mode.el

@@ -170,7 +170,7 @@
 (defconst rust-mode-keywords
   '("as"
     "box" "break"
-    "const" "continue" "crate"
+    "continue" "crate"
     "do"
     "else" "enum" "extern"
     "false" "fn" "for"
@@ -182,8 +182,7 @@
     "self" "static" "struct" "super"
     "true" "trait" "type"
     "unsafe" "use"
-    "virtual"
-    "where" "while"))
+    "while"))
 
 (defconst rust-special-types
   '("u8" "i8"

branches/try/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -71,8 +71,6 @@
 		<keyword>trait</keyword>
 		<keyword>unsafe</keyword>
 		<keyword>use</keyword>
-		<keyword>virtual</keyword>
-		<keyword>where</keyword>
 		<keyword>while</keyword>
     </context>
 

branches/try/src/etc/kate/rust.xml

@@ -19,7 +19,6 @@
 		<item> as </item>
 		<item> break </item>
 		<item> box </item>
-		<item> const </item>
 		<item> continue </item>
 		<item> crate </item>
 		<item> do </item>
@@ -45,8 +44,6 @@
 		<item> trait </item>
 		<item> unsafe </item>
 		<item> use </item>
-		<item> virtual </item>
-		<item> where </item>
 		<item> while </item>
 	</list>
 	<list name="traits">

branches/try/src/etc/vim/syntax/rust.vim

@@ -26,7 +26,7 @@ syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite skipempty
 syn keyword   rustKeyword     for in if impl let
 syn keyword   rustKeyword     loop once proc pub
 syn keyword   rustKeyword     return super
-syn keyword   rustKeyword     unsafe virtual where while
+syn keyword   rustKeyword     unsafe virtual while
 syn keyword   rustKeyword     use nextgroup=rustModPath,rustModPathInUse skipwhite skipempty
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty

branches/try/src/libcollections/bitv.rs

@@ -1271,7 +1271,7 @@ impl BitvSet {
     /// let a = BitvSet::from_bitv(bitv::from_bytes([0b01101000]));
     /// let b = BitvSet::from_bitv(bitv::from_bytes([0b10100000]));
     ///
-    /// // Print 1, 4 in arbitrary order
+    /// // Print 2, 4 in arbitrary order
     /// for x in a.difference(&b) {
     ///     println!("{}", x);
     /// }

branches/try/src/libcollections/btree.rs

@@ -11,13 +11,6 @@
 // btree.rs
 //
 
-// NB. this is not deprecated for removal, just deprecating the
-// current implementation. If the major pain-points are addressed
-// (overuse of by-value self and .clone), this can be removed.
-#![deprecated = "the current implementation is extremely inefficient, \
-                 prefer a HashMap, TreeMap or TrieMap"]
-#![allow(deprecated)]
-
 //! Starting implementation of a btree for rust.
 //! Structure inspired by github user davidhalperin's gist.
 

branches/try/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/try/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/try/src/librustc/middle/typeck/check/_match.rs

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

branches/try/src/test/compile-fail/issue-16338.rs

@@ -0,0 +1,17 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::raw::Slice;
+
+fn main() {
+    let Slice { data: data, len: len } = "foo";
+    //~^ ERROR mismatched types: expected `&'static str` but found a structure pattern
+}
+

branches/try/src/test/compile-fail/issue-16401.rs

@@ -0,0 +1,19 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::raw::Slice;
+
+fn main() {
+    match () {
+        Slice { data: data, len: len } => (),
+        //~^ ERROR mismatched types: expected `()` but found a structure pattern
+        _ => unreachable!()
+    }
+}