---

yaml
---
r: 56205
b: refs/heads/auto
c: d32d4d1
h: refs/heads/master
i:
  56203: 1ec531e
v: v3

Author: bors

[refs]

@@ -14,6 +14,6 @@ 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: 6030e3982a52c8d9ede225f992088bb75fba4ef1
+refs/heads/auto: d32d4d12096dc39ff428f606e2242eaae0c6a0de
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/.gitignore

@@ -86,3 +86,4 @@ config.stamp
 .DS_Store
 src/etc/dl
 .settings/
+build/

branches/auto/src/libcore/vec.rs

@@ -18,6 +18,10 @@ use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 use clone::Clone;
 use iter::BaseIter;
 use iter;
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+use iterator::Iterator;
 use kinds::Copy;
 use libc;
 use option::{None, Option, Some};
@@ -1919,6 +1923,7 @@ impl<'self,T> ImmutableVector<T> for &'self [T] {
 #[cfg(stage3)]
 pub trait ImmutableVector<'self, T> {
     fn slice(&self, start: uint, end: uint) -> &'self [T];
+    fn iter(self) -> VecIterator<'self, T>;
     fn head(&self) -> &'self T;
     fn head_opt(&self) -> Option<&'self T>;
     fn tail(&self) -> &'self [T];
@@ -1949,6 +1954,15 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
         slice(*self, start, end)
     }
 
+    #[inline]
+    fn iter(self) -> VecIterator<'self, T> {
+        unsafe {
+            let p = vec::raw::to_ptr(self);
+            VecIterator{ptr: p, end: p.offset(self.len()),
+                        lifetime: cast::transmute(p)}
+        }
+    }
+
     /// Returns the first element of a vector, failing if the vector is empty.
     #[inline]
     fn head(&self) -> &'self T { head(*self) }
@@ -2795,7 +2809,33 @@ impl<A:Clone> Clone for ~[A] {
     }
 }
 
