Merge pull request #1664 from kevina/issue-1612

See Issue #1612

5 files changed, 36 insertions, 33 deletions

diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index a8c76724b26..8463f37681a 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -11,7 +11,8 @@ type file_pos = {ch: uint, byte: uint};
  * compiler.
  */
 type filemap =
-    @{name: filename, start_pos: file_pos, mutable lines: [file_pos]};
+    @{name: filename, src: @str,
+      start_pos: file_pos, mutable lines: [file_pos]};
 
 type codemap = @{mutable files: [filemap]};
 
@@ -19,9 +20,10 @@ type loc = {filename: filename, line: uint, col: uint};
 
 fn new_codemap() -> codemap { ret @{mutable files: []}; }
 
-fn new_filemap(filename: filename, start_pos_ch: uint, start_pos_byte: uint)
+fn new_filemap(filename: filename, src: @str,
+               start_pos_ch: uint, start_pos_byte: uint)
    -> filemap {
-    ret @{name: filename,
+    ret @{name: filename, src: src,
           start_pos: {ch: start_pos_ch, byte: start_pos_byte},
           mutable lines: [{ch: start_pos_ch, byte: start_pos_byte}]};
 }
@@ -106,7 +108,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     ret @{name: lo.filename, lines: lines};
 }
 
-fn get_line(fm: filemap, line: int, file: str) -> str {
+fn get_line(fm: filemap, line: int) -> str {
     let begin: uint = fm.lines[line].byte - fm.start_pos.byte;
     let end: uint;
     if line as uint < vec::len(fm.lines) - 1u {
@@ -115,12 +117,12 @@ fn get_line(fm: filemap, line: int, file: str) -> str {
         // If we're not done parsing the file, we're at the limit of what's
         // parsed. If we just slice the rest of the string, we'll print out
         // the remainder of the file, which is undesirable.
-        end = str::byte_len(file);
-        let rest = str::slice(file, begin, end);
+        end = str::byte_len(*fm.src);
+        let rest = str::slice(*fm.src, begin, end);
         let newline = str::index(rest, '\n' as u8);
         if newline != -1 { end = begin + (newline as uint); }
     }
-    ret str::slice(file, begin, end);
+    ret str::slice(*fm.src, begin, end);
 }
 
 fn get_filemap(cm: codemap, filename: str) -> filemap {
diff --git a/src/comp/syntax/ext/expand.rs b/src/comp/syntax/ext/expand.rs
index e749b28a417..d5482a1e62f 100644
--- a/src/comp/syntax/ext/expand.rs
+++ b/src/comp/syntax/ext/expand.rs
@@ -75,7 +75,7 @@ fn expand_crate(sess: session::session, c: @crate) -> @crate {
         {fold_expr: bind expand_expr(exts, cx, _, _, _, afp.fold_expr)
             with *afp};
     let f = make_fold(f_pre);
-    let cm = parse_expr_from_source_str("<anon>", core_macros(),
+    let cm = parse_expr_from_source_str("<anon>", @core_macros(),
                                         sess.opts.cfg,
                                         sess.parse_sess);
 
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index ca7af9e273d..2530c794c94 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -79,7 +79,7 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option::t<str>)
         let first_item_outer_attrs = inner_attrs.next;
         let m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
         cx.sess.chpos = p0.reader.chpos;
-        cx.sess.byte_pos = p0.reader.pos;
+        cx.sess.byte_pos = cx.sess.byte_pos + p0.reader.pos;
         ret (m0.view_items, m0.items, inner_attrs.inner);
     } else {
         ret ([], [], []);
@@ -117,7 +117,7 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
                                            ast::item_mod(m0), mod_attrs);
         // Thread defids, chpos and byte_pos through the parsers
         cx.sess.chpos = p0.reader.chpos;
-        cx.sess.byte_pos = p0.reader.pos;
+        cx.sess.byte_pos = cx.sess.byte_pos + p0.reader.pos;
         items += [i];
       }
       ast::cdir_dir_mod(id, cdirs, attrs) {
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index f51838ef28e..66e0f87d982 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -11,7 +11,7 @@ import driver::diagnostic;
 type reader = @{
     cm: codemap::codemap,
     span_diagnostic: diagnostic::span_handler,
-    src: str,
+    src: @str,
     len: uint,
     mutable col: uint,
     mutable pos: uint,
@@ -27,11 +27,11 @@ impl reader for reader {
     fn get_str_from(start: uint) -> str {
         // I'm pretty skeptical about this subtraction. What if there's a
         // multi-byte character before the mark?
-        ret str::slice(self.src, start - 1u, self.pos - 1u);
+        ret str::slice(*self.src, start - 1u, self.pos - 1u);
     }
     fn next() -> char {
         if self.pos < self.len {
-            ret str::char_at(self.src, self.pos);
+            ret str::char_at(*self.src, self.pos);
         } else { ret -1 as char; }
     }
     fn bump() {
@@ -43,7 +43,7 @@ impl reader for reader {
                                    self.filemap.start_pos.byte);
                 self.col = 0u;
             }
-            let next = str::char_range_at(self.src, self.pos);
+            let next = str::char_range_at(*self.src, self.pos);
             self.pos = next.next;
             self.curr = next.ch;
         } else { self.curr = -1 as char; }
@@ -57,16 +57,16 @@ impl reader for reader {
 
 fn new_reader(cm: codemap::codemap,
               span_diagnostic: diagnostic::span_handler,
-              src: str, filemap: codemap::filemap,
+              filemap: codemap::filemap,
               itr: @interner::interner<str>) -> reader {
     let r = @{cm: cm,
               span_diagnostic: span_diagnostic,
-              src: src, len: str::byte_len(src),
+              src: filemap.src, len: str::byte_len(*filemap.src),
               mutable col: 0u, mutable pos: 0u, mutable curr: -1 as char,
               mutable chpos: filemap.start_pos.ch, mutable strs: [],
               filemap: filemap, interner: itr};
     if r.pos < r.len {
-        let next = str::char_range_at(r.src, r.pos);
+        let next = str::char_range_at(*r.src, r.pos);
         r.pos = next.next;
         r.curr = next.ch;
     }
@@ -672,10 +672,10 @@ fn gather_comments_and_literals(cm: codemap::codemap,
                                 path: str,
                                 srdr: io::reader) ->
    {cmnts: [cmnt], lits: [lit]} {
-    let src = str::unsafe_from_bytes(srdr.read_whole_stream());
+    let src = @str::unsafe_from_bytes(srdr.read_whole_stream());
     let itr = @interner::mk::<str>(str::hash, str::eq);
-    let rdr = new_reader(cm, span_diagnostic, src,
-                         codemap::new_filemap(path, 0u, 0u), itr);
+    let rdr = new_reader(cm, span_diagnostic,
+                         codemap::new_filemap(path, src, 0u, 0u), itr);
     let comments: [cmnt] = [];
     let literals: [lit] = [];
     let first_read: bool = true;
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index eca22f38adf..4d8acc6fa44 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -98,27 +98,28 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
     let src = alt io::read_whole_file_str(path) {
       result::ok(src) {
         // FIXME: This copy is unfortunate
-        src
+        @src
       }
       result::err(e) {
         sess.span_diagnostic.handler().fatal(e)
       }
     };
-    let filemap = codemap::new_filemap(path, sess.chpos, sess.byte_pos);
+    let filemap = codemap::new_filemap(path, src,
+                                       sess.chpos, sess.byte_pos);
     sess.cm.files += [filemap];
     let itr = @interner::mk(str::hash, str::eq);
-    let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic, src, filemap,
-                                itr);
+    let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic, filemap, itr);
     ret new_parser(sess, cfg, rdr, ftype);
 }
 
 fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
-                              name: str, source: str) -> parser {
+                              name: str, source: @str) -> parser {
     let ftype = SOURCE_FILE;
-    let filemap = codemap::new_filemap(name, sess.chpos, sess.byte_pos);
+    let filemap = codemap::new_filemap(name, source,
+                                       sess.chpos, sess.byte_pos);
     sess.cm.files += [filemap];
     let itr = @interner::mk(str::hash, str::eq);
-    let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic, source,
+    let rdr = lexer::new_reader(sess.cm, sess.span_diagnostic,
                                 filemap, itr);
     ret new_parser(sess, cfg, rdr, ftype);
 }
@@ -2457,26 +2458,26 @@ fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
     let p = new_parser_from_file(sess, cfg, input, SOURCE_FILE);
     let r = parse_crate_mod(p, cfg);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
 }
 
 
-fn parse_expr_from_source_str(name: str, source: str, cfg: ast::crate_cfg,
+fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
                               sess: parse_sess) -> @ast::expr {
     let p = new_parser_from_source_str(sess, cfg, name, source);
     let r = parse_expr(p);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
 }
 
-fn parse_crate_from_source_str(name: str, source: str, cfg: ast::crate_cfg,
+fn parse_crate_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
                                sess: parse_sess) -> @ast::crate {
     let p = new_parser_from_source_str(sess, cfg, name, source);
     let r = parse_crate_mod(p, cfg);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
 }
 
@@ -2578,7 +2579,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
     let first_cdir_attr = leading_attrs.next;
     let cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
     sess.chpos = p.reader.chpos;
-    sess.byte_pos = p.reader.pos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
     let cx =
         @{p: p,
           sess: sess,