aboutsummaryrefslogtreecommitdiff
path: root/src/comp/front
diff options
context:
space:
mode:
Diffstat (limited to 'src/comp/front')
-rw-r--r--src/comp/front/ast.rs15
-rw-r--r--src/comp/front/eval.rs7
-rw-r--r--src/comp/front/extfmt.rs4
-rw-r--r--src/comp/front/lexer.rs14
-rw-r--r--src/comp/front/parser.rs124
-rw-r--r--src/comp/front/token.rs5
6 files changed, 92 insertions, 77 deletions
diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 1970f788..ec93db55 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -91,6 +91,7 @@ tag pat_ {
tag mutability {
mut;
imm;
+ maybe_mut;
}
tag opacity {
@@ -168,7 +169,6 @@ tag unop {
bitnot;
not;
neg;
- _mutable;
}
fn unop_to_str(unop op) -> str {
@@ -178,7 +178,6 @@ fn unop_to_str(unop op) -> str {
case (bitnot) {ret "~";}
case (not) {ret "!";}
case (neg) {ret "-";}
- case (_mutable) {ret "mutable";}
}
}
@@ -215,7 +214,7 @@ type field = rec(mutability mut, ident ident, @expr expr);
type expr = spanned[expr_];
tag expr_ {
- expr_vec(vec[@expr], ann);
+ expr_vec(vec[@expr], mutability, ann);
expr_tup(vec[elt], ann);
expr_rec(vec[field], option.t[@expr], ann);
expr_call(@expr, vec[@expr], ann);
@@ -263,7 +262,8 @@ tag lit_ {
// NB: If you change this, you'll probably want to change the corresponding
// type structure in middle/ty.rs as well.
-type ty_field = rec(ident ident, @ty ty);
+type mt = rec(@ty ty, mutability mut);
+type ty_field = rec(ident ident, mt mt);
type ty_arg = rec(mode mode, @ty ty);
// TODO: effect
type ty_method = rec(proto proto, ident ident,
@@ -277,16 +277,15 @@ tag ty_ {
ty_machine(util.common.ty_mach);
ty_char;
ty_str;
- ty_box(@ty);
- ty_vec(@ty);
+ ty_box(mt);
+ ty_vec(mt);
ty_port(@ty);
ty_chan(@ty);
- ty_tup(vec[@ty]);
+ ty_tup(vec[mt]);
ty_rec(vec[ty_field]);
ty_fn(proto, vec[ty_arg], @ty); // TODO: effect
ty_obj(vec[ty_method]);
ty_path(path, option.t[def]);
- ty_mutable(@ty);
ty_type;
ty_constr(@ty, vec[@constr]);
}
diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs
index ac249848..4cf3765f 100644
--- a/src/comp/front/eval.rs
+++ b/src/comp/front/eval.rs
@@ -13,7 +13,6 @@ import front.parser.new_parser;
import front.parser.parse_mod_items;
import util.common;
import util.common.filename;
-import util.common.append;
import util.common.span;
import util.common.new_str_hash;
@@ -394,7 +393,7 @@ impure fn eval_crate_directive(parser p,
auto im = ast.item_mod(id, m0, next_id);
auto i = @spanned(cdir.span, cdir.span, im);
ast.index_item(index, i);
- append[@ast.item](items, i);
+ _vec.push[@ast.item](items, i);
}
case (ast.cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
@@ -412,11 +411,11 @@ impure fn eval_crate_directive(parser p,
auto im = ast.item_mod(id, m0, p.next_def_id());
auto i = @spanned(cdir.span, cdir.span, im);
ast.index_item(index, i);
- append[@ast.item](items, i);
+ _vec.push[@ast.item](items, i);
}
case (ast.cdir_view_item(?vi)) {
- append[@ast.view_item](view_items, vi);
+ _vec.push[@ast.view_item](view_items, vi);
ast.index_view_item(index, vi);
}
diff --git a/src/comp/front/extfmt.rs b/src/comp/front/extfmt.rs
index 255614d0..0a32a851 100644
--- a/src/comp/front/extfmt.rs
+++ b/src/comp/front/extfmt.rs
@@ -113,7 +113,7 @@ fn parse_fmt_string(str s) -> vec[piece] {
fn flush_buf(str buf, &vec[piece] pieces) -> str {
if (_str.byte_len(buf) > 0u) {
auto piece = piece_string(buf);
- pieces += piece;
+ pieces += vec(piece);
}
ret "";
}
@@ -133,7 +133,7 @@ fn parse_fmt_string(str s) -> vec[piece] {
} else {
buf = flush_buf(buf, pieces);
auto res = parse_conversion(s, i, lim);
- pieces += res._0;
+ pieces += vec(res._0);
i = res._1;
}
} else {
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
index 95fd32c7..403558e2 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/front/lexer.rs
@@ -420,7 +420,7 @@ impure fn next_token(reader rdr) -> token.token {
if (is_alpha(c) || c == '_') {
while (is_alnum(c) || c == '_') {
- accum_str += (c as u8);
+ _str.push_byte(accum_str, (c as u8));
rdr.bump();
c = rdr.curr();
}
@@ -580,23 +580,23 @@ impure fn next_token(reader rdr) -> token.token {
alt (rdr.next()) {
case ('n') {
rdr.bump();
- accum_str += '\n' as u8;
+ _str.push_byte(accum_str, '\n' as u8);
}
case ('r') {
rdr.bump();
- accum_str += '\r' as u8;
+ _str.push_byte(accum_str, '\r' as u8);
}
case ('t') {
rdr.bump();
- accum_str += '\t' as u8;
+ _str.push_byte(accum_str, '\t' as u8);
}
case ('\\') {
rdr.bump();
- accum_str += '\\' as u8;
+ _str.push_byte(accum_str, '\\' as u8);
}
case ('"') {
rdr.bump();
- accum_str += '"' as u8;
+ _str.push_byte(accum_str, '"' as u8);
}
// FIXME: unicode numeric escapes.
case (?c2) {
@@ -607,7 +607,7 @@ impure fn next_token(reader rdr) -> token.token {
}
}
case (_) {
- accum_str += rdr.curr() as u8;
+ _str.push_byte(accum_str, rdr.curr() as u8);
}
}
rdr.bump();
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index a5c79926..028b8a31 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -9,7 +9,6 @@ import std.map.hashmap;
import driver.session;
import util.common;
import util.common.filename;
-import util.common.append;
import util.common.span;
import util.common.new_str_hash;
@@ -190,6 +189,11 @@ impure fn parse_ty_fn(ast.proto proto, parser p,
if (p.peek() == token.BINOP(token.AND)) {
p.bump();
mode = ast.alias;
+
+ if (p.peek() == token.MUTABLE) {
+ p.bump();
+ // TODO: handle mutable alias args
+ }
} else {
mode = ast.val;
}
@@ -263,10 +267,16 @@ impure fn parse_ty_obj(parser p, &mutable ast.span hi) -> ast.ty_ {
ret ast.ty_obj(meths.node);
}
+impure fn parse_mt(parser p) -> ast.mt {
+ auto mut = parse_mutability(p);
+ auto t = parse_ty(p);
+ ret rec(ty=t, mut=mut);
+}
+
impure fn parse_ty_field(parser p) -> ast.ty_field {
- auto ty = parse_ty(p);
+ auto mt = parse_mt(p);
auto id = parse_ident(p);
- ret rec(ident=id, ty=ty);
+ ret rec(ident=id, mt=mt);
}
impure fn parse_constr_arg(parser p) -> @ast.constr_arg {
@@ -303,7 +313,7 @@ impure fn parse_constrs(parser p) -> common.spanned[vec[@ast.constr]] {
case (token.IDENT(_)) {
auto constr = parse_ty_constr(p);
hi = constr.span;
- append[@ast.constr](constrs, constr);
+ _vec.push[@ast.constr](constrs, constr);
if (p.peek() == token.COMMA) {
p.bump();
more = false;
@@ -361,25 +371,25 @@ impure fn parse_ty(parser p) -> @ast.ty {
case (token.AT) {
p.bump();
- auto t0 = parse_ty(p);
- hi = t0.span;
- t = ast.ty_box(t0);
+ auto mt = parse_mt(p);
+ hi = mt.ty.span;
+ t = ast.ty_box(mt);
}
case (token.VEC) {
p.bump();
expect(p, token.LBRACKET);
- t = ast.ty_vec(parse_ty(p));
+ t = ast.ty_vec(parse_mt(p));
hi = p.get_span();
expect(p, token.RBRACKET);
}
case (token.TUP) {
p.bump();
- auto f = parse_ty; // FIXME: trans_const_lval bug
- auto elems = parse_seq[@ast.ty] (token.LPAREN,
- token.RPAREN,
- some(token.COMMA), f, p);
+ auto f = parse_mt; // FIXME: trans_const_lval bug
+ auto elems = parse_seq[ast.mt] (token.LPAREN,
+ token.RPAREN,
+ some(token.COMMA), f, p);
hi = elems.span;
t = ast.ty_tup(elems.node);
}
@@ -396,13 +406,6 @@ impure fn parse_ty(parser p) -> @ast.ty {
t = ast.ty_rec(elems.node);
}
- case (token.MUTABLE) {
- p.bump();
- auto t0 = parse_ty(p);
- hi = t0.span;
- t = ast.ty_mutable(t0);
- }
-
case (token.FN) {
auto flo = p.get_span();
p.bump();
@@ -464,20 +467,22 @@ impure fn parse_arg(parser p) -> ast.arg {
if (p.peek() == token.BINOP(token.AND)) {
m = ast.alias;
p.bump();
+
+ if (p.peek() == token.MUTABLE) {
+ // TODO: handle mutable alias args
+ p.bump();
+ }
}
let @ast.ty t = parse_ty(p);
let ast.ident i = parse_ident(p);
ret rec(mode=m, ty=t, ident=i, id=p.next_def_id());
}
-impure fn parse_seq[T](token.token bra,
- token.token ket,
- option.t[token.token] sep,
- (impure fn(parser) -> T) f,
- parser p) -> util.common.spanned[vec[T]] {
+impure fn parse_seq_to_end[T](token.token ket,
+ option.t[token.token] sep,
+ (impure fn(parser) -> T) f,
+ parser p) -> vec[T] {
let bool first = true;
- auto lo = p.get_span();
- expect(p, bra);
let vec[T] v = vec();
while (p.peek() != ket) {
alt(sep) {
@@ -495,9 +500,20 @@ impure fn parse_seq[T](token.token bra,
let T t = f(p);
v += vec(t);
}
- auto hi = p.get_span();
expect(p, ket);
- ret spanned(lo, hi, v);
+ ret v;
+}
+
+impure fn parse_seq[T](token.token bra,
+ token.token ket,
+ option.t[token.token] sep,
+ (impure fn(parser) -> T) f,
+ parser p) -> util.common.spanned[vec[T]] {
+ auto lo = p.get_span();
+ expect(p, bra);
+ auto result = parse_seq_to_end[T](ket, sep, f, p);
+ auto hi = p.get_span();
+ ret spanned(lo, hi, result);
}
impure fn parse_lit(parser p) -> ast.lit {
@@ -573,7 +589,7 @@ impure fn parse_path(parser p, greed g) -> ast.path {
alt (p.peek()) {
case (token.IDENT(?i)) {
hi = p.get_span();
- ids += i;
+ ids += vec(i);
p.bump();
if (p.peek() == token.DOT) {
if (g == GREEDY) {
@@ -596,16 +612,20 @@ impure fn parse_path(parser p, greed g) -> ast.path {
ret spanned(lo, tys.span, rec(idents=ids, types=tys.node));
}
-impure fn parse_mutabliity(parser p) -> ast.mutability {
+impure fn parse_mutability(parser p) -> ast.mutability {
if (p.peek() == token.MUTABLE) {
p.bump();
+ if (p.peek() == token.QUES) {
+ p.bump();
+ ret ast.maybe_mut;
+ }
ret ast.mut;
}
ret ast.imm;
}
impure fn parse_field(parser p) -> ast.field {
- auto m = parse_mutabliity(p);
+ auto m = parse_mutability(p);
auto i = parse_ident(p);
expect(p, token.EQ);
auto e = parse_expr(p);
@@ -651,7 +671,7 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
case (token.TUP) {
p.bump();
impure fn parse_elt(parser p) -> ast.elt {
- auto m = parse_mutabliity(p);
+ auto m = parse_mutability(p);
auto e = parse_expr(p);
ret rec(mut=m, expr=e);
}
@@ -668,12 +688,15 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
case (token.VEC) {
p.bump();
auto pf = parse_expr;
- auto es = parse_seq[@ast.expr](token.LPAREN,
- token.RPAREN,
- some(token.COMMA),
- pf, p);
- hi = es.span;
- ex = ast.expr_vec(es.node, ast.ann_none);
+
+ expect(p, token.LPAREN);
+ auto mut = parse_mutability(p);
+
+ auto es = parse_seq_to_end[@ast.expr](token.RPAREN,
+ some(token.COMMA),
+ pf, p);
+ hi = p.get_span();
+ ex = ast.expr_vec(es, mut, ast.ann_none);
}
case (token.REC) {
@@ -699,7 +722,7 @@ impure fn parse_bottom_expr(parser p) -> @ast.expr {
}
case (token.COMMA) {
p.bump();
- fields += parse_field(p);
+ fields += vec(parse_field(p));
}
case (?t) {
unexpected(p, t);
@@ -877,7 +900,7 @@ impure fn extend_expr_by_ident(parser p, span lo, span hi,
case (ast.expr_path(?pth, ?def, ?ann)) {
if (_vec.len[@ast.ty](pth.node.types) == 0u) {
auto idents_ = pth.node.idents;
- idents_ += i;
+ idents_ += vec(i);
auto tys = parse_ty_args(p, hi);
auto pth_ = spanned(pth.span, tys.span,
rec(idents=idents_,
@@ -1005,13 +1028,6 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
ex = ast.expr_unary(ast.box, e, ast.ann_none);
}
- case (token.MUTABLE) {
- p.bump();
- auto e = parse_prefix_expr(p);
- hi = e.span;
- ex = ast.expr_unary(ast._mutable, e, ast.ann_none);
- }
-
case (_) {
ret parse_dot_or_call_expr(p);
}
@@ -1559,7 +1575,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool {
}
case (ast.stmt_expr(?e)) {
alt (e.node) {
- case (ast.expr_vec(_,_)) { ret true; }
+ case (ast.expr_vec(_,_,_)) { ret true; }
case (ast.expr_tup(_,_)) { ret true; }
case (ast.expr_rec(_,_,_)) { ret true; }
case (ast.expr_call(_,_,_)) { ret true; }
@@ -1723,6 +1739,7 @@ impure fn parse_item_fn_or_iter(parser p, ast.effect eff) -> @ast.item {
impure fn parse_obj_field(parser p) -> ast.obj_field {
+ auto mut = parse_mutability(p); // TODO: store this, use it in typeck
auto ty = parse_ty(p);
auto ident = parse_ident(p);
ret rec(ty=ty, ident=ident, id=p.next_def_id(), ann=ast.ann_none);
@@ -1763,8 +1780,8 @@ impure fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
dtor = some[ast.block](parse_block(p));
}
case (_) {
- append[@ast.method](meths,
- parse_method(p));
+ _vec.push[@ast.method](meths,
+ parse_method(p));
}
}
}
@@ -2161,12 +2178,11 @@ impure fn parse_rest_import_name(parser p, ast.ident first,
-> @ast.view_item {
auto lo = p.get_span();
auto hi = lo;
- let vec[ast.ident] identifiers = vec();
- identifiers += first;
+ let vec[ast.ident] identifiers = vec(first);
while (p.peek() != token.SEMI) {
expect(p, token.DOT);
auto i = parse_ident(p);
- identifiers += i;
+ identifiers += vec(i);
}
p.bump();
auto defined_id;
@@ -2402,7 +2418,7 @@ impure fn parse_crate_directives(parser p, token.token term)
while (p.peek() != term) {
auto cdir = @parse_crate_directive(p);
- append[@ast.crate_directive](cdirs, cdir);
+ _vec.push[@ast.crate_directive](cdirs, cdir);
}
ret cdirs;
diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs
index 8c594054..62c6406a 100644
--- a/src/comp/front/token.rs
+++ b/src/comp/front/token.rs
@@ -3,6 +3,7 @@ import util.common.ty_mach_to_str;
import util.common.new_str_hash;
import std._int;
import std._uint;
+import std._str;
tag binop {
PLUS;
@@ -302,8 +303,8 @@ fn to_str(token t) -> str {
case (LIT_CHAR(?c)) {
// FIXME: escape and encode.
auto tmp = "'";
- tmp += c as u8;
- tmp += '\'' as u8;
+ _str.push_byte(tmp, c as u8);
+ _str.push_byte(tmp, '\'' as u8);
ret tmp;
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-12 20:13:54 +0000