bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Camel case all the codemap types except span

Browse source
This commit is contained in:
Brian Anderson 2012-11-12 18:59:37 -08:00
parent 38b9740668
commit 9ecf86343a
13 changed files with 104 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/middle/trans/debuginfo.rs
View file

@ -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};

2
src/librustdoc/attr_parser.rs
View file

@ -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()
}

2
src/libsyntax/ast.rs
View file

@ -4,7 +4,7 @@ use std::serialization::{Serializable,
Deserializable,
Serializer,
Deserializer};
use codemap::{span, filename};
use codemap::{span, FileName};
use parse::token;
#[auto_serialize]

128
src/libsyntax/codemap.rs
View file

@ -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,
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 {

2
src/libsyntax/diagnostic.rs
View file

@ -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;

18
src/libsyntax/ext/base.rs
View file

@ -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")

10
src/libsyntax/ext/expand.rs
View file

@ -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 {

6
src/libsyntax/ext/qquote.rs
View file

@ -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:

4
src/libsyntax/ext/source_util.rs
View file

@ -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);
}

20
src/libsyntax/parse.rs
View file

@ -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,

4
src/libsyntax/parse/comments.rs
View file

@ -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] = ~[];

6
src/libsyntax/parse/lexer.rs
View file

@ -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,

2
src/libsyntax/parse/parser.rs
View file

@ -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;