---

yaml
---
r: 13813
b: refs/heads/try
c: 5847cf0
h: refs/heads/master
i:
  13811: a393f10
v: v3

Author: killerswan

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 566a4be1f892eee66f88b832ff04421ad70cb1ee
+refs/heads/try: 5847cf0367287d89377c57a431f38419ec1db008
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/AUTHORS.txt

@@ -26,7 +26,6 @@ Jeff Balogh <[email protected]>
 Jeff Muizelaar <[email protected]>
 Jeffrey Yasskin <[email protected]>
 Jesse Ruderman <[email protected]>
-Joe Pletcher <[email protected]>
 Josh Matthews <[email protected]>
 Joshua Clark <[email protected]>
 Joshua Wise <[email protected]>

branches/try/doc/rust.md

@@ -1058,9 +1058,7 @@ accessed through the components `x` and `y`, and laid out in memory with the
 An _enumeration item_ simultaneously declares a new nominal
 [enumerated type](#enumerated-types) as well as a set of *constructors* that
 can be used to create or pattern-match values of the corresponding enumerated
-type. Note that `enum` previously was refered to as a `tag`, however this
-definition has been deprecated. While `tag` is no longer used, the two are 
-synonymous.
+type.
 
 The constructors of an `enum` type may be recursive: that is, each constructor
 may take an argument that refers, directly or indirectly, to the enumerated
@@ -2009,7 +2007,7 @@ alt_pat : pat [ "to" pat ] ? [ "if" expr ] ;
 
 An `alt` expression branches on a *pattern*. The exact form of matching that
 occurs depends on the pattern. Patterns consist of some combination of
-literals, destructured enum constructors, records and tuples, variable binding
+literals, destructured tag constructors, records and tuples, variable binding
 specifications and placeholders (`_`). An `alt` expression has a *head
 expression*, which is the value to compare to the patterns. The type of the
 patterns must equal the type of the head expression.
@@ -2024,7 +2022,7 @@ An example of an `alt` expression:
 
 
 ~~~~
-enum list<X> { nil; cons(X, @list<X>); }
+tag list<X> { nil; cons(X, @list<X>); }
 
 let x: list<int> = cons(10, @cons(11, @nil));
 
@@ -3288,7 +3286,7 @@ such as vectors, strings, and the low level communication system (ports,
 channels, tasks).
 
 Support for other built-in types such as simple types, tuples, records, and
-enums is open-coded by the Rust compiler.
+tags is open-coded by the Rust compiler.
 
 
 

branches/try/doc/tutorial.md

@@ -92,9 +92,7 @@ packages:
   * curl
 
 Assuming you're on a relatively modern Linux system and have met the
-prerequisites, something along these lines should work. Building from source on
-Windows requires some extra steps: please see the
-[getting started][wiki-get-started] page on the Rust wiki.
+prerequisites, something along these lines should work:
 
 ~~~~
 ## notrust
@@ -105,9 +103,8 @@ $ ./configure
 $ make && make install
 ~~~~
 
-You may need to use `sudo make install` if you do not normally have
-permission to modify the destination directory (either `/usr/local/bin`
-or the directory specified with to `configure` with `--prefix`).
+Building from source on windows requires some extra steps, please see
+the [getting started][wiki-get-started] page on the Rust wiki.
 
 When complete, `make install` will place the following programs into
 `/usr/local/bin`:
@@ -1349,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, enums, or unique pointers require
+reference count updates, big records, tags, or unique pointers require
 an arbitrary amount of data to be copied (plus updating the reference
 counts of shared boxes hanging off them).
 
@@ -1462,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 enums *are* passed by pointer, but single-word values, like
+records and tags *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,11 +100,10 @@ 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,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
+        diagnostic: diagnostic::mk_handler(cm, none),
         mutable chpos: 0u,
         mutable byte_pos: 0u
     };

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

@@ -5,83 +5,51 @@ import codemap::span;
 
 export emitter, emit;
 export level, fatal, error, warning, note;
-export span_handler, handler, mk_span_handler, mk_handler;
-export codemap_span_handler, codemap_handler;
+export handler, mk_handler;
 export ice_msg;
 
 type emitter = fn@(cmsp: option<(codemap::codemap, span)>,
                    msg: str, lvl: level);
 
 
