Store info about file "substr".

That is when a string that is part of a file needs to be parsed for a
reason, record that the string is a substr of the file rather than
using "<anon>" or "-" as the file name.  This will eventually allow
pointing to the right location, for now it just uses a more
meaningful string for the filename.

src/comp/syntax/codemap.rs

@@ -10,8 +10,12 @@ type file_pos = {ch: uint, byte: uint};
  * with single-word things, rather than passing records all over the
  * compiler.
  */
+
+type file_substr_ = {lo: uint, hi: uint, col: uint, line: uint};
+type file_substr = option<file_substr_>;
+
 type filemap =
-    @{name: filename, src: @str,
+    @{name: filename, substr: file_substr, src: @str,
       start_pos: file_pos, mutable lines: [file_pos]};
 
 type codemap = @{mutable files: [filemap]};
@@ -22,14 +26,30 @@ fn new_codemap() -> codemap {
     @{mutable files: [new_filemap("-", @"", 0u, 0u)]}
 }
 
-fn new_filemap(filename: filename, src: @str,
-               start_pos_ch: uint, start_pos_byte: uint)
+fn new_filemap_w_substr(filename: filename, substr: file_substr,
+                        src: @str,
+                        start_pos_ch: uint, start_pos_byte: uint)
    -> filemap {
-    ret @{name: filename, src: src,
+    ret @{name: filename, substr: substr, src: src,
           start_pos: {ch: start_pos_ch, byte: start_pos_byte},
           mutable lines: [{ch: start_pos_ch, byte: start_pos_byte}]};
 }
 
+fn new_filemap(filename: filename, src: @str,
+               start_pos_ch: uint, start_pos_byte: uint)
+    -> filemap {
+    ret new_filemap_w_substr(filename, none, src, 
+                             start_pos_ch, start_pos_byte);
+}
+
+fn get_substr_info(cm: codemap, lo: uint, hi: uint)
+    -> (filename, file_substr_)
+{
+    let pos = lookup_char_pos(cm, lo);
+    let name = #fmt("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
+    ret (name, {lo: lo, hi: hi, col: pos.col, line: pos.line});
+}
+
 fn empty_filemap(cm: codemap) -> filemap {cm.files[0]}
 
 fn next_line(file: filemap, chpos: uint, byte_pos: uint) {

src/comp/syntax/ext/qquote.rs

@@ -48,8 +48,10 @@ fn expand_ast(ecx: ext_ctxt, _sp: span, _arg: ast::mac_arg, body: ast::mac_body)
 {
     let body = get_mac_body(ecx,_sp,body);
     let str = @codemap::span_to_snippet(body.span, ecx.session().parse_sess.cm);
+    let (fname, ss) = codemap::get_substr_info(ecx.session().parse_sess.cm, 
+                                               body.span.lo, body.span.hi);
     let {node: e, _} = parse_from_source_str(parser::parse_expr, 
-                                             "<anon>", str, 
+                                             fname, some(ss), str, 
                                              ecx.session().opts.cfg, 
                                              ecx.session().parse_sess);
     ret expand_qquote(ecx, e.span, some(*str), e);

src/comp/syntax/parse/parser.rs

@@ -113,10 +113,11 @@ fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
 }
 
 fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
-                              name: str, source: @str) -> parser {
+                              name: str, ss: codemap::file_substr,
+                              source: @str) -> parser {
     let ftype = SOURCE_FILE;
-    let filemap = codemap::new_filemap(name, source,
-                                       sess.chpos, sess.byte_pos);
+    let filemap = codemap::new_filemap_w_substr
+        (name, ss, 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,
@@ -2536,19 +2537,20 @@ fn parse_crate_from_source_file(input: 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 p = new_parser_from_source_str(sess, cfg, name, none, source);
     let r = parse_expr(p);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
     ret r;
 }
 
-fn parse_from_source_str<T>(f: fn (p: parser) -> T, 
-                            name: str, source: @str, cfg: ast::crate_cfg,
-                            sess: parse_sess) 
+fn parse_from_source_str<T>(f: fn (p: parser) -> T,
+                            name: str, ss: codemap::file_substr,
+                            source: @str, cfg: ast::crate_cfg,
+                            sess: parse_sess)
     -> {node: T, fm: codemap::filemap}
 {
-    let p = new_parser_from_source_str(sess, cfg, name, source);
+    let p = new_parser_from_source_str(sess, cfg, name, ss, source);
     let r = f(p);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;
@@ -2557,7 +2559,7 @@ fn parse_from_source_str<T>(f: fn (p: parser) -> T,
 
 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 p = new_parser_from_source_str(sess, cfg, name, none, source);
     let r = parse_crate_mod(p, cfg);
     sess.chpos = p.reader.chpos;
     sess.byte_pos = sess.byte_pos + p.reader.pos;

src/rustdoc/attr_parser.rs

@@ -94,7 +94,7 @@ mod test {
             mutable byte_pos: 0u
         };
         let parser = parser::new_parser_from_source_str(
-            parse_sess, [], "-", @source);
+            parse_sess, [], "-", none, @source);
 
         parser::parse_outer_attributes(parser)
     }