---

yaml
---
r: 51007
b: refs/heads/try
c: 05fba8c
h: refs/heads/master
i:
  51005: 394b698
  51003: b68f6f7
  50999: 03696da
  50991: e700053
  50975: 02e62f2
  50943: 5be9cff
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 5011d05db25fd3dfc0a9dc41fd914633ffb85469
+refs/heads/try: 05fba8c8f4c45d8f52b3aa70f9353f0adc1261eb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rust.md

@@ -441,11 +441,11 @@ expression context, the final namespace qualifier is omitted.
 Two examples of paths with type arguments:
 
 ~~~~
-# use core::hashmap::linear::LinearMap;
+# use std::oldmap;
 # fn f() {
 # fn id<T:Copy>(t: T) -> T { t }
-type t = LinearMap<int,~str>;  // Type arguments used in a type expression
-let x = id::<int>(10);         // Type arguments used in a call expression
+type t = oldmap::HashMap<int,~str>;  // Type arguments used in a type expression
+let x = id::<int>(10);           // Type arguments used in a call expression
 # }
 ~~~~
 

branches/try/doc/tutorial.md

@@ -1829,8 +1829,8 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-# use core::hashmap::linear::LinearMap;
-type Set<T> = LinearMap<T, ()>;
+# use std::oldmap::HashMap;
+type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
     elements: ~[T]

branches/try/src/libcore/flate.rs

@@ -17,10 +17,10 @@ Simple compression
 use libc;
 use libc::{c_void, size_t, c_int};
 use ptr;
+use rand::RngUtil;
 use vec;
 
 #[cfg(test)] use rand;
