Camel case all the codemap types except span

13 files changed, 104 insertions, 104 deletions

diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index 2575141f7c4..ecf060afc93 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -112,7 +112,7 @@ type compile_unit_md = {name: ~str};
 type subprogram_md = {id: ast::node_id};
 type local_var_md = {id: ast::node_id};
 type tydesc_md = {hash: uint};
-type block_md = {start: codemap::loc, end: codemap::loc};
+type block_md = {start: codemap::Loc, end: codemap::Loc};
 type argument_md = {id: ast::node_id};
 type retval_md = {id: ast::node_id};
 
diff --git a/src/librustdoc/attr_parser.rs b/src/librustdoc/attr_parser.rs
index 2b16112fe16..4e8b11d2ca6 100644
--- a/src/librustdoc/attr_parser.rs
+++ b/src/librustdoc/attr_parser.rs
@@ -30,7 +30,7 @@ mod test {
 
         let parse_sess = syntax::parse::new_parse_sess(None);
         let parser = parse::new_parser_from_source_str(
-            parse_sess, ~[], ~"-", codemap::fss_none, @source);
+            parse_sess, ~[], ~"-", codemap::FssNone, @source);
 
         parser.parse_outer_attributes()
     }
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 7452e41fac3..4455db08826 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -4,7 +4,7 @@ use std::serialization::{Serializable,
                          Deserializable,
                          Serializer,
                          Deserializer};
-use codemap::{span, filename};
+use codemap::{span, FileName};
 use parse::token;
 
 #[auto_serialize]
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index 4f6c16a39d7..87328f25ca8 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -10,13 +10,13 @@ use std::serialization::{Serializable,
                          Serializer,
                          Deserializer};
 
-pub type byte_pos = uint;
-pub type char_pos = uint;
+pub type BytePos = uint;
+pub type CharPos = uint;
 
 pub struct span {
-    lo: char_pos,
-    hi: char_pos,
-    expn_info: Option<@expn_info>
+    lo: CharPos,
+    hi: CharPos,
+    expn_info: Option<@ExpnInfo>
 }
 
 impl span : cmp::Eq {
@@ -37,70 +37,70 @@ impl<D: Deserializer> span: Deserializable<D> {
     }
 }
 
