user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Port the compiler to the typaram foo<T> syntax.

Browse source
This commit is contained in:
Erick Tryzelaar 2011-08-12 07:15:18 -07:00 • committed by Graydon Hoare
parent f764f9a8cf
commit e4a0f997fb
51 changed files with 568 additions and 568 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/comp/syntax/parse/lexer.rs
View file

@ -20,7 +20,7 @@ type reader =
fn init() ;
fn bump() ;
fn get_str_from(uint) -> str ;
fn get_interner() -> @interner::interner[str] ;
fn get_interner() -> @interner::interner<str> ;
fn get_chpos() -> uint ;
fn get_byte_pos() -> uint ;
fn get_col() -> uint ;
@ -29,7 +29,7 @@ type reader =
};
fn new_reader(cm: &codemap::codemap, src: str, filemap: codemap::filemap,
itr: @interner::interner[str]) -> reader {
itr: @interner::interner<str>) -> reader {
obj reader(cm: codemap::codemap,
src: str,
len: uint,
@ -39,7 +39,7 @@ fn new_reader(cm: &codemap::codemap, src: str, filemap: codemap::filemap,
mutable chpos: uint,
mutable strs: [str],
fm: codemap::filemap,
itr: @interner::interner[str]) {
itr: @interner::interner<str>) {
fn is_eof() -> bool { ret ch == -1 as char; }
fn get_str_from(start: uint) -> str {
// I'm pretty skeptical about this subtraction. What if there's a
@ -74,7 +74,7 @@ fn new_reader(cm: &codemap::codemap, src: str, filemap: codemap::filemap,
ch = next.ch;
} else { ch = -1 as char; }
}
fn get_interner() -> @interner::interner[str] { ret itr; }
fn get_interner() -> @interner::interner<str> { ret itr; }
fn get_col() -> uint { ret col; }
fn get_filemap() -> codemap::filemap { ret fm; }
fn err(m: str) {
@ -173,7 +173,7 @@ fn digits_to_string(s: str) -> int {
ret accum_int;
}
fn scan_exponent(rdr: &reader) -> option::t[str] {
fn scan_exponent(rdr: &reader) -> option::t<str> {
let c = rdr.curr();
let rslt = "";
if c == 'e' || c == 'E' {

60
src/comp/syntax/parse/parser.rs
View file

@ -52,7 +52,7 @@ type parser =
fn get_str(token::str_num) -> str ;
fn get_reader() -> lexer::reader ;
fn get_filemap() -> codemap::filemap ;
fn get_bad_expr_words() -> hashmap[str, ()] ;
fn get_bad_expr_words() -> hashmap<str, ()> ;
fn get_chpos() -> uint ;
fn get_byte_pos() -> uint ;
fn get_id() -> node_id ;
@ -84,7 +84,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
mutable restr: restriction,
rdr: lexer::reader,
precs: @[op_spec],
bad_words: hashmap[str, ()]) {
bad_words: hashmap<str, ()>) {
fn peek() -> token::token { ret tok; }
fn bump() {
last_tok_span = tok_span;
@ -132,7 +132,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
}
fn get_reader() -> lexer::reader { ret rdr; }
fn get_filemap() -> codemap::filemap { ret rdr.get_filemap(); }
fn get_bad_expr_words() -> hashmap[str, ()] { ret bad_words; }
fn get_bad_expr_words() -> hashmap<str, ()> { ret bad_words; }
fn get_chpos() -> uint { ret rdr.get_chpos(); }
fn get_byte_pos() -> uint { ret rdr.get_byte_pos(); }
fn get_id() -> node_id { ret next_node_id(sess); }
@ -148,7 +148,7 @@ fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
// These are the words that shouldn't be allowed as value identifiers,
// because, if used at the start of a line, they will cause the line to be
// interpreted as a specific kind of statement, which would be confusing.
fn bad_expr_word_table() -> hashmap[str, ()] {
fn bad_expr_word_table() -> hashmap<str, ()> {
let words = new_str_hash();
words.insert("mod", ());
words.insert("if", ());
@ -224,7 +224,7 @@ fn expect_gt(p: &parser) {
}
}
fn spanned[T](lo: uint, hi: uint, node: &T) -> spanned[T] {
fn spanned[T](lo: uint, hi: uint, node: &T) -> spanned<T> {
ret {node: node, span: ast::mk_sp(lo, hi)};
}
@ -429,9 +429,9 @@ fn parse_constr_in_type(p: &parser) -> @ast::ty_constr {
}
fn parse_constrs[T](pser: fn(&parser) -> @ast::constr_general[T] , p: &parser)
-> [@ast::constr_general[T]] {
let constrs: [@ast::constr_general[T]] = ~[];
fn parse_constrs[T](pser: fn(&parser) -> @ast::constr_general<T>, p: &parser)
-> [@ast::constr_general<T>] {
let constrs: [@ast::constr_general<T>] = ~[];
while true {
let constr = pser(p);
constrs += ~[constr];
@ -643,7 +643,7 @@ fn parse_fn_block_arg(p: &parser) -> ast::arg {
ret {mode: m, ty: t, ident: i, id: p.get_id()};
}
fn parse_seq_to_before_gt[T](sep: option::t[token::token],
fn parse_seq_to_before_gt[T](sep: option::t<token::token>,
f: fn(&parser) -> T, p: &parser) -> [T] {
let first = true;
let v = ~[];
@ -660,7 +660,7 @@ fn parse_seq_to_before_gt[T](sep: option::t[token::token],
ret v;
}
fn parse_seq_to_gt[T](sep: option::t[token::token], f: fn(&parser) -> T,
fn parse_seq_to_gt[T](sep: option::t<token::token>, f: fn(&parser) -> T,
p: &parser) -> [T] {
let v = parse_seq_to_before_gt(sep, f, p);
expect_gt(p);
@ -668,8 +668,8 @@ fn parse_seq_to_gt[T](sep: option::t[token::token], f: fn(&parser) -> T,
ret v;
}
fn parse_seq_lt_gt[T](sep: option::t[token::token], f: fn(&parser) -> T,
p: &parser) -> spanned[[T]] {
fn parse_seq_lt_gt[T](sep: option::t<token::token>, f: fn(&parser) -> T,
p: &parser) -> spanned<[T]> {
let lo = p.get_lo_pos();
expect(p, token::LT);
let result = parse_seq_to_before_gt[T](sep, f, p);
@ -678,14 +678,14 @@ fn parse_seq_lt_gt[T](sep: option::t[token::token], f: fn(&parser) -> T,
ret spanned(lo, hi, result);
}
fn parse_seq_to_end[T](ket: token::token, sep: option::t[token::token],
fn parse_seq_to_end[T](ket: token::token, sep: option::t<token::token>,
f: fn(&parser) -> T , p: &parser) -> [T] {
let val = parse_seq_to_before_end(ket, sep, f, p);
p.bump();
ret val;
}
fn parse_seq_to_before_end[T](ket: token::token, sep: option::t[token::token],
fn parse_seq_to_before_end[T](ket: token::token, sep: option::t<token::token>,
f: fn(&parser) -> T , p: &parser) -> [T] {
let first: bool = true;
let v: [T] = ~[];
@ -701,8 +701,8 @@ fn parse_seq_to_before_end[T](ket: token::token, sep: option::t[token::token],
fn parse_seq[T](bra: token::token, ket: token::token,
sep: option::t[token::token], f: fn(&parser) -> T ,
p: &parser) -> spanned[[T]] {
sep: option::t<token::token>, f: fn(&parser) -> T ,
p: &parser) -> spanned<[T]> {
let lo = p.get_lo_pos();
expect(p, bra);
let result = parse_seq_to_before_end[T](ket, sep, f, p);
@ -955,7 +955,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
// Anonymous object
// Only make people type () if they're actually adding new fields
let fields: option::t[[ast::anon_obj_field]] = none;
let fields: option::t<[ast::anon_obj_field]> = none;
if p.peek() == token::LPAREN {
p.bump();
fields =
@ -963,7 +963,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
parse_anon_obj_field, p));
}
let meths: [@ast::method] = ~[];
let inner_obj: option::t[@ast::expr] = none;
let inner_obj: option::t<@ast::expr> = none;
expect(p, token::LBRACE);
while p.peek() != token::RBRACE {
if eat_word(p, "with") {
@ -982,7 +982,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
ex = ast::expr_anon_obj(ob);
} else if (eat_word(p, "bind")) {
let e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
fn parse_expr_opt(p: &parser) -> option::t[@ast::expr] {
fn parse_expr_opt(p: &parser) -> option::t<@ast::expr> {
alt p.peek() {
token::UNDERSCORE. { p.bump(); ret none; }
_ { ret some(parse_expr(p)); }
@ -1329,13 +1329,13 @@ fn parse_assign_expr(p: &parser) -> @ast::expr {
fn parse_if_expr_1(p: &parser) ->
{cond: @ast::expr,
then: ast::blk,
els: option::t[@ast::expr],
els: option::t<@ast::expr>,
lo: uint,
hi: uint} {
let lo = p.get_last_lo_pos();
let cond = parse_expr(p);
let thn = parse_block(p);
let els: option::t[@ast::expr] = none;
let els: option::t<@ast::expr> = none;
let hi = thn.span.hi;
if eat_word(p, "else") {
let elexpr = parse_else_expr(p);
@ -1437,7 +1437,7 @@ fn parse_expr_res(p: &parser, r: restriction) -> @ast::expr {
ret e;
}
fn parse_initializer(p: &parser) -> option::t[ast::initializer] {
fn parse_initializer(p: &parser) -> option::t<ast::initializer> {
alt p.peek() {
token::EQ. {
p.bump();
@ -1653,7 +1653,7 @@ fn parse_source_stmt(p: &parser) -> @ast::stmt {
}
}
fn stmt_to_expr(stmt: @ast::stmt) -> option::t[@ast::expr] {
fn stmt_to_expr(stmt: @ast::stmt) -> option::t<@ast::expr> {
ret alt stmt.node { ast::stmt_expr(e, _) { some(e) } _ { none } };
}
@ -1724,7 +1724,7 @@ fn parse_block(p: &parser) -> ast::blk {
// some blocks start with "#{"...
fn parse_block_tail(p: &parser, lo: uint) -> ast::blk {
let stmts: [@ast::stmt] = ~[];
let expr: option::t[@ast::expr] = none;
let expr: option::t<@ast::expr> = none;
while p.peek() != token::RBRACE {
alt p.peek() {
token::SEMI. {
@ -1796,7 +1796,7 @@ fn parse_ty_params(p: &parser) -> [ast::ty_param] {
fn parse_fn_decl(p: &parser, purity: ast::purity, il: ast::inlineness)
-> ast::fn_decl {
let inputs: ast::spanned[[ast::arg]] =
let inputs: ast::spanned<[ast::arg]> =
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA), parse_arg,
p);
let rslt: ty_or_bang;
@ -1835,7 +1835,7 @@ fn parse_fn_decl(p: &parser, purity: ast::purity, il: ast::inlineness)
}
fn parse_fn_block_decl(p: &parser) -> ast::fn_decl {
let inputs: ast::spanned[[ast::arg]] =
let inputs: ast::spanned<[ast::arg]> =
parse_seq(token::BINOP(token::OR), token::BINOP(token::OR),
some(token::COMMA), parse_fn_block_arg, p);
ret {inputs: inputs.node,
@ -1910,7 +1910,7 @@ fn parse_item_obj(p: &parser, attrs: &[ast::attribute]) ->
let lo = p.get_last_lo_pos();
let ident = parse_value_ident(p);
let ty_params = parse_ty_params(p);
let fields: ast::spanned[[ast::obj_field]] =
let fields: ast::spanned<[ast::obj_field]> =
parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
parse_obj_field, p);
let meths: [@ast::method] = ~[];
@ -2171,7 +2171,7 @@ fn parse_auth(p: &parser) -> ast::_auth {
} else { unexpected(p, p.peek()); }
}
fn parse_item(p: &parser, attrs: &[ast::attribute]) -> option::t[@ast::item] {
fn parse_item(p: &parser, attrs: &[ast::attribute]) -> option::t<@ast::item> {
if eat_word(p, "const") {
ret some(parse_item_const(p, attrs));
} else if (eat_word(p, "inline")) {
@ -2207,7 +2207,7 @@ fn parse_item(p: &parser, attrs: &[ast::attribute]) -> option::t[@ast::item] {
// A type to distingush between the parsing of item attributes or syntax
// extensions, which both begin with token.POUND
type attr_or_ext = option::t[either::t[[ast::attribute], @ast::expr]];
type attr_or_ext = option::t<either::t<[ast::attribute], @ast::expr>>;
fn parse_outer_attrs_or_ext(p: &parser) -> attr_or_ext {
if p.peek() == token::POUND {
@ -2311,7 +2311,7 @@ fn parse_use(p: &parser) -> ast::view_item_ {
}
fn parse_rest_import_name(p: &parser, first: ast::ident,
def_ident: option::t[ast::ident]) ->
def_ident: option::t<ast::ident>) ->
ast::view_item_ {
let identifiers: [ast::ident] = ~[first];
let glob: bool = false;