---

yaml
---
r: 37531
b: refs/heads/try
c: 5b248a6
h: refs/heads/master
i:
  37529: 7a5a693
  37527: 4a352fe
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
-refs/heads/try: 385a4668e568e4379371bf065d071f6caf6d1c3a
+refs/heads/try: 5b248a6ca8962249d5882375610764a6dd9561c3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/libfuzzer/fuzzer.rs

@@ -225,7 +225,7 @@ fn as_str(f: fn@(+x: io::Writer)) -> ~str {
     io::with_str_writer(f)
 }
 
-fn check_variants_of_ast(crate: ast::crate, codemap: codemap::CodeMap,
+fn check_variants_of_ast(crate: ast::crate, codemap: @codemap::CodeMap,
                          filename: &Path, cx: context) {
     let stolen = steal(crate, cx.mode);
     let extra_exprs = vec::filter(common_exprs(),
@@ -239,7 +239,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::CodeMap,
 
 fn check_variants_T<T: Copy>(
   crate: ast::crate,
-  codemap: codemap::CodeMap,
+  codemap: @codemap::CodeMap,
   filename: &Path,
   thing_label: ~str,
   things: ~[T],

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

@@ -574,7 +574,7 @@ fn build_session_options(binary: ~str,
 
 fn build_session(sopts: @session::options,
                  demitter: diagnostic::emitter) -> Session {
-    let codemap = codemap::new_codemap();
+    let codemap = @codemap::new_codemap();
     let diagnostic_handler =
         diagnostic::mk_handler(Some(demitter));
     let span_diagnostic_handler =
@@ -583,7 +583,7 @@ fn build_session(sopts: @session::options,
 }
 
 fn build_session_(sopts: @session::options,
-                  cm: codemap::CodeMap,
+                  cm: @codemap::CodeMap,
                   demitter: diagnostic::emitter,
                   span_diagnostic_handler: diagnostic::span_handler)
                -> Session {

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

@@ -131,7 +131,7 @@ type Session_ = {targ_cfg: @config,
                  opts: @options,
                  cstore: metadata::cstore::CStore,
                  parse_sess: parse_sess,
-                 codemap: codemap::CodeMap,
+                 codemap: @codemap::CodeMap,
                  // For a library crate, this is always none
                  mut main_fn: Option<(node_id, codemap::span)>,
                  span_diagnostic: diagnostic::span_handler,

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

@@ -229,7 +229,7 @@ fn create_file(cx: @crate_ctxt, full_path: ~str) -> @metadata<file_md> {
     return mdval;
 }
 
-fn line_from_span(cm: codemap::CodeMap, sp: span) -> uint {
+fn line_from_span(cm: @codemap::CodeMap, sp: span) -> uint {
     codemap::lookup_char_pos(cm, sp.lo).line
 }
 

branches/try/src/librustc/rustc.rs

@@ -193,7 +193,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
 
         // The 'diagnostics emitter'. Every error, warning, etc. should
         // go through this function.
-        let demitter = fn@(cmsp: Option<(codemap::CodeMap, codemap::span)>,
+        let demitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
                            msg: &str, lvl: diagnostic::level) {
             if lvl == diagnostic::fatal {
                 comm::send(ch, fatal);

branches/try/src/librustdoc/astsrv.rs

@@ -120,7 +120,7 @@ fn build_ctxt(sess: Session,
 
 fn build_session() -> Session {
     let sopts: @options = basic_options();
-    let codemap = codemap::new_codemap();
+    let codemap = @codemap::new_codemap();
     let error_handlers = build_error_handlers(codemap);
     let {emitter, span_handler} = error_handlers;
 
@@ -137,7 +137,7 @@ type ErrorHandlers = {
 // Build a custom error handler that will allow us to ignore non-fatal
 // errors
 fn build_error_handlers(
-    codemap: codemap::CodeMap
+    codemap: @codemap::CodeMap
 ) -> ErrorHandlers {
 
     type DiagnosticHandler = {
@@ -156,13 +156,13 @@ fn build_error_handlers(
         fn note(msg: &str) { self.inner.note(msg) }
         fn bug(msg: &str) -> ! { self.inner.bug(msg) }
         fn unimpl(msg: &str) -> ! { self.inner.unimpl(msg) }
-        fn emit(cmsp: Option<(codemap::CodeMap, codemap::span)>,
+        fn emit(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
                 msg: &str, lvl: diagnostic::level) {
             self.inner.emit(cmsp, msg, lvl)
         }
     }
 
-    let emitter = fn@(cmsp: Option<(codemap::CodeMap, codemap::span)>,
+    let emitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
                        msg: &str, lvl: diagnostic::level) {
         diagnostic::emit(cmsp, msg, lvl);
     };

branches/try/src/libsyntax/codemap.rs

@@ -86,19 +86,21 @@ impl filemap {
     }
 }
 
-struct CodeMap_ {
+struct CodeMap {
     files: DVec<@filemap>
 }
 
-type CodeMap = @CodeMap_;
-
 struct loc {
     file: @filemap, line: uint, col: uint
 }
 
-fn new_codemap() -> CodeMap { @CodeMap_ {files: DVec()} }
+fn new_codemap() -> CodeMap {
+    CodeMap {
+        files: DVec()
+    }
+}
 
-fn mk_substr_filename(cm: CodeMap, sp: span) -> ~str
+fn mk_substr_filename(cm: @CodeMap, sp: span) -> ~str
 {
     let pos = lookup_char_pos(cm, sp.lo);
     return fmt!("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
@@ -110,7 +112,7 @@ fn next_line(file: @filemap, chpos: uint, byte_pos: uint) {
 
 type lookup_fn = pure fn(file_pos) -> uint;
 
-fn lookup_line(map: CodeMap, pos: uint, lookup: lookup_fn)
+fn lookup_line(map: @CodeMap, pos: uint, lookup: lookup_fn)
     -> {fm: @filemap, line: uint}
 {
     let len = map.files.len();
@@ -133,22 +135,22 @@ fn lookup_line(map: CodeMap, pos: uint, lookup: lookup_fn)
     return {fm: f, line: a};
 }
 
-fn lookup_pos(map: CodeMap, pos: uint, lookup: lookup_fn) -> loc {
+fn lookup_pos(map: @CodeMap, pos: uint, lookup: lookup_fn) -> loc {
     let {fm: f, line: a} = lookup_line(map, pos, lookup);
     return loc {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
 }
 
-fn lookup_char_pos(map: CodeMap, pos: uint) -> loc {
+fn lookup_char_pos(map: @CodeMap, pos: uint) -> loc {
     pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
     return lookup_pos(map, pos, lookup);
 }
 
-fn lookup_byte_pos(map: CodeMap, pos: uint) -> loc {
+fn lookup_byte_pos(map: @CodeMap, pos: uint) -> loc {
     pure fn lookup(pos: file_pos) -> uint { return pos.byte; }
     return lookup_pos(map, pos, lookup);
 }
 
-fn lookup_char_pos_adj(map: CodeMap, pos: uint)
+fn lookup_char_pos_adj(map: @CodeMap, pos: uint)
     -> {filename: ~str, line: uint, col: uint, file: Option<@filemap>}
 {
     let loc = lookup_char_pos(map, pos);
@@ -171,7 +173,7 @@ fn lookup_char_pos_adj(map: CodeMap, pos: uint)
     }
 }
 
-fn adjust_span(map: CodeMap, sp: span) -> span {
+fn adjust_span(map: @CodeMap, sp: span) -> span {
     pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
     let line = lookup_line(map, sp.lo, lookup);
     match (line.fm.substr) {
@@ -210,14 +212,14 @@ impl<D: Deserializer> span: Deserializable<D> {
     }
 }
 
-fn span_to_str_no_adj(sp: span, cm: CodeMap) -> ~str {
+fn span_to_str_no_adj(sp: span, cm: @CodeMap) -> ~str {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
     return fmt!("%s:%u:%u: %u:%u", lo.file.name,
              lo.line, lo.col, hi.line, hi.col)
 }
 
-fn span_to_str(sp: span, cm: CodeMap) -> ~str {
+fn span_to_str(sp: span, cm: @CodeMap) -> ~str {
     let lo = lookup_char_pos_adj(cm, sp.lo);
     let hi = lookup_char_pos_adj(cm, sp.hi);
     return fmt!("%s:%u:%u: %u:%u", lo.filename,
@@ -229,12 +231,12 @@ struct file_lines {
     lines: ~[uint]
 }
 
-fn span_to_filename(sp: span, cm: codemap::CodeMap) -> filename {
+fn span_to_filename(sp: span, cm: @codemap::CodeMap) -> filename {
     let lo = lookup_char_pos(cm, sp.lo);
     return /* FIXME (#2543) */ copy lo.file.name;
 }
 
-fn span_to_lines(sp: span, cm: codemap::CodeMap) -> @file_lines {
+fn span_to_lines(sp: span, cm: @codemap::CodeMap) -> @file_lines {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
     let mut lines = ~[];
@@ -253,7 +255,7 @@ fn get_line(fm: @filemap, line: int) -> ~str unsafe {
     str::slice(*fm.src, begin, end)
 }
 
-fn lookup_byte_offset(cm: codemap::CodeMap, chpos: uint)
+fn lookup_byte_offset(cm: @codemap::CodeMap, chpos: uint)
     -> {fm: @filemap, pos: uint} {
     pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
     let {fm, line} = lookup_line(cm, chpos, lookup);
@@ -263,20 +265,20 @@ fn lookup_byte_offset(cm: codemap::CodeMap, chpos: uint)
     {fm: fm, pos: line_offset + col_offset}
 }
 
-fn span_to_snippet(sp: span, cm: codemap::CodeMap) -> ~str {
+fn span_to_snippet(sp: span, cm: @codemap::CodeMap) -> ~str {
     let begin = lookup_byte_offset(cm, sp.lo);
     let end = lookup_byte_offset(cm, sp.hi);
     assert begin.fm.start_pos == end.fm.start_pos;
     return str::slice(*begin.fm.src, begin.pos, end.pos);
 }
 
-fn get_snippet(cm: codemap::CodeMap, fidx: uint, lo: uint, hi: uint) -> ~str
+fn get_snippet(cm: @codemap::CodeMap, fidx: uint, lo: uint, hi: uint) -> ~str
 {
     let fm = cm.files[fidx];
     return str::slice(*fm.src, lo, hi)
 }
 
-fn get_filemap(cm: CodeMap, filename: ~str) -> @filemap {
+fn get_filemap(cm: @CodeMap, filename: ~str) -> @filemap {
     for cm.files.each |fm| { if fm.name == filename { return *fm; } }
     //XXjdm the following triggers a mismatched type bug
     //      (or expected function, found _|_)

branches/try/src/libsyntax/diagnostic.rs

@@ -9,7 +9,7 @@ export codemap_span_handler, codemap_handler;
 export ice_msg;
 export expect;
 
-type emitter = fn@(cmsp: Option<(codemap::CodeMap, span)>,
+type emitter = fn@(cmsp: Option<(@codemap::CodeMap, span)>,
                    msg: &str, lvl: level);
 
 
@@ -33,7 +33,7 @@ trait handler {
     fn note(msg: &str);
     fn bug(msg: &str) -> !;
     fn unimpl(msg: &str) -> !;
-    fn emit(cmsp: Option<(codemap::CodeMap, span)>, msg: &str, lvl: level);
+    fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level);
 }
 
 type handler_t = @{
@@ -43,7 +43,7 @@ type handler_t = @{
 
 type codemap_t = @{
     handler: handler,
-    cm: codemap::CodeMap
+    cm: @codemap::CodeMap
 };
 
 impl codemap_t: span_handler {
@@ -107,7 +107,7 @@ impl handler_t: handler {
         self.fatal(ice_msg(msg));
     }
     fn unimpl(msg: &str) -> ! { self.bug(~"unimplemented " + msg); }
-    fn emit(cmsp: Option<(codemap::CodeMap, span)>, msg: &str, lvl: level) {
+    fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level) {
         self.emit(cmsp, msg, lvl);
     }
 }
@@ -116,7 +116,7 @@ fn ice_msg(msg: &str) -> ~str {
     fmt!("internal compiler error: %s", msg)
 }
 
-fn mk_span_handler(handler: handler, cm: codemap::CodeMap) -> span_handler {
+fn mk_span_handler(handler: handler, cm: @codemap::CodeMap) -> span_handler {
     @{ handler: handler, cm: cm } as span_handler
 }
 
@@ -125,7 +125,7 @@ fn mk_handler(emitter: Option<emitter>) -> handler {
     let emit = match emitter {
       Some(e) => e,
       None => {
-        let f = fn@(cmsp: Option<(codemap::CodeMap, span)>,
+        let f = fn@(cmsp: Option<(@codemap::CodeMap, span)>,
             msg: &str, t: level) {
             emit(cmsp, msg, t);
         };
@@ -189,7 +189,7 @@ fn print_diagnostic(topic: ~str, lvl: level, msg: &str) {
     io::stderr().write_str(fmt!(" %s\n", msg));
 }
 
-fn emit(cmsp: Option<(codemap::CodeMap, span)>, msg: &str, lvl: level) {
+fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level) {
     match cmsp {
       Some((cm, sp)) => {
         let sp = codemap::adjust_span(cm,sp);
@@ -205,7 +205,7 @@ fn emit(cmsp: Option<(codemap::CodeMap, span)>, msg: &str, lvl: level) {
     }
 }
 
-fn highlight_lines(cm: codemap::CodeMap, sp: span,
+fn highlight_lines(cm: @codemap::CodeMap, sp: span,
                    lines: @codemap::file_lines) {
 
     let fm = lines.file;
@@ -260,7 +260,7 @@ fn highlight_lines(cm: codemap::CodeMap, sp: span,
     }
 }
 
-fn print_macro_backtrace(cm: codemap::CodeMap, sp: span) {
+fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
     do option::iter(&sp.expn_info) |ei| {
         let ss = option::map_default(&ei.callie.span, @~"",
                                      |span| @codemap::span_to_str(*span, cm));

branches/try/src/libsyntax/ext/base.rs

@@ -125,7 +125,7 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
 // when a macro expansion occurs, the resulting nodes have the backtrace()
 // -> expn_info of their expansion context stored into their span.
 trait ext_ctxt {
-    fn codemap() -> CodeMap;
+    fn codemap() -> @CodeMap;
     fn parse_sess() -> parse::parse_sess;
     fn cfg() -> ast::crate_cfg;
     fn print_backtrace();
@@ -157,7 +157,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
                       mut mod_path: ~[ast::ident],
                       mut trace_mac: bool};
     impl ctxt_repr: ext_ctxt {
-        fn codemap() -> CodeMap { self.parse_sess.cm }
+        fn codemap() -> @CodeMap { self.parse_sess.cm }
         fn parse_sess() -> parse::parse_sess { self.parse_sess }
         fn cfg() -> ast::crate_cfg { self.cfg }
         fn print_backtrace() { }

branches/try/src/libsyntax/parse.rs

@@ -23,7 +23,7 @@ use parse::token::{ident_interner, mk_ident_interner};
 use codemap::filemap;
 
 type parse_sess = @{
-    cm: codemap::CodeMap,
+    cm: @codemap::CodeMap,
     mut next_id: node_id,
     span_diagnostic: span_handler,
     interner: @ident_interner,
@@ -33,15 +33,15 @@ type parse_sess = @{
 };
 
 fn new_parse_sess(demitter: Option<emitter>) -> parse_sess {
-    let cm = codemap::new_codemap();
+    let cm = @codemap::new_codemap();
     return @{cm: cm,
              mut next_id: 1,
              span_diagnostic: mk_span_handler(mk_handler(demitter), cm),
              interner: mk_ident_interner(),
              mut chpos: 0u, mut byte_pos: 0u};
 }
 
-fn new_parse_sess_special_handler(sh: span_handler, cm: codemap::CodeMap)
+fn new_parse_sess_special_handler(sh: span_handler, cm: @codemap::CodeMap)
     -> parse_sess {
     return @{cm: cm,
              mut next_id: 1,

branches/try/src/libsyntax/parse/lexer.rs

@@ -232,7 +232,7 @@ fn consume_any_line_comment(rdr: string_reader)
         }
     } else if rdr.curr == '#' {
         if nextch(rdr) == '!' {
-            let cmap = codemap::new_codemap();
+            let cmap = @codemap::new_codemap();
             (*cmap).files.push(rdr.filemap);
             let loc = codemap::lookup_char_pos_adj(cmap, rdr.chpos);
             if loc.line == 1u && loc.col == 0u {