-#[cfg(test)] use rand::RngUtil;
 
 pub mod rustrt {
     use libc::{c_int, c_void, size_t};

branches/try/src/libcore/hashmap.rs

@@ -656,11 +656,6 @@ pub mod linear {
         fn reserve_at_least(&mut self, n: uint) {
             self.map.reserve_at_least(n)
         }
-
-        /// Consumes all of the elements in the set, emptying it out
-        fn consume(&mut self, f: &fn(T)) {
-            self.map.consume(|k, _| f(k))
-        }
     }
 
     #[test]

branches/try/src/libcore/logging.rs

@@ -10,6 +10,8 @@
 
 //! Logging
 
+use libc;
+
 pub mod rustrt {
     use libc;
 
@@ -47,7 +49,6 @@ pub fn console_off() {
 pub fn log_type<T>(level: u32, object: &T) {
     use cast::transmute;
     use io;
-    use libc;
     use repr;
     use vec;
 

branches/try/src/libcore/repr.rs

@@ -451,9 +451,6 @@ impl TyVisitor for ReprVisitor {
     }
     fn visit_leave_tup(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool {
-        if _n_fields == 1 {
-            self.writer.write_char(',');
-        }
         self.writer.write_char(')');
         true
     }
@@ -594,6 +591,7 @@ fn test_repr() {
         fail_unless!(s == e);
     }
 
+
     exact_test(&10, "10");
     exact_test(&true, "true");
     exact_test(&false, "false");
@@ -610,7 +608,6 @@ fn test_repr() {
     let mut x = 10;
     exact_test(&(&mut x), "&mut 10");
 
-    exact_test(&(1,), "(1,)");
     exact_test(&(@[1,2,3,4,5,6,7,8]),
                "@[1, 2, 3, 4, 5, 6, 7, 8]");
     exact_test(&(@[1u8,2u8,3u8,4u8]),

branches/try/src/libcore/rt/io/mod.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use option::*;
+use comm::{GenericPort, GenericChan};
+
 pub mod file;
 
 // FIXME #5370 Strongly want this to be StreamError(&mut Stream)

branches/try/src/libcore/rt/uv/mod.rs

@@ -42,6 +42,7 @@ use ptr;
 use libc::{c_void, c_int, size_t, malloc, free, ssize_t};
 use cast::{transmute, transmute_mut_region};
 use ptr::null;
+use sys::size_of;
 use super::uvll;
 use super::uvll::*;
 use unstable::finally::Finally;

branches/try/src/libcore/rt/uvll.rs

@@ -32,6 +32,7 @@
 use libc::{size_t, c_int, c_uint, c_void, c_char, uintptr_t};
 use libc::{malloc, free};
 use prelude::*;
+use ptr::to_unsafe_ptr;
 
 pub struct uv_err_t {
     code: c_int,

branches/try/src/libcore/to_str.rs

@@ -29,16 +29,7 @@ impl ToStr for () {
     fn to_str(&self) -> ~str { ~"()" }
 }
 
-impl<A:ToStr> ToStr for (A,) {
-    #[inline(always)]
-    fn to_str(&self) -> ~str {
-        match *self {
-            (ref a,) => {
-                ~"(" + a.to_str() + ~", " + ~")"
-            }
-        }
-    }
-}
+// FIXME #4898: impl for one-tuples
 
 impl<A:ToStr,B:ToStr> ToStr for (A, B) {
     #[inline(always)]

branches/try/src/libcore/tuple.rs

@@ -112,45 +112,7 @@ impl<A:Copy,B:Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
     }
 }
 
-#[cfg(notest)]
-impl<A:Eq> Eq for (A,) {
-    #[inline(always)]
-    fn eq(&self, other: &(A,)) -> bool {
-        match (*self) {
-            (ref self_a,) => match other {
-                &(ref other_a,) => {
-                    (*self_a).eq(other_a)
-                }
-            }
-        }
-    }
-    #[inline(always)]
-    fn ne(&self, other: &(A,)) -> bool { !(*self).eq(other) }
-}
-
-#[cfg(notest)]
-impl<A:Ord> Ord for (A,) {
-    #[inline(always)]
-    fn lt(&self, other: &(A,)) -> bool {
-        match (*self) {
-            (ref self_a,) => {
-                match (*other) {
-                    (ref other_a,) => {
-                        if (*self_a).lt(other_a) { return true; }
-                        return false;
-                    }
-                }
-            }
-        }
-    }
-    #[inline(always)]
-    fn le(&self, other: &(A,)) -> bool { !other.lt(&(*self)) }
-    #[inline(always)]
-    fn ge(&self, other: &(A,)) -> bool { !self.lt(other) }
-    #[inline(always)]
-    fn gt(&self, other: &(A,)) -> bool { other.lt(&(*self))  }
-}
-
+// FIXME #4898: impl for one-tuples
 
 #[cfg(notest)]
 impl<A:Eq,B:Eq> Eq for (A, B) {

branches/try/src/librustc/back/link.rs

@@ -642,7 +642,7 @@ pub fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
 
 pub fn get_symbol_hash(ccx: @CrateContext, t: ty::t) -> @str {
     match ccx.type_hashcodes.find(&t) {
-      Some(&h) => h,
+      Some(h) => h,
       None => {
         let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta);
         ccx.type_hashcodes.insert(t, hash);

branches/try/src/librustc/driver/driver.rs

@@ -246,7 +246,7 @@ pub fn compile_rest(sess: Session, cfg: ast::crate_cfg,
 
         // These next two const passes can probably be merged
         time(time_passes, ~"const marking", ||
-             middle::const_eval::process_crate(crate, ty_cx));
+             middle::const_eval::process_crate(crate, def_map, ty_cx));
 
         time(time_passes, ~"const checking", ||
              middle::check_const::check_crate(sess, crate, ast_map, def_map,
@@ -546,11 +546,11 @@ pub fn build_session_options(+binary: ~str,
         let flags = vec::append(getopts::opt_strs(matches, level_short),
                                 getopts::opt_strs(matches, level_name));
         for flags.each |lint_name| {
-            let lint_name = str::replace(*lint_name, ~"-", ~"_");
+            let lint_name = @str::replace(*lint_name, ~"-", ~"_");
             match lint_dict.find(&lint_name) {
               None => {
                 early_error(demitter, fmt!("unknown %s flag: %s",
-                                           level_name, lint_name));
+                                           level_name, *lint_name));
               }
               Some(lint) => {
                 lint_opts.push((lint.lint, *level));

branches/try/src/librustc/lib/llvm.rs

@@ -10,12 +10,12 @@
 
 use core::prelude::*;
 
-use core::hashmap::linear::LinearMap;
 use core::libc::{c_char, c_int, c_uint, c_longlong, c_ulonglong};
 use core::option;
 use core::ptr;
 use core::str;
 use core::vec;
+use std::oldmap::HashMap;
 
 pub type Opcode = u32;
 pub type Bool = c_uint;
@@ -1467,8 +1467,8 @@ pub fn SetLinkage(Global: ValueRef, Link: Linkage) {
 /* Memory-managed object interface to type handles. */
 
 pub struct TypeNames {
-    type_names: @mut LinearMap<TypeRef, @str>,
-    named_types: @mut LinearMap<@str, TypeRef>
+    type_names: HashMap<TypeRef, @str>,
+    named_types: HashMap<@str, TypeRef>
 }
 
 pub fn associate_type(tn: @TypeNames, s: @str, t: TypeRef) {
@@ -1477,17 +1477,17 @@ pub fn associate_type(tn: @TypeNames, s: @str, t: TypeRef) {
 }
 
 pub fn type_has_name(tn: @TypeNames, t: TypeRef) -> Option<@str> {
-    return tn.type_names.find(&t).map_consume(|x| *x);
+    return tn.type_names.find(&t);
 }
 
 pub fn name_has_type(tn: @TypeNames, s: @str) -> Option<TypeRef> {
-    return tn.named_types.find(&s).map_consume(|x| *x);
+    return tn.named_types.find(&s);
 }
 
 pub fn mk_type_names() -> @TypeNames {
     @TypeNames {
-        type_names: @mut LinearMap::new(),
-        named_types: @mut LinearMap::new()
+        type_names: HashMap(),
+        named_types: HashMap()
     }
 }
 

branches/try/src/librustc/metadata/creader.rs

@@ -19,14 +19,14 @@ use metadata::filesearch::FileSearch;
 use metadata::loader;
 
 use core::either;
-use core::hashmap::linear::LinearMap;
 use core::vec;
 use syntax::attr;
 use syntax::codemap::{span, dummy_sp};
 use syntax::diagnostic::span_handler;
 use syntax::parse::token::ident_interner;
 use syntax::visit;
 use syntax::{ast, ast_util};
+use std::oldmap::HashMap;
 
 // Traverses an AST, reading all the information about use'd crates and extern
 // libraries necessary for later resolving, typechecking, linking, etc.
@@ -307,7 +307,7 @@ fn resolve_crate_deps(e: @mut Env, cdata: @~[u8]) -> cstore::cnum_map {
     debug!("resolving deps of external crate");
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
-    let mut cnum_map = LinearMap::new();
+    let cnum_map = HashMap();
     for decoder::get_crate_deps(e.intr, cdata).each |dep| {
         let extrn_cnum = dep.cnum;
         let cname = dep.name;
@@ -334,7 +334,7 @@ fn resolve_crate_deps(e: @mut Env, cdata: @~[u8]) -> cstore::cnum_map {
           }
         }
     }
-    return @mut cnum_map;
+    return cnum_map;
 }
 
 // Local Variables: