---

yaml
---
r: 13777
b: refs/heads/try
c: 3b9a9fc
h: refs/heads/master
i:
  13775: 575e160
v: v3

Author: yeahwhatever

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: eaa4befd6df4a26be0776d6aab0a7925232d76a7
+refs/heads/try: 3b9a9fce49d4c0ad5247ca04f2d2cb89ff8c001a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/doc/tutorial.md

@@ -1346,7 +1346,7 @@ destructors. Resources might go away in the future.
 Rust datatypes are not trivial to copy (the way, for example,
 JavaScript values can be copied by simply taking one or two machine
 words and plunking them somewhere else). Shared boxes require
-reference count updates, big records, tags, or unique pointers require
+reference count updates, big records, enums, or unique pointers require
 an arbitrary amount of data to be copied (plus updating the reference
 counts of shared boxes hanging off them).
 
@@ -1459,7 +1459,7 @@ alt my_rec {
 
 The fact that arguments are conceptually passed by safe reference does
 not mean all arguments are passed by pointer. Composite types like
-records and tags *are* passed by pointer, but single-word values, like
+records and enums *are* passed by pointer, but single-word values, like
 integers and pointers, are simply passed by value. Most of the time,
 the programmer does not have to worry about this, as the compiler will
 simply pick the most efficient passing style. There is one exception,

branches/try/src/cargo/cargo.rs

@@ -100,10 +100,11 @@ fn load_link(mis: [@ast::meta_item]) -> (option::t<str>,
 
 fn load_pkg(filename: str) -> option::t<pkg> {
     let cm = codemap::new_codemap();
+    let handler = diagnostic::mk_handler(none);
     let sess = @{
         cm: cm,
         mutable next_id: 1,
-        diagnostic: diagnostic::mk_handler(cm, none),
+        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
         mutable chpos: 0u,
         mutable byte_pos: 0u
     };

branches/try/src/comp/driver/diagnostic.rs

@@ -5,51 +5,83 @@ import codemap::span;
 
 export emitter, emit;
 export level, fatal, error, warning, note;
-export handler, mk_handler;
+export span_handler, handler, mk_span_handler, mk_handler;
+export codemap_span_handler, codemap_handler;
 export ice_msg;
 
 type emitter = fn@(cmsp: option<(codemap::codemap, span)>,
                    msg: str, lvl: level);
 
 
-iface handler {
+iface span_handler {
     fn span_fatal(sp: span, msg: str) -> !;
-    fn fatal(msg: str) -> !;
     fn span_err(sp: span, msg: str);
+    fn span_warn(sp: span, msg: str);
+    fn span_note(sp: span, msg: str);
+    fn span_bug(sp: span, msg: str) -> !;
+    fn span_unimpl(sp: span, msg: str) -> !;
+    fn handler() -> handler;
+}
+
+iface handler {
+    fn fatal(msg: str) -> !;
     fn err(msg: str);
+    fn bump_err_count();
     fn has_errors() -> bool;
     fn abort_if_errors();
-    fn span_warn(sp: span, msg: str);
     fn warn(msg: str);
-    fn span_note(sp: span, msg: str);
     fn note(msg: str);
-    fn span_bug(sp: span, msg: str) -> !;
     fn bug(msg: str) -> !;
-    fn span_unimpl(sp: span, msg: str) -> !;
     fn unimpl(msg: str) -> !;
+    fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level);
 }
 
-type codemap_t = @{
-    cm: codemap::codemap,
+type handler_t = @{
     mutable err_count: uint,
-    emit: emitter
+    _emit: emitter
+};
+
+type codemap_t = @{
+    handler: handler,
+    cm: codemap::codemap
 };
 
-impl codemap_handler of handler for codemap_t {
+impl codemap_span_handler of span_handler for codemap_t {
     fn span_fatal(sp: span, msg: str) -> ! {
-        self.emit(some((self.cm, sp)), msg, fatal);
+        self.handler.emit(some((self.cm, sp)), msg, fatal);
         fail;
     }
+    fn span_err(sp: span, msg: str) {
+        self.handler.emit(some((self.cm, sp)), msg, error);
+        self.handler.bump_err_count();
+    }
+    fn span_warn(sp: span, msg: str) {
+        self.handler.emit(some((self.cm, sp)), msg, warning);
+    }
+    fn span_note(sp: span, msg: str) {
+        self.handler.emit(some((self.cm, sp)), msg, note);
+    }
+    fn span_bug(sp: span, msg: str) -> ! {
+        self.span_fatal(sp, ice_msg(msg));
+    }
+    fn span_unimpl(sp: span, msg: str) -> ! {
+        self.span_bug(sp, "unimplemented " + msg);
+    }
+    fn handler() -> handler {
+        self.handler
+    }
+}
+
+impl codemap_handler of handler for handler_t {
     fn fatal(msg: str) -> ! {
-        self.emit(none, msg, fatal);
+        self._emit(none, msg, fatal);
         fail;
     }
-    fn span_err(sp: span, msg: str) {
-        self.emit(some((self.cm, sp)), msg, error);
-        self.err_count += 1u;
-    }
     fn err(msg: str) {
-        self.emit(none, msg, error);
+        self._emit(none, msg, error);
+        self.bump_err_count();
+    }
+    fn bump_err_count() {
         self.err_count += 1u;
     }
     fn has_errors() -> bool { self.err_count > 0u }
@@ -58,36 +90,30 @@ impl codemap_handler of handler for codemap_t {
             self.fatal("aborting due to previous errors");
         }
     }
-    fn span_warn(sp: span, msg: str) {
-        self.emit(some((self.cm, sp)), msg, warning);
-    }
     fn warn(msg: str) {
-        self.emit(none, msg, warning);
-    }
-    fn span_note(sp: span, msg: str) {
-        self.emit(some((self.cm, sp)), msg, note);
+        self._emit(none, msg, warning);
     }
     fn note(msg: str) {
-        self.emit(none, msg, note);
-    }
-    fn span_bug(sp: span, msg: str) -> ! {
-        self.span_fatal(sp, ice_msg(msg));
+        self._emit(none, msg, note);
     }
     fn bug(msg: str) -> ! {
         self.fatal(ice_msg(msg));
     }
-    fn span_unimpl(sp: span, msg: str) -> ! {
-        self.span_bug(sp, "unimplemented " + msg);
-    }
     fn unimpl(msg: str) -> ! { self.bug("unimplemented " + msg); }
+    fn emit(cmsp: option<(codemap::codemap, span)>, msg: str, lvl: level) {
+        self._emit(cmsp, msg, lvl);
+    }
 }
 
 fn ice_msg(msg: str) -> str {
     #fmt["internal compiler error %s", msg]
 }
 
-fn mk_handler(cm: codemap::codemap,
-              emitter: option<emitter>) -> handler {
+fn mk_span_handler(handler: handler, cm: codemap::codemap) -> span_handler {
+    @{ handler: handler, cm: cm } as span_handler
+}
+
+fn mk_handler(emitter: option<emitter>) -> handler {
 
     let emit = alt emitter {
       some(e) { e }
@@ -101,9 +127,8 @@ fn mk_handler(cm: codemap::codemap,
     };
 
     @{
-        cm: cm,
         mutable err_count: 0u,
-        emit: emit
+        _emit: emit
     } as handler
 }
 

branches/try/src/comp/driver/driver.rs

@@ -299,7 +299,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
       }
       ppm_expanded | ppm_normal {}
     }
-    pprust::print_crate(sess.codemap, sess.diagnostic, crate, input,
+    pprust::print_crate(sess.codemap, sess.span_diagnostic, crate, input,
                         io::string_reader(src), io::stdout(), ann);
 }
 
@@ -481,21 +481,23 @@ fn build_session(sopts: @session::options, input: str,
         sopts.addl_lib_search_paths);
     let codemap = codemap::new_codemap();
     let diagnostic_handler =
-        diagnostic::mk_handler(codemap, some(demitter));
+        diagnostic::mk_handler(some(demitter));
+    let span_diagnostic_handler =
+        diagnostic::mk_span_handler(diagnostic_handler, codemap);
     @{targ_cfg: target_cfg,
       opts: sopts,
       cstore: cstore,
       parse_sess: @{
           cm: codemap,
           mutable next_id: 1,
-          diagnostic: diagnostic_handler,
+          span_diagnostic: span_diagnostic_handler,
           mutable chpos: 0u,
           mutable byte_pos: 0u
       },
       codemap: codemap,
       // For a library crate, this is always none
       mutable main_fn: none,
-      diagnostic: diagnostic_handler,
+      span_diagnostic: span_diagnostic_handler,
       filesearch: filesearch,
       mutable building_library: false,
       working_dir: fs::dirname(input)}

branches/try/src/comp/driver/session.rs

@@ -60,53 +60,53 @@ type session = @{targ_cfg: @config,
                  codemap: codemap::codemap,
                  // For a library crate, this is always none
                  mutable main_fn: option::t<node_id>,
-                 diagnostic: diagnostic::handler,
+                 span_diagnostic: diagnostic::span_handler,
                  filesearch: filesearch::filesearch,
                  mutable building_library: bool,
                  working_dir: str};
 
 impl session for session {
     fn span_fatal(sp: span, msg: str) -> ! {
-        self.diagnostic.span_fatal(sp, msg)
+        self.span_diagnostic.span_fatal(sp, msg)
     }
     fn fatal(msg: str) -> ! {
-        self.diagnostic.fatal(msg)
+        self.span_diagnostic.handler().fatal(msg)
     }
     fn span_err(sp: span, msg: str) {
-        self.diagnostic.span_err(sp, msg)
+        self.span_diagnostic.span_err(sp, msg)
     }
     fn err(msg: str) {
-        self.diagnostic.err(msg)
+        self.span_diagnostic.handler().err(msg)
     }
     fn has_errors() -> bool {
-        self.diagnostic.has_errors()
+        self.span_diagnostic.handler().has_errors()
     }
     fn abort_if_errors() {
-        self.diagnostic.abort_if_errors()
+        self.span_diagnostic.handler().abort_if_errors()
     }
     fn span_warn(sp: span, msg: str) {
-        self.diagnostic.span_warn(sp, msg)
+        self.span_diagnostic.span_warn(sp, msg)
     }
     fn warn(msg: str) {
-        self.diagnostic.warn(msg)
+        self.span_diagnostic.handler().warn(msg)
     }
     fn span_note(sp: span, msg: str) {
-        self.diagnostic.span_note(sp, msg)
+        self.span_diagnostic.span_note(sp, msg)
     }
     fn note(msg: str) {
-        self.diagnostic.note(msg)
+        self.span_diagnostic.handler().note(msg)
     }
     fn span_bug(sp: span, msg: str) -> ! {
-        self.diagnostic.span_bug(sp, msg)
+        self.span_diagnostic.span_bug(sp, msg)
     }
     fn bug(msg: str) -> ! {
-        self.diagnostic.bug(msg)
+        self.span_diagnostic.handler().bug(msg)
     }
     fn span_unimpl(sp: span, msg: str) -> ! {
-        self.diagnostic.span_unimpl(sp, msg)
+        self.span_diagnostic.span_unimpl(sp, msg)
     }
     fn unimpl(msg: str) -> ! {
-        self.diagnostic.unimpl(msg)
+        self.span_diagnostic.handler().unimpl(msg)
     }
     fn next_node_id() -> ast::node_id {
         ret syntax::parse::parser::next_node_id(self.parse_sess);

branches/try/src/comp/metadata/tydecode.rs

@@ -39,7 +39,7 @@ fn parse_ident_(st: @pstate, is_last: fn@(char) -> bool) ->
    ast::ident {
     let rslt = "";
     while !is_last(peek(st) as char) {
-        rslt += str::from_byte(next(st));
+        rslt += str::unsafe_from_byte(next(st));
     }
     ret rslt;
 }
@@ -226,7 +226,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         while peek(st) as char != ']' {
             let name = "";
             while peek(st) as char != '=' {
-                name += str::from_byte(next(st));
+                name += str::unsafe_from_byte(next(st));
             }
             st.pos = st.pos + 1u;
             fields += [{ident: name, mt: parse_mt(st, conv)}];

branches/try/src/comp/middle/trans.rs

@@ -274,7 +274,7 @@ fn sanitize(s: str) -> str {
                            c != ' ' as u8 && c != '\t' as u8 && c != ';' as u8
                        {
                         let v = [c];
-                        result += str::from_bytes(v);
+                        result += str::unsafe_from_bytes(v);
                     }
                 }
             }

branches/try/src/comp/syntax/parse/lexer.rs

@@ -10,7 +10,7 @@ import driver::diagnostic;
 
 type reader = @{
     cm: codemap::codemap,
-    diagnostic: diagnostic::handler,
+    span_diagnostic: diagnostic::span_handler,
     src: str,
     len: uint,
     mutable col: uint,
@@ -49,17 +49,18 @@ impl reader for reader {
         } else { self.curr = -1 as char; }
     }
     fn fatal(m: str) -> ! {
-        self.diagnostic.span_fatal(
+        self.span_diagnostic.span_fatal(
             ast_util::mk_sp(self.chpos, self.chpos),
             m)
     }
 }
 
 fn new_reader(cm: codemap::codemap,
-              diagnostic: diagnostic::handler,
+              span_diagnostic: diagnostic::span_handler,
               src: str, filemap: codemap::filemap,
               itr: @interner::interner<str>) -> reader {
-    let r = @{cm: cm, diagnostic: diagnostic,
+    let r = @{cm: cm,
+              span_diagnostic: span_diagnostic,
               src: src, len: str::byte_len(src),
               mutable col: 0u, mutable pos: 0u, mutable curr: -1 as char,
               mutable chpos: filemap.start_pos.ch, mutable strs: [],
@@ -667,13 +668,13 @@ fn is_lit(t: token::token) -> bool {
 type lit = {lit: str, pos: uint};
 
 fn gather_comments_and_literals(cm: codemap::codemap,
-                                diagnostic: diagnostic::handler,
+                                span_diagnostic: diagnostic::span_handler,
                                 path: str,
                                 srdr: io::reader) ->
    {cmnts: [cmnt], lits: [lit]} {
     let src = str::unsafe_from_bytes(srdr.read_whole_stream());
     let itr = @interner::mk::<str>(str::hash, str::eq);
-    let rdr = new_reader(cm, diagnostic, src,
+    let rdr = new_reader(cm, span_diagnostic, src,
                          codemap::new_filemap(path, 0u, 0u), itr);
     let comments: [cmnt] = [];
     let literals: [lit] = [];