-pub struct file_pos {
-    ch: char_pos, byte: byte_pos
+pub struct Loc {
+    file: @FileMap, line: uint, col: uint
 }
 
-pub struct loc {
-    file: @filemap, line: uint, col: uint
+pub struct FilePos {
+    ch: CharPos, byte: BytePos
 }
 
-impl file_pos : cmp::Eq {
-    pure fn eq(other: &file_pos) -> bool {
+impl FilePos : cmp::Eq {
+    pure fn eq(other: &FilePos) -> bool {
         self.ch == (*other).ch && self.byte == (*other).byte
     }
-    pure fn ne(other: &file_pos) -> bool { !self.eq(other) }
+    pure fn ne(other: &FilePos) -> bool { !self.eq(other) }
 }
 
-pub enum expn_info {
-    expanded_from({call_site: span,
-                   callie: {name: ~str, span: Option<span>}})
+pub enum ExpnInfo {
+    ExpandedFrom({call_site: span,
+                  callie: {name: ~str, span: Option<span>}})
 }
 
-pub type filename = ~str;
+pub type FileName = ~str;
 
-pub type lookup_fn = pure fn(file_pos) -> uint;
+pub type LookupFn = pure fn(FilePos) -> uint;
 
-pub struct file_lines {
-    file: @filemap,
+pub struct FileLines {
+    file: @FileMap,
     lines: ~[uint]
 }
 
-pub enum file_substr {
-    pub fss_none,
-    pub fss_internal(span),
-    pub fss_external({filename: ~str, line: uint, col: uint})
+pub enum FileSubstr {
+    pub FssNone,
+    pub FssInternal(span),
+    pub FssExternal({filename: ~str, line: uint, col: uint})
 }
 
-pub struct filemap {
-    name: filename,
-    substr: file_substr,
+pub struct FileMap {
+    name: FileName,
+    substr: FileSubstr,
     src: @~str,
-    start_pos: file_pos,
-    mut lines: ~[file_pos]
+    start_pos: FilePos,
+    mut lines: ~[FilePos]
 }
 
-pub impl filemap {
-    static fn new_w_substr(+filename: filename, +substr: file_substr,
+pub impl FileMap {
+    static fn new_w_substr(+filename: FileName, +substr: FileSubstr,
                            src: @~str,
                            start_pos_ch: uint, start_pos_byte: uint)
-        -> filemap {
-        return filemap {
+        -> FileMap {
+        return FileMap {
             name: filename, substr: substr, src: src,
-            start_pos: file_pos {ch: start_pos_ch, byte: start_pos_byte},
-            mut lines: ~[file_pos {ch: start_pos_ch, byte: start_pos_byte}]
+            start_pos: FilePos {ch: start_pos_ch, byte: start_pos_byte},
+            mut lines: ~[FilePos {ch: start_pos_ch, byte: start_pos_byte}]
         };
     }
 
-    static fn new(+filename: filename, src: @~str,
-                  start_pos_ch: char_pos, start_pos_byte: byte_pos)
-        -> filemap {
-        return filemap::new_w_substr(filename, fss_none, src,
+    static fn new(+filename: FileName, src: @~str,
+                  start_pos_ch: CharPos, start_pos_byte: BytePos)
+        -> FileMap {
+        return FileMap::new_w_substr(filename, FssNone, src,
                                      start_pos_ch, start_pos_byte);
     }
 
-    fn next_line(@self, chpos: char_pos, byte_pos: byte_pos) {
-        self.lines.push(file_pos {ch: chpos, byte: byte_pos + self.start_pos.byte});
+    fn next_line(@self, chpos: CharPos, byte_pos: BytePos) {
+        self.lines.push(FilePos {ch: chpos, byte: byte_pos + self.start_pos.byte});
     }
 
     pub fn get_line(@self, line: int) -> ~str unsafe {
@@ -115,7 +115,7 @@ pub impl filemap {
 }
 
 pub struct CodeMap {
-    files: DVec<@filemap>
+    files: DVec<@FileMap>
 }
 
 pub impl CodeMap {
@@ -130,31 +130,31 @@ pub impl CodeMap {
         return fmt!("<%s:%u:%u>", pos.file.name, pos.line, pos.col);
     }
 
-    pub fn lookup_char_pos(@self, pos: char_pos) -> loc {
-        pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
+    pub fn lookup_char_pos(@self, pos: CharPos) -> Loc {
+        pure fn lookup(pos: FilePos) -> uint { return pos.ch; }
         return self.lookup_pos(pos, lookup);
     }
 
-    pub fn lookup_byte_pos(@self, pos: byte_pos) -> loc {
-        pure fn lookup(pos: file_pos) -> uint { return pos.byte; }
+    pub fn lookup_byte_pos(@self, pos: BytePos) -> Loc {
+        pure fn lookup(pos: FilePos) -> uint { return pos.byte; }
         return self.lookup_pos(pos, lookup);
     }
 
-    pub fn lookup_char_pos_adj(@self, pos: char_pos)
-        -> {filename: ~str, line: uint, col: uint, file: Option<@filemap>}
+    pub fn lookup_char_pos_adj(@self, pos: CharPos)
+        -> {filename: ~str, line: uint, col: uint, file: Option<@FileMap>}
     {
         let loc = self.lookup_char_pos(pos);
         match (loc.file.substr) {
-            fss_none => {
+            FssNone => {
                 {filename: /* FIXME (#2543) */ copy loc.file.name,
                  line: loc.line,
                  col: loc.col,
                  file: Some(loc.file)}
             }
-            fss_internal(sp) => {
+            FssInternal(sp) => {
                 self.lookup_char_pos_adj(sp.lo + (pos - loc.file.start_pos.ch))
             }
-            fss_external(eloc) => {
+            FssExternal(eloc) => {
                 {filename: /* FIXME (#2543) */ copy eloc.filename,
                  line: eloc.line + loc.line - 1u,
                  col: if loc.line == 1u {eloc.col + loc.col} else {loc.col},
@@ -164,15 +164,15 @@ pub impl CodeMap {
     }
 
     pub fn adjust_span(@self, sp: span) -> span {
-        pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
+        pure fn lookup(pos: FilePos) -> uint { return pos.ch; }
         let line = self.lookup_line(sp.lo, lookup);
         match (line.fm.substr) {
-            fss_none => sp,
-            fss_internal(s) => {
+            FssNone => sp,
+            FssInternal(s) => {
                 self.adjust_span(span {lo: s.lo + (sp.lo - line.fm.start_pos.ch),
                                        hi: s.lo + (sp.hi - line.fm.start_pos.ch),
                                        expn_info: sp.expn_info})}
-            fss_external(_) => sp
+            FssExternal(_) => sp
         }
     }
 
@@ -183,24 +183,24 @@ pub impl CodeMap {
                     lo.line, lo.col, hi.line, hi.col)
     }
 
-    pub fn span_to_filename(@self, sp: span) -> filename {
+    pub fn span_to_filename(@self, sp: span) -> FileName {
         let lo = self.lookup_char_pos(sp.lo);
         return /* FIXME (#2543) */ copy lo.file.name;
     }
 
-    pub fn span_to_lines(@self, sp: span) -> @file_lines {
+    pub fn span_to_lines(@self, sp: span) -> @FileLines {
         let lo = self.lookup_char_pos(sp.lo);
         let hi = self.lookup_char_pos(sp.hi);
         let mut lines = ~[];
         for uint::range(lo.line - 1u, hi.line as uint) |i| {
             lines.push(i);
         };
-        return @file_lines {file: lo.file, lines: lines};
+        return @FileLines {file: lo.file, lines: lines};
     }
 
-    fn lookup_byte_offset(@self, chpos: char_pos)
-        -> {fm: @filemap, pos: byte_pos} {
-        pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
+    fn lookup_byte_offset(@self, chpos: CharPos)
+        -> {fm: @FileMap, pos: BytePos} {
+        pure fn lookup(pos: FilePos) -> uint { return pos.ch; }
         let {fm, line} = self.lookup_line(chpos, lookup);
         let line_offset = fm.lines[line].byte - fm.start_pos.byte;
         let col = chpos - fm.lines[line].ch;
@@ -215,7 +215,7 @@ pub impl CodeMap {
         return str::slice(*begin.fm.src, begin.pos, end.pos);
     }
 
-    pub fn get_filemap(@self, filename: ~str) -> @filemap {
+    pub fn get_filemap(@self, filename: ~str) -> @FileMap {
         for self.files.each |fm| { if fm.name == filename { return *fm; } }
         //XXjdm the following triggers a mismatched type bug
         //      (or expected function, found _|_)
@@ -225,8 +225,8 @@ pub impl CodeMap {
 }
 
 priv impl CodeMap {
-    fn lookup_line(@self, pos: uint, lookup: lookup_fn)
-        -> {fm: @filemap, line: uint}
+    fn lookup_line(@self, pos: uint, lookup: LookupFn)
+        -> {fm: @FileMap, line: uint}
     {
         let len = self.files.len();
         let mut a = 0u;
@@ -248,9 +248,9 @@ priv impl CodeMap {
         return {fm: f, line: a};
     }
 
-    fn lookup_pos(@self, pos: uint, lookup: lookup_fn) -> loc {
+    fn lookup_pos(@self, pos: uint, lookup: LookupFn) -> Loc {
         let {fm: f, line: a} = self.lookup_line(pos, lookup);
-        return loc {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
+        return Loc {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
     }
 
     fn span_to_str_no_adj(@self, sp: span) -> ~str {
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 66c59683813..22bed009c9a 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -206,7 +206,7 @@ fn emit(cmsp: Option<(@codemap::CodeMap, span)>, msg: &str, lvl: level) {
 }
 
 fn highlight_lines(cm: @codemap::CodeMap, sp: span,
-                   lines: @codemap::file_lines) {
+                   lines: @codemap::FileLines) {
 
     let fm = lines.file;
 
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 127e4a13e27..ad33e99ff04 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -1,7 +1,7 @@
 use std::map::HashMap;
 use parse::parser;
 use diagnostic::span_handler;
-use codemap::{CodeMap, span, expn_info, expanded_from};
+use codemap::{CodeMap, span, ExpnInfo, ExpandedFrom};
 use ast_util::dummy_sp;
 
 // obsolete old-style #macro code:
@@ -129,11 +129,11 @@ trait ext_ctxt {
     fn parse_sess() -> parse::parse_sess;
     fn cfg() -> ast::crate_cfg;
     fn print_backtrace();
-    fn backtrace() -> Option<@expn_info>;
+    fn backtrace() -> Option<@ExpnInfo>;
     fn mod_push(mod_name: ast::ident);
     fn mod_pop();
     fn mod_path() -> ~[ast::ident];
-    fn bt_push(ei: codemap::expn_info);
+    fn bt_push(ei: codemap::ExpnInfo);
     fn bt_pop();
     fn span_fatal(sp: span, msg: &str) -> !;
     fn span_err(sp: span, msg: &str);
@@ -153,7 +153,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
            cfg: ast::crate_cfg) -> ext_ctxt {
     type ctxt_repr = {parse_sess: parse::parse_sess,
                       cfg: ast::crate_cfg,
-                      mut backtrace: Option<@expn_info>,
+                      mut backtrace: Option<@ExpnInfo>,
                       mut mod_path: ~[ast::ident],
                       mut trace_mac: bool};
     impl ctxt_repr: ext_ctxt {
@@ -161,15 +161,15 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
         fn parse_sess() -> parse::parse_sess { self.parse_sess }
         fn cfg() -> ast::crate_cfg { self.cfg }
         fn print_backtrace() { }
-        fn backtrace() -> Option<@expn_info> { self.backtrace }
+        fn backtrace() -> Option<@ExpnInfo> { self.backtrace }
         fn mod_push(i: ast::ident) { self.mod_path.push(i); }
         fn mod_pop() { self.mod_path.pop(); }
         fn mod_path() -> ~[ast::ident] { return self.mod_path; }
-        fn bt_push(ei: codemap::expn_info) {
+        fn bt_push(ei: codemap::ExpnInfo) {
             match ei {
-              expanded_from({call_site: cs, callie: callie}) => {
+              ExpandedFrom({call_site: cs, callie: callie}) => {
                 self.backtrace =
-                    Some(@expanded_from({
+                    Some(@ExpandedFrom({
                         call_site: span {lo: cs.lo, hi: cs.hi,
                                          expn_info: self.backtrace},
                         callie: callie}));
@@ -178,7 +178,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
         }
         fn bt_pop() {
             match self.backtrace {
-              Some(@expanded_from({call_site: span {expn_info: prev, _}, _})) => {
+              Some(@ExpandedFrom({call_site: span {expn_info: prev, _}, _})) => {
                 self.backtrace = prev
               }
               _ => self.bug(~"tried to pop without a push")
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index ca054255fa6..69d067f1ddb 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -8,7 +8,7 @@ use ext::qquote::{qq_helper};
 use parse::{parser, parse_expr_from_source_str, new_parser_from_tt};
 
 
-use codemap::{span, expanded_from};
+use codemap::{span, ExpandedFrom};
 
 fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
                e: expr_, s: span, fld: ast_fold,
@@ -41,7 +41,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
                   Some(normal({expander: exp, span: exp_sp})) => {
                     let expanded = exp(cx, mac.span, args, body);
 
-                    cx.bt_push(expanded_from({call_site: s,
+                    cx.bt_push(ExpandedFrom({call_site: s,
                                 callie: {name: *extname, span: exp_sp}}));
                     //keep going, outside-in
                     let fully_expanded = fld.fold_expr(expanded).node;
@@ -86,7 +86,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
                                          *extname))
                     };
 
-                    cx.bt_push(expanded_from({call_site: s,
+                    cx.bt_push(ExpandedFrom({call_site: s,
                                 callie: {name: *extname, span: exp_sp}}));
                     //keep going, outside-in
                     let fully_expanded = fld.fold_expr(expanded).node;
@@ -100,7 +100,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
                                                                tts);
                     let expanded = exp(cx, mac.span, arg, None);
 
-                    cx.bt_push(expanded_from({call_site: s,
+                    cx.bt_push(ExpandedFrom({call_site: s,
                                 callie: {name: *extname, span: exp_sp}}));
                     //keep going, outside-in
                     let fully_expanded = fld.fold_expr(expanded).node;
@@ -206,7 +206,7 @@ fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
           }
           Some(item_tt(expand)) => {
             let expanded = expand.expander(cx, it.span, it.ident, tts);
-            cx.bt_push(expanded_from({call_site: it.span,
+            cx.bt_push(ExpandedFrom({call_site: it.span,
                                       callie: {name: *extname,
                                                span: expand.span}}));
             let maybe_it = match expanded {
diff --git a/src/libsyntax/ext/qquote.rs b/src/libsyntax/ext/qquote.rs
index 6ae083779cd..1d17b09329c 100644
--- a/src/libsyntax/ext/qquote.rs
+++ b/src/libsyntax/ext/qquote.rs
@@ -208,7 +208,7 @@ fn finish<T: qq_helper>
     debug!("qquote--str==%?", str);
     let fname = cm.mk_substr_filename(body.span);
     let node = parse_from_source_str
-        (f, fname, codemap::fss_internal(body.span), str,
+        (f, fname, codemap::FssInternal(body.span), str,
          ecx.cfg(), ecx.parse_sess());
     let loc = cm.lookup_char_pos(body.span.lo);
 
@@ -345,8 +345,8 @@ fn replace_ty(repls: ~[fragment],
 }
 
 fn mk_file_substr(fname: ~str, line: uint, col: uint) ->
-    codemap::file_substr {
-    codemap::fss_external({filename: fname, line: line, col: col})
+    codemap::FileSubstr {
+    codemap::FssExternal({filename: fname, line: line, col: col})
 }
 
 // Local Variables:
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 8c5048b4c6f..3e4f24dff02 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -1,5 +1,5 @@
 use base::*;
-use codemap::{span, loc, filemap};
+use codemap::{span, Loc, FileMap};
 use print::pprust;
 use build::{mk_base_vec_e,mk_uint,mk_u8,mk_uniq_str};
 
@@ -34,7 +34,7 @@ fn expand_col(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
 fn expand_file(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
                _body: ast::mac_body) -> @ast::expr {
     get_mac_args(cx, sp, arg, 0u, option::Some(0u), ~"file");
-    let loc { file: @filemap { name: filename, _ }, _ } =
+    let Loc { file: @FileMap { name: filename, _ }, _ } =
         cx.codemap().lookup_char_pos(sp.lo);
     return mk_uniq_str(cx, sp, filename);
 }
diff --git a/src/libsyntax/parse.rs b/src/libsyntax/parse.rs
index 3f15a5b6e88..01461a85220 100644
--- a/src/libsyntax/parse.rs
+++ b/src/libsyntax/parse.rs
@@ -20,7 +20,7 @@ use util::interner;
 use diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
 use lexer::{reader, string_reader};
 use parse::token::{ident_interner, mk_ident_interner};
-use codemap::{CodeMap, filemap};
+use codemap::{CodeMap, FileMap};
 
 type parse_sess = @{
     cm: @codemap::CodeMap,
@@ -100,7 +100,7 @@ fn parse_crate_from_source_file(input: &Path, 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, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
-                                                  codemap::fss_none, source);
+                                                  codemap::FssNone, source);
     let r = p.parse_crate_mod(cfg);
     p.abort_if_errors();
     sess.chpos = rdr.chpos;
@@ -111,7 +111,7 @@ fn parse_crate_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, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
-                                                  codemap::fss_none, source);
+                                                  codemap::FssNone, source);
     let r = p.parse_expr();
     p.abort_if_errors();
     sess.chpos = rdr.chpos;
@@ -123,7 +123,7 @@ fn parse_item_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
                               +attrs: ~[ast::attribute],
                               sess: parse_sess) -> Option<@ast::item> {
     let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
-                                                  codemap::fss_none, source);
+                                                  codemap::FssNone, source);
     let r = p.parse_item(attrs);
     p.abort_if_errors();
     sess.chpos = rdr.chpos;
@@ -135,7 +135,7 @@ fn parse_stmt_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
                               +attrs: ~[ast::attribute],
                               sess: parse_sess) -> @ast::stmt {
     let (p, rdr) = new_parser_etc_from_source_str(sess, cfg, name,
-                                                  codemap::fss_none, source);
+                                                  codemap::FssNone, source);
     let r = p.parse_stmt(attrs);
     p.abort_if_errors();
     sess.chpos = rdr.chpos;
@@ -144,7 +144,7 @@ fn parse_stmt_from_source_str(name: ~str, source: @~str, cfg: ast::crate_cfg,
 }
 
 fn parse_from_source_str<T>(f: fn (p: Parser) -> T,
-                            name: ~str, ss: codemap::file_substr,
+                            name: ~str, ss: codemap::FileSubstr,
                             source: @~str, cfg: ast::crate_cfg,
                             sess: parse_sess)
     -> T
@@ -170,10 +170,10 @@ fn next_node_id(sess: parse_sess) -> node_id {
 }
 
 fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
-                                  +name: ~str, +ss: codemap::file_substr,
+                                  +name: ~str, +ss: codemap::FileSubstr,
                                   source: @~str) -> (Parser, string_reader) {
     let ftype = parser::SOURCE_FILE;
-    let filemap = @filemap::new_w_substr
+    let filemap = @FileMap::new_w_substr
         (name, ss, source, sess.chpos, sess.byte_pos);
     sess.cm.files.push(filemap);
     let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,
@@ -182,7 +182,7 @@ fn new_parser_etc_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
 }
 
 fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
-                              +name: ~str, +ss: codemap::file_substr,
+                              +name: ~str, +ss: codemap::FileSubstr,
                               source: @~str) -> Parser {
     let (p, _) = new_parser_etc_from_source_str(sess, cfg, name, ss, source);
     move p
@@ -198,7 +198,7 @@ fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg,
       result::Err(e) => sess.span_diagnostic.handler().fatal(e)
     }
     let src = @result::unwrap(res);
-    let filemap = @filemap::new(path.to_str(), src,
+    let filemap = @FileMap::new(path.to_str(), src,
                                 sess.chpos, sess.byte_pos);
     sess.cm.files.push(filemap);
     let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap,
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 0ed8bd12361..a2f73fd189c 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -3,7 +3,7 @@ use io::ReaderUtil;
 use util::interner;
 use lexer::{string_reader, bump, is_eof, nextch,
                is_whitespace, get_str_from, reader};
-use codemap::filemap;
+use codemap::FileMap;
 
 export cmnt;
 export lit;
@@ -289,7 +289,7 @@ fn gather_comments_and_literals(span_diagnostic: diagnostic::span_handler,
     let src = @str::from_bytes(srdr.read_whole_stream());
     let itr = parse::token::mk_fake_ident_interner();
     let rdr = lexer::new_low_level_string_reader
-        (span_diagnostic, @filemap::new(path, src, 0u, 0u), itr);
+        (span_diagnostic, @FileMap::new(path, src, 0u, 0u), itr);
 
     let mut comments: ~[cmnt] = ~[];
     let mut literals: ~[lit] = ~[];
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 1c984ad57b1..06b8b1e8eee 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -25,7 +25,7 @@ type string_reader = @{
     mut pos: uint,
     mut curr: char,
     mut chpos: uint,
-    filemap: @codemap::filemap,
+    filemap: @codemap::FileMap,
     interner: @token::ident_interner,
     /* cached: */
     mut peek_tok: token::Token,
@@ -33,7 +33,7 @@ type string_reader = @{
 };
 
 fn new_string_reader(span_diagnostic: span_handler,
-                     filemap: @codemap::filemap,
+                     filemap: @codemap::FileMap,
                      itr: @token::ident_interner) -> string_reader {
     let r = new_low_level_string_reader(span_diagnostic, filemap, itr);
     string_advance_token(r); /* fill in peek_* */
@@ -42,7 +42,7 @@ fn new_string_reader(span_diagnostic: span_handler,
 
 /* For comments.rs, which hackily pokes into 'pos' and 'curr' */
 fn new_low_level_string_reader(span_diagnostic: span_handler,
-                               filemap: @codemap::filemap,
+                               filemap: @codemap::FileMap,
                                itr: @token::ident_interner)
     -> string_reader {
     let r = @{span_diagnostic: span_diagnostic, src: filemap.src,
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 9df6b7ab5d2..43628b0908f 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -5,7 +5,7 @@ use either::{Either, Left, Right};
 use std::map::HashMap;
 use token::{can_begin_expr, is_ident, is_ident_or_path, is_plain_ident,
             INTERPOLATED, special_idents};
-use codemap::{span,fss_none};
+use codemap::{span,FssNone};
 use util::interner::Interner;
 use ast_util::{spanned, respan, mk_sp, ident_to_path, operator_prec};
 use lexer::reader;