-iface span_handler {
-    fn span_fatal(sp: span, 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 span_fatal(sp: span, msg: str) -> !;
     fn fatal(msg: str) -> !;
+    fn span_err(sp: span, 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 handler_t = @{
-    mutable err_count: uint,
-    _emit: emitter
-};
-
 type codemap_t = @{
-    handler: handler,
-    cm: codemap::codemap
+    cm: codemap::codemap,
+    mutable err_count: uint,
+    emit: emitter
 };
 
-impl codemap_span_handler of span_handler for codemap_t {
+impl codemap_handler of handler for codemap_t {
     fn span_fatal(sp: span, msg: str) -> ! {
-        self.handler.emit(some((self.cm, sp)), msg, fatal);
+        self.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 err(msg: str) {
-        self._emit(none, msg, error);
-        self.bump_err_count();
+    fn span_err(sp: span, msg: str) {
+        self.emit(some((self.cm, sp)), msg, error);
+        self.err_count += 1u;
     }
-    fn bump_err_count() {
+    fn err(msg: str) {
+        self.emit(none, msg, error);
         self.err_count += 1u;
     }
     fn has_errors() -> bool { self.err_count > 0u }
@@ -90,30 +58,36 @@ impl codemap_handler of handler for handler_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);
+        self.emit(none, msg, warning);
+    }
+    fn span_note(sp: span, msg: str) {
+        self.emit(some((self.cm, sp)), msg, note);
     }
     fn note(msg: str) {
-        self._emit(none, msg, note);
+        self.emit(none, msg, note);
+    }
+    fn span_bug(sp: span, msg: str) -> ! {
+        self.span_fatal(sp, ice_msg(msg));
     }
     fn bug(msg: str) -> ! {
         self.fatal(ice_msg(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 span_unimpl(sp: span, msg: str) -> ! {
+        self.span_bug(sp, "unimplemented " + msg);
     }
+    fn unimpl(msg: str) -> ! { self.bug("unimplemented " + msg); }
 }
 
 fn ice_msg(msg: str) -> str {
     #fmt["internal compiler error %s", msg]
 }
 
-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 {
+fn mk_handler(cm: codemap::codemap,
+              emitter: option<emitter>) -> handler {
 
     let emit = alt emitter {
       some(e) { e }
@@ -127,8 +101,9 @@ fn mk_handler(emitter: option<emitter>) -> handler {
     };
 
     @{
+        cm: cm,
         mutable err_count: 0u,
-        _emit: emit
+        emit: emit
     } as handler
 }
 
@@ -193,6 +168,15 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
     // pull out the lines
     if lines.name == "-" { ret; }
 
+    // FIXME: reading in the entire file is the worst possible way to
+    //        get access to the necessary lines.
+    let file = alt io::read_whole_file_str(lines.name) {
+      result::ok(file) { file }
+      result::err(e) {
+        // Hard to report errors while reporting an error
+        ret;
+      }
+    };
     let fm = codemap::get_filemap(cm, lines.name);
 
     // arbitrarily only print up to six lines of the error
@@ -206,7 +190,7 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
     // Print the offending lines
     for line: uint in display_lines {
         io::stdout().write_str(#fmt["%s:%u ", fm.name, line + 1u]);
-        let s = codemap::get_line(fm, line as int);
+        let s = codemap::get_line(fm, line as int, file);
         if !str::ends_with(s, "\n") { s += "\n"; }
         io::stdout().write_str(s);
     }

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

@@ -77,7 +77,7 @@ fn parse_cfgspecs(cfgspecs: [str]) -> ast::crate_cfg {
 fn input_is_stdin(filename: str) -> bool { filename == "-" }
 
 fn parse_input(sess: session, cfg: ast::crate_cfg, input: str)
-    -> {crate: @ast::crate, src: @str} {
+    -> {crate: @ast::crate, src: str} {
     let src = get_input_str(sess, input);
     let crate = if !input_is_stdin(input) {
         parser::parse_crate_from_file(input, cfg, sess.parse_sess)
@@ -87,7 +87,7 @@ fn parse_input(sess: session, cfg: ast::crate_cfg, input: str)
     {crate: crate, src: src}
 }
 
-fn get_input_str(sess: session, infile: str) -> @str {
+fn get_input_str(sess: session, infile: str) -> str {
     let stream = if !input_is_stdin(infile) {
         alt io::file_reader(infile) {
           result::ok(reader) { reader }
@@ -96,7 +96,7 @@ fn get_input_str(sess: session, infile: str) -> @str {
           }
         }
     } else { io::stdin() };
-    @str::unsafe_from_bytes(stream.read_whole_stream())
+    str::from_bytes(stream.read_whole_stream())
 }
 
 fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T {
@@ -141,7 +141,7 @@ enum compile_upto {
 fn compile_upto(sess: session, cfg: ast::crate_cfg,
                 input: str, upto: compile_upto,
                 outputs: option::t<output_filenames>)
-    -> {crate: @ast::crate, tcx: option::t<ty::ctxt>, src: @str} {
+    -> {crate: @ast::crate, tcx: option::t<ty::ctxt>, src: str} {
     let time_passes = sess.opts.time_passes;
     let {crate, src} =
         time(time_passes, "parsing", bind parse_input(sess, cfg, input));
@@ -299,8 +299,8 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: str,
       }
       ppm_expanded | ppm_normal {}
     }
-    pprust::print_crate(sess.codemap, sess.span_diagnostic, crate, input,
-                        io::string_reader(*src), io::stdout(), ann);
+    pprust::print_crate(sess.codemap, sess.diagnostic, crate, input,
+                        io::string_reader(src), io::stdout(), ann);
 }
 
 fn get_os(triple: str) -> option<session::os> {
@@ -481,23 +481,21 @@ fn build_session(sopts: @session::options, input: str,
         sopts.addl_lib_search_paths);
     let codemap = codemap::new_codemap();
     let diagnostic_handler =
-        diagnostic::mk_handler(some(demitter));
-    let span_diagnostic_handler =
-        diagnostic::mk_span_handler(diagnostic_handler, codemap);
+        diagnostic::mk_handler(codemap, some(demitter));
     @{targ_cfg: target_cfg,
       opts: sopts,
       cstore: cstore,
       parse_sess: @{
           cm: codemap,
           mutable next_id: 1,
-          span_diagnostic: span_diagnostic_handler,
+          diagnostic: diagnostic_handler,
           mutable chpos: 0u,
           mutable byte_pos: 0u
       },
       codemap: codemap,
       // For a library crate, this is always none
       mutable main_fn: none,
-      span_diagnostic: span_diagnostic_handler,
+      diagnostic: diagnostic_handler,
       filesearch: filesearch,
       mutable building_library: false,
       working_dir: fs::dirname(input)}