---

yaml
---
r: 144893
b: refs/heads/try2
c: 0fcb859
h: refs/heads/master
i:
  144891: d2508f7
v: v3

Author: brendanzab

[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: 7e2827b99deb70196a32c3df716baccc763fe6c6
+refs/heads/try2: 0fcb85997db852350c104b40e3d7c78214bb0708
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial-container.md

@@ -200,7 +200,7 @@ for i in range(0, 5) {
   printf!("%d ", i) // prints "0 1 2 3 4"
 }
 
-for i in std::iter::range_inclusive(0, 5) { // needs explicit import
+for i in std::iterator::range_inclusive(0, 5) { // needs explicit import
   printf!("%d ", i) // prints "0 1 2 3 4 5"
 }
 ~~~

branches/try2/src/etc/unicode.py

@@ -310,7 +310,7 @@ def emit_decomp_module(f, canon, compat, combine):
         + "        bsearch_range_value_table(c, combining_class_table)\n"
         + "    }\n\n")
     f.write("    fn d(c: char, i: &fn(char), k: bool) {\n")
-    f.write("        use iter::Iterator;\n");
+    f.write("        use iterator::Iterator;\n");
 
     f.write("        if c <= '\\x7f' { i(c); return; }\n")
 

branches/try2/src/libextra/bitv.rs

@@ -12,8 +12,8 @@
 
 
 use std::cmp;
-use std::iter::RandomAccessIterator;
-use std::iter::{Invert, Enumerate, Repeat, Map, Zip};
+use std::iterator::RandomAccessIterator;
+use std::iterator::{Invert, Enumerate, Repeat, Map, Zip};
 use std::num;
 use std::ops;
 use std::uint;

branches/try2/src/libextra/dlist.rs

@@ -25,8 +25,8 @@
 use std::cast;
 use std::ptr;
 use std::util;
-use std::iter::Invert;
-use std::iter;
+use std::iterator::{FromIterator, Extendable, Invert};
+use std::iterator;
 
 use container::Deque;
 
@@ -593,27 +593,27 @@ impl<A> Extendable<A> for DList<A> {
 impl<A: Eq> Eq for DList<A> {
     fn eq(&self, other: &DList<A>) -> bool {
         self.len() == other.len() &&
-            iter::order::eq(self.iter(), other.iter())
+            iterator::order::eq(self.iter(), other.iter())
     }
 
     fn ne(&self, other: &DList<A>) -> bool {
         self.len() != other.len() ||
-            iter::order::ne(self.iter(), other.iter())
+            iterator::order::ne(self.iter(), other.iter())
     }
 }
 
 impl<A: Eq + Ord> Ord for DList<A> {
     fn lt(&self, other: &DList<A>) -> bool {
-        iter::order::lt(self.iter(), other.iter())
+        iterator::order::lt(self.iter(), other.iter())
     }
     fn le(&self, other: &DList<A>) -> bool {
-        iter::order::le(self.iter(), other.iter())
+        iterator::order::le(self.iter(), other.iter())
     }
     fn gt(&self, other: &DList<A>) -> bool {
-        iter::order::gt(self.iter(), other.iter())
+        iterator::order::gt(self.iter(), other.iter())
     }
     fn ge(&self, other: &DList<A>) -> bool {
-        iter::order::ge(self.iter(), other.iter())
+        iterator::order::ge(self.iter(), other.iter())
     }
 }
 

branches/try2/src/libextra/enum_set.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::iterator::Iterator;
+
 #[deriving(Clone, Eq, IterBytes, ToStr)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {

branches/try2/src/libextra/json.rs

@@ -18,6 +18,7 @@
 
 use std::char;
 use std::cast::transmute;
+use std::iterator;
 use std::float;
 use std::hashmap::HashMap;
 use std::io::WriterUtil;
@@ -488,7 +489,7 @@ pub struct Parser<T> {
 }
 
 /// Decode a json value from an Iterator<char>
-pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> {
+pub fn Parser<T : iterator::Iterator<char>>(rdr: ~T) -> Parser<T> {
     let mut p = Parser {
         rdr: rdr,
         ch: '\x00',
@@ -499,7 +500,7 @@ pub fn Parser<T : Iterator<char>>(rdr: ~T) -> Parser<T> {
     p
 }
 
-impl<T: Iterator<char>> Parser<T> {
+impl<T: iterator::Iterator<char>> Parser<T> {
     pub fn parse(&mut self) -> Result<Json, Error> {
         match self.parse_value() {
           Ok(value) => {
@@ -517,7 +518,7 @@ impl<T: Iterator<char>> Parser<T> {
     }
 }
 
-impl<T : Iterator<char>> Parser<T> {
+impl<T : iterator::Iterator<char>> Parser<T> {
     // FIXME: #8971: unsound
     fn eof(&self) -> bool { self.ch == unsafe { transmute(-1u32) } }
 

branches/try2/src/libextra/num/bigint.rs

@@ -2011,13 +2011,13 @@ mod bigint_tests {
 #[cfg(test)]
 mod bench {
     use super::*;
-    use std::{iter, util};
+    use std::{iterator, util};
     use std::num::{Zero, One};
     use extra::test::BenchHarness;
 
     fn factorial(n: uint) -> BigUint {
         let mut f: BigUint = One::one();
-        for i in iter::range_inclusive(1, n) {
+        for i in iterator::range_inclusive(1, n) {
             f = f * BigUint::from_uint(i);
         }
         f

branches/try2/src/libextra/priority_queue.rs

@@ -16,6 +16,7 @@ use std::clone::Clone;
 use std::unstable::intrinsics::{move_val_init, init};
 use std::util::{replace, swap};
 use std::vec;
+use std::iterator::{FromIterator, Extendable};
 
 /// A priority queue implemented with a binary heap
 #[deriving(Clone)]

branches/try2/src/libextra/ringbuf.rs

@@ -15,7 +15,7 @@
 
 use std::num;
 use std::vec;
-use std::iter::{Invert, RandomAccessIterator};
+use std::iterator::{FromIterator, Invert, RandomAccessIterator, Extendable};
 
 use container::Deque;
 
@@ -694,13 +694,13 @@ mod tests {
 
     #[test]
     fn test_from_iterator() {
-        use std::iter;
+        use std::iterator;
         let v = ~[1,2,3,4,5,6,7];
         let deq: RingBuf<int> = v.iter().map(|&x| x).collect();
         let u: ~[int] = deq.iter().map(|&x| x).collect();
         assert_eq!(u, v);
 
-        let mut seq = iter::count(0u, 2).take(256);
+        let mut seq = iterator::count(0u, 2).take(256);
         let deq: RingBuf<uint> = seq.collect();
         for (i, &x) in deq.iter().enumerate() {
             assert_eq!(2*i, x);

branches/try2/src/libextra/smallintmap.rs

@@ -15,7 +15,7 @@
 
 #[allow(missing_doc)];
 
-use std::iter::{Enumerate, FilterMap, Invert};
+use std::iterator::{Iterator, Enumerate, FilterMap, Invert};
 use std::util::replace;
 use std::vec::{VecIterator, VecMutIterator};
 use std::vec;

branches/try2/src/libextra/treemap.rs

@@ -14,7 +14,7 @@
 
 
 use std::util::{swap, replace};
-use std::iter::{Peekable};
+use std::iterator::{FromIterator, Extendable, Peekable};
 use std::cmp::Ordering;
 
 // This is implemented as an AA tree, which is a simplified variation of

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

@@ -39,6 +39,7 @@ use syntax::ast_map::{path, path_mod, path_name, path_pretty_name};
 use syntax::attr;
 use syntax::attr::{AttrMetaMethods};
 use syntax::print::pprust;
+use syntax::parse::token;
 
 #[deriving(Clone, Eq)]
 pub enum output_type {
@@ -677,8 +678,8 @@ pub fn symbol_hash(tcx: ty::ctxt,
     write_string(symbol_hasher, "-");
     write_string(symbol_hasher, encoder::encoded_ty(tcx, t));
     let mut hash = truncated_hash_result(symbol_hasher);
-    // Prefix with 'h' so that it never blends into adjacent digits
-    hash.unshift_char('h');
+    // Prefix with _ so that it never blends into adjacent digits
+    hash.unshift_char('_');
     // tjc: allocation is unfortunate; need to change std::hash
     hash.to_managed()
 }
@@ -721,7 +722,7 @@ pub fn sanitize(s: &str) -> ~str {
             'a' .. 'z'
             | 'A' .. 'Z'
             | '0' .. '9'
-            | '_' | '.' | '$' => result.push_char(c),
+            | '_' | '.' => result.push_char(c),
 
             _ => {
                 let mut tstr = ~"";
@@ -846,25 +847,28 @@ pub fn mangle_internal_name_by_type_and_seq(ccx: &mut CrateContext,
                                             name: &str) -> ~str {
     let s = ppaux::ty_to_str(ccx.tcx, t);
     let hash = get_symbol_hash(ccx, t);
-    let (_, name) = gensym_name(name);
     return mangle(ccx.sess,
-                  ~[path_name(ccx.sess.ident_of(s)), name],
+                  ~[path_name(ccx.sess.ident_of(s)),
+                    path_name(gensym_name(name))],
                   Some(hash.as_slice()),
                   None);
 }
 
 pub fn mangle_internal_name_by_path_and_seq(ccx: &mut CrateContext,
                                             mut path: path,
                                             flav: &str) -> ~str {
-    let (_, name) = gensym_name(flav);
-    path.push(name);
+    path.push(path_name(gensym_name(flav)));
     mangle(ccx.sess, path, None, None)
 }
 
 pub fn mangle_internal_name_by_path(ccx: &mut CrateContext, path: path) -> ~str {
     mangle(ccx.sess, path, None, None)
 }
 
+pub fn mangle_internal_name_by_seq(_ccx: &mut CrateContext, flav: &str) -> ~str {
+    return fmt!("%s_%u", flav, token::gensym(flav));
+}
+
 
 pub fn output_dll_filename(os: session::Os, lm: LinkMeta) -> ~str {
     let (dll_prefix, dll_suffix) = match os {

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

@@ -1063,13 +1063,12 @@ fn encode_info_for_item(ecx: &EncodeContext,
             let impl_vtables = ty::lookup_impl_vtables(tcx, def_id);
             encode_impl_vtables(ebml_w, ecx, &impl_vtables);
         }
-        let elt = ast_map::impl_pretty_name(opt_trait, ty, item.ident);
-        encode_path(ecx, ebml_w, path, elt);
+        encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         ebml_w.end_tag();
 
         // >:-<
         let mut impl_path = vec::append(~[], path);
-        impl_path.push(elt);
+        impl_path.push(ast_map::path_name(item.ident));
 
         // Iterate down the methods, emitting them. We rely on the
         // assumption that all of the actually implemented methods

branches/try2/src/librustc/middle/check_match.rs

@@ -18,7 +18,7 @@ use middle::typeck::method_map;
 use middle::moves;
 use util::ppaux::ty_to_str;
 
-use std::iter;
+use std::iterator;
 use std::num;
 use std::vec;
 use extra::sort;
@@ -282,7 +282,7 @@ pub fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful {
                     _ => max_len
                   }
                 };
-                for n in iter::range(0u, max_len + 1) {
+                for n in iterator::range(0u, max_len + 1) {
                   match is_useful_specialized(cx, m, v, vec(n), n, left_ty) {
                     not_useful => (),
                     ref u => return *u,

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

@@ -10,7 +10,7 @@
 
 use lib::llvm::{llvm, BasicBlockRef};
 use middle::trans::value::{UserIterator, Value};
-use std::iter::{Filter, Map};
+use std::iterator::{Filter, Map};
 
 pub struct BasicBlock(BasicBlockRef);
 

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

@@ -39,17 +39,15 @@ use std::hashmap::{HashMap};
 use std::libc::{c_uint, c_longlong, c_ulonglong, c_char};
 use std::vec;
 use syntax::ast::Ident;
-use syntax::ast_map::{path, path_elt, path_pretty_name};
+use syntax::ast_map::{path, path_elt};
 use syntax::codemap::Span;
 use syntax::parse::token;
 use syntax::{ast, ast_map};
 
 pub use middle::trans::context::CrateContext;
 
-pub fn gensym_name(name: &str) -> (Ident, path_elt) {
-    let name = token::gensym(name);
-    let ident = Ident::new(name);
-    (ident, path_pretty_name(ident, name as u64))
+pub fn gensym_name(name: &str) -> Ident {
+    token::str_to_ident(fmt!("%s_%u", name, token::gensym(name)))
 }
 
 pub struct tydesc_info {

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

@@ -69,7 +69,6 @@ use std::ptr;
 use std::vec;
 use syntax::codemap::Span;
 use syntax::{ast, codemap, ast_util, ast_map, opt_vec};
-use syntax::parse::token;
 use syntax::parse::token::special_idents;
 
 static DW_LANG_RUST: c_uint = 0x9000;
@@ -514,8 +513,7 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
         ast_map::node_expr(ref expr) => {
             match expr.node {
                 ast::ExprFnBlock(ref fn_decl, ref top_level_block) => {
-                    let name = fmt!("fn%u", token::gensym("fn"));
-                    let name = token::str_to_ident(name);
+                    let name = gensym_name("fn");
                     (name, fn_decl,
                         // This is not quite right. It should actually inherit the generics of the
                         // enclosing function.
@@ -2064,7 +2062,7 @@ fn populate_scope_map(cx: &mut CrateContext,
                 }
             }
 
-            ast::ExprForLoop(_, _, _, _) => {
+            ast::ExprForLoop(_, _, _) => {
                 cx.sess.span_bug(exp.span, "debuginfo::populate_scope_map() - \
                                             Found unexpanded for-loop.");
             }

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

@@ -37,7 +37,6 @@ use std::vec;
 use syntax::ast_map::{path, path_mod, path_name, path_pretty_name};
 use syntax::ast_util;
 use syntax::{ast, ast_map};
-use syntax::parse::token;
 use syntax::visit;
 
 /**
@@ -569,8 +568,8 @@ pub fn make_vtable(ccx: &mut CrateContext,
         }
 
         let tbl = C_struct(components);
-        let sym = token::gensym("vtable");
-        let vt_gvar = do fmt!("vtable%u", sym).with_c_str |buf| {
+        let vtable = ccx.sess.str_of(gensym_name("vtable"));
+        let vt_gvar = do vtable.with_c_str |buf| {
             llvm::LLVMAddGlobal(ccx.llmod, val_ty(tbl).to_ref(), buf)
         };
         llvm::LLVMSetInitializer(vt_gvar, tbl);

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

@@ -31,6 +31,7 @@ use util::ppaux::{Repr,ty_to_str};
 
 use syntax::ast;
 use syntax::ast_map;
+use syntax::ast_map::path_name;
 use syntax::ast_util::local_def;
 
 pub fn monomorphic_fn(ccx: @mut CrateContext,
@@ -193,7 +194,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
     }
     ccx.monomorphizing.insert(fn_id, depth + 1);
 
-    let (_, elt) = gensym_name(ccx.sess.str_of(name));
+    let elt = path_name(gensym_name(ccx.sess.str_of(name)));
     let mut pt = (*pt).clone();
     pt.push(elt);
     let s = mangle_exported_name(ccx, pt.clone(), mono_ty);

branches/try2/src/libstd/at_vec.rs

@@ -12,7 +12,7 @@
 
 use clone::Clone;
 use container::Container;
-use iter::Iterator;
+use iterator::Iterator;
 use option::{Option, Some, None};
 use sys;
 use unstable::raw::Repr;