-// ___________________________________________________________________________
+// could be implemented with &[T] with .slice(), but this avoids bounds checks
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+pub struct VecIterator<'self, T> {
+    priv ptr: *T,
+    priv end: *T,
+    priv lifetime: &'self T // FIXME: #5922
+}
+
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+impl<'self, T> Iterator<&'self T> for VecIterator<'self, T> {
+    #[inline]
+    fn next(&mut self) -> Option<&'self T> {
+        unsafe {
+            if self.ptr == self.end {
+                None
+            } else {
+                let old = self.ptr;
+                self.ptr = self.ptr.offset(1);
+                Some(cast::transmute(old))
+            }
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {
@@ -4421,6 +4461,19 @@ mod tests {
         [1, 2, 3, 4, 5, 5, 5, 5].cmp(& &[1, 2, 3, 4, 5, 6]) == Less;
         [2, 2].cmp(& &[1, 2, 3, 4]) == Greater;
     }
+
+    #[test]
+    fn test_iterator() {
+        use iterator::*;
+        let xs = [1, 2, 5, 10, 11];
+        let ys = [1, 2, 5, 10, 11, 19];
+        let mut it = xs.iter();
+        let mut i = 0;
+        for it.advance |&x| {
+            assert_eq!(x, ys[i]);
+            i += 1;
+        }
+    }
 }
 
 // Local Variables:

branches/auto/src/libsyntax/diagnostic.rs

@@ -33,7 +33,6 @@ pub trait handler {
     fn bump_err_count(@mut self);
     fn has_errors(@mut self) -> bool;
     fn abort_if_errors(@mut self);
-    fn abort_error_print(@mut self);
     fn warn(@mut self, msg: &str);
     fn note(@mut self, msg: &str);
     // used to indicate a bug in the compiler:
@@ -43,7 +42,6 @@ pub trait handler {
             cmsp: Option<(@codemap::CodeMap, span)>,
             msg: &str,
             lvl: level);
-    fn emit_print(@mut self, lvl: level);
 }
 
 // a span-handler is like a handler but also
@@ -59,15 +57,8 @@ pub trait span_handler {
     fn handler(@mut self) -> @handler;
 }
 
-struct emitter_arg {
-    cmsp: Option<(@codemap::CodeMap, span)>,
-    msg: ~str,
-    lvl: level,
-}
-
 struct HandlerT {
     err_count: uint,
-    emitters: ~[emitter_arg],
     emit: Emitter,
 }
 
@@ -78,19 +69,15 @@ struct CodemapT {
 
 impl span_handler for CodemapT {
     fn span_fatal(@mut self, sp: span, msg: &str) -> ! {
-        self.handler.bump_err_count();
         self.handler.emit(Some((self.cm, sp)), msg, fatal);
-        self.handler.emit_print(error);
-        self.handler.emit_print(note);
-        self.handler.abort_error_print();
         fail!();
     }
     fn span_err(@mut self, sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, error);
         self.handler.bump_err_count();
     }
     fn span_warn(@mut self, sp: span, msg: &str) {
-        emit_one(Some((self.cm, sp)), msg, warning);
+        self.handler.emit(Some((self.cm, sp)), msg, warning);
     }
     fn span_note(@mut self, sp: span, msg: &str) {
         self.handler.emit(Some((self.cm, sp)), msg, note);
@@ -108,13 +95,11 @@ impl span_handler for CodemapT {
 
 impl handler for HandlerT {
     fn fatal(@mut self, msg: &str) -> ! {
-        self.emit_print(error);
-        self.emit_print(note);
-        emit_one(None, msg, fatal);
+        (self.emit)(None, msg, fatal);
         fail!();
     }
     fn err(@mut self, msg: &str) {
-        emit_one(None, msg, error);
+        (self.emit)(None, msg, error);
         self.bump_err_count();
     }
     fn bump_err_count(@mut self) {
@@ -133,26 +118,13 @@ impl handler for HandlerT {
         }
         self.fatal(s);
     }
-    fn abort_error_print(@mut self) {
-        let s;
-        match self.err_count {
-          0u => return,
-          1u => s = ~"aborting due to previous error",
-          _  => {
-            s = fmt!("aborting due to %u previous errors",
-                     self.err_count);
-          }
-        }
-        emit_one(None, s, fatal);
-    }
     fn warn(@mut self, msg: &str) {
-        emit_one(None, msg, warning);
+        (self.emit)(None, msg, warning);
     }
     fn note(@mut self, msg: &str) {
-        self.emit(None, msg, note);
+        (self.emit)(None, msg, note);
     }
     fn bug(@mut self, msg: &str) -> ! {
-        self.bump_err_count();
         self.fatal(ice_msg(msg));
     }
     fn unimpl(@mut self, msg: &str) -> ! {
@@ -163,50 +135,6 @@ impl handler for HandlerT {
             msg: &str,
             lvl: level) {
         (self.emit)(cmsp, msg, lvl);
-        let emitter = emitter_arg { cmsp: cmsp,
-                                    msg: str::from_slice(msg),
-                                    lvl: lvl };
-        self.emitters.push(emitter);
-    }
-
-    fn emit_print(@mut self, lvl: level) {
-        let mut old_cmsp = None;
-        let mut old_line = 0u;
-
-        let emitters = self.emitters;
-        let length = emitters.len();
-        for uint::range(0, length) |i| {
-            let emitter = copy self.emitters[i];
-            let cmsp = emitter.cmsp;
-            let msg = emitter.msg;
-            if diagnosticstr(lvl) == diagnosticstr(emitter.lvl) {
-                match cmsp {
-                    Some((cm, sp)) => {
-                            let lo = cm.lookup_char_pos_adj(sp.lo);
-                            let sp = cm.adjust_span(sp);
-                            let ss = cm.span_to_str(sp);
-                            if i == 0 || old_line == lo.line {
-                                if old_line == lo.line {
-                                    highlight_lines_cmp(cmsp, old_cmsp);
-                                }
-                                print_diagnostic(ss, lvl, msg);
-                                highlight_lines_cmp(old_cmsp, cmsp);
-                            } else {
-                                highlight_lines(old_cmsp);
-                                print_macro_backtrace(old_cmsp);
-                                print_diagnostic(ss, lvl, msg);
-                            }
-                            old_line = lo.line;
-                            old_cmsp = emitter.cmsp;
-                    }
-                    None => {
-                        print_diagnostic(~"", lvl, msg);
-                    }
-                }
-            }
-        }
-        highlight_lines(old_cmsp);
-        print_macro_backtrace(old_cmsp);
     }
 }
 
@@ -228,9 +156,7 @@ pub fn mk_handler(emitter: Option<Emitter>) -> @handler {
         }
     };
 
-    @mut HandlerT { err_count: 0,
-                    emitters: ~[],
-                    emit: emit } as @handler
+    @mut HandlerT { err_count: 0, emit: emit } as @handler
 }
 
 #[deriving(Eq)]
@@ -282,27 +208,23 @@ pub fn collect(messages: @mut ~[~str])
     f
 }
 
-pub fn emit(_cmsp: Option<(@codemap::CodeMap, span)>, _msg: &str, _lvl: level) {
-    // Nothing to do
-}
-
-pub fn emit_one(cmsp: Option<(@codemap::CodeMap, span)>,
-        msg: &str, lvl: level) {
+pub fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level) {
     match cmsp {
       Some((cm, sp)) => {
         let sp = cm.adjust_span(sp);
         let ss = cm.span_to_str(sp);
+        let lines = cm.span_to_lines(sp);
         print_diagnostic(ss, lvl, msg);
-        highlight_lines(cmsp);
-        print_macro_backtrace(cmsp);
+        highlight_lines(cm, sp, lines);
+        print_macro_backtrace(cm, sp);
       }
       None => {
         print_diagnostic(~"", lvl, msg);
       }
     }
 }
 
-fn highlight_lines_internal(cm: @codemap::CodeMap,
+fn highlight_lines(cm: @codemap::CodeMap,
                    sp: span,
                    lines: @codemap::FileLines) {
     let fm = lines.file;
@@ -369,70 +291,14 @@ fn highlight_lines_internal(cm: @codemap::CodeMap,
     }
 }
 
-fn highlight_lines(cmsp: Option<(@codemap::CodeMap, span)>) {
-    match cmsp {
-        Some((cm, sp)) => {
-            let sp = cm.adjust_span(sp);
-            let lines = cm.span_to_lines(sp);
-            highlight_lines_internal(cm, sp, lines);
-        }
-        None => ()
-    }
-}
-
-fn highlight_lines_cmp(old_cmsp: Option<(@codemap::CodeMap, span)>,
-                       cmsp: Option<(@codemap::CodeMap, span)> ){
-    let mut old_line = ~[];
-    let mut new_line = ~[];
-    let mut old_lo = 0u;
-    let mut new_lo = 0u;
-    let mut flag = true;
-    match old_cmsp {
-        Some((cm, sp)) => {
-            let lo = cm.lookup_char_pos(sp.lo);
-            let sp = cm.adjust_span(sp);
-            let lines = cm.span_to_lines(sp);
-            old_line = lines.lines;
-            old_lo = lo.col.to_uint();
-        }
-        None => { flag = false; }
-    }
-
-    match cmsp {
-        Some((cm, sp)) => {
-            let lo = cm.lookup_char_pos(sp.lo);
-            let sp = cm.adjust_span(sp);
-            let lines = cm.span_to_lines(sp);
-            new_line = lines.lines;
-            new_lo = lo.col.to_uint();
-        }
-        None => { flag = false; }
-    }
-
-    if flag {
-        if old_line == new_line && old_lo > new_lo {
-            highlight_lines(cmsp);
-        }
-    }
-}
-
-fn print_macro_backtrace_internal(cm: @codemap::CodeMap, sp: span) {
+fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
     for sp.expn_info.each |ei| {
         let ss = ei.callee.span.map_default(@~"", |span| @cm.span_to_str(*span));
         print_diagnostic(*ss, note,
                          fmt!("in expansion of %s!", ei.callee.name));
         let ss = cm.span_to_str(ei.call_site);
         print_diagnostic(ss, note, ~"expansion site");
-        print_macro_backtrace_internal(cm, ei.call_site);
-    }
-}
-
-fn print_macro_backtrace(cmsp: Option<(@codemap::CodeMap, span)>) {
-    match cmsp {
-        Some((cm, sp)) => {
-            print_macro_backtrace_internal(cm, sp);
-        }
-        None => ()
+        print_macro_backtrace(cm, ei.call_site);
     }
 }