Skip to content

Commit 4e034f8

Browse files
pcwaltonpcwalton
committed
---
yaml --- r: 2174 b: refs/heads/master c: cac7524 h: refs/heads/master v: v3
1 parent 366391c commit 4e034f8

File tree

5 files changed

+108
-102
lines changed

5 files changed

+108
-102
lines changed

‎[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,2 @@
11
---
2-
refs/heads/master: 38e842244c33ced2bc248a0b0911b507336829c9
2+
refs/heads/master: cac7524c1aa63961973e3607d72a49dfccb09448

‎trunk/src/comp/front/creader.rs

Lines changed: 51 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -75,52 +75,28 @@ fn parse_ty_str(str rep, str_def sd) -> @ty.t {
7575
}
7676

7777
fn parse_ty(@pstate st, str_def sd) -> @ty.t {
78-
ret @rec(struct=parse_sty(st, sd),
79-
cname=option.none[str]);
80-
}
81-
82-
fn parse_mt(@pstate st, str_def sd) -> ty.mt {
83-
auto mut;
84-
alt (peek(st) as char) {
85-
case ('m') {next(st); mut = ast.mut;}
86-
case ('?') {next(st); mut = ast.maybe_mut;}
87-
case (_) {mut=ast.imm;}
88-
}
89-
ret rec(ty=parse_ty(st, sd), mut=mut);
90-
}
91-
92-
fn parse_def(@pstate st, str_def sd) -> ast.def_id {
93-
auto def = "";
94-
while (peek(st) as char != '|') {
95-
def += _str.unsafe_from_byte(next(st));
96-
}
97-
st.pos = st.pos + 1u;
98-
ret sd(def);
99-
}
100-
101-
fn parse_sty(@pstate st, str_def sd) -> ty.sty {
10278
alt (next(st) as char) {
103-
case ('n') {ret ty.ty_nil;}
104-
case ('b') {ret ty.ty_bool;}
105-
case ('i') {ret ty.ty_int;}
106-
case ('u') {ret ty.ty_uint;}
107-
case ('l') {ret ty.ty_float;}
79+
case ('n') { ret ty.mk_nil(); }
80+
case ('b') { ret ty.mk_bool(); }
81+
case ('i') { ret ty.mk_int(); }
82+
case ('u') { ret ty.mk_uint(); }
83+
case ('l') { ret ty.mk_float(); }
10884
case ('M') {
10985
alt (next(st) as char) {
110-
case ('b') {ret ty.ty_machine(common.ty_u8);}
111-
case ('w') {ret ty.ty_machine(common.ty_u16);}
112-
case ('l') {ret ty.ty_machine(common.ty_u32);}
113-
case ('d') {ret ty.ty_machine(common.ty_u64);}
114-
case ('B') {ret ty.ty_machine(common.ty_i8);}
115-
case ('W') {ret ty.ty_machine(common.ty_i16);}
116-
case ('L') {ret ty.ty_machine(common.ty_i32);}
117-
case ('D') {ret ty.ty_machine(common.ty_i64);}
118-
case ('f') {ret ty.ty_machine(common.ty_f32);}
119-
case ('F') {ret ty.ty_machine(common.ty_f64);}
86+
case ('b') { ret ty.mk_mach(common.ty_u8); }
87+
case ('w') { ret ty.mk_mach(common.ty_u16); }
88+
case ('l') { ret ty.mk_mach(common.ty_u32); }
89+
case ('d') { ret ty.mk_mach(common.ty_u64); }
90+
case ('B') { ret ty.mk_mach(common.ty_i8); }
91+
case ('W') { ret ty.mk_mach(common.ty_i16); }
92+
case ('L') { ret ty.mk_mach(common.ty_i32); }
93+
case ('D') { ret ty.mk_mach(common.ty_i64); }
94+
case ('f') { ret ty.mk_mach(common.ty_f32); }
95+
case ('F') { ret ty.mk_mach(common.ty_f64); }
12096
}
12197
}
122-
case ('c') {ret ty.ty_char;}
123-
case ('s') {ret ty.ty_str;}
98+
case ('c') { ret ty.mk_char(); }
99+
case ('s') { ret ty.mk_str(); }
124100
case ('t') {
125101
check(next(st) as char == '[');
126102
auto def = parse_def(st, sd);
@@ -129,21 +105,21 @@ fn parse_sty(@pstate st, str_def sd) -> ty.sty {
129105
params += vec(parse_ty(st, sd));
130106
}
131107
st.pos = st.pos + 1u;
132-
ret ty.ty_tag(def, params);
108+
ret ty.mk_tag(def, params);
133109
}
134-
case ('p') {ret ty.ty_param(parse_int(st) as uint);}
135-
case ('@') {ret ty.ty_box(parse_mt(st, sd));}
136-
case ('V') {ret ty.ty_vec(parse_mt(st, sd));}
137-
case ('P') {ret ty.ty_port(parse_ty(st, sd));}
138-
case ('C') {ret ty.ty_chan(parse_ty(st, sd));}
110+
case ('p') { ret ty.mk_param(parse_int(st) as uint); }
111+
case ('@') { ret ty.mk_box(parse_mt(st, sd)); }
112+
case ('V') { ret ty.mk_vec(parse_mt(st, sd)); }
113+
case ('P') { ret ty.mk_port(parse_ty(st, sd)); }
114+
case ('C') { ret ty.mk_chan(parse_ty(st, sd)); }
139115
case ('T') {
140116
check(next(st) as char == '[');
141117
let vec[ty.mt] params = vec();
142118
while (peek(st) as char != ']') {
143119
params += vec(parse_mt(st, sd));
144120
}
145121
st.pos = st.pos + 1u;
146-
ret ty.ty_tup(params);
122+
ret ty.mk_tup(params);
147123
}
148124
case ('R') {
149125
check(next(st) as char == '[');
@@ -157,15 +133,15 @@ fn parse_sty(@pstate st, str_def sd) -> ty.sty {
157133
fields += vec(rec(ident=name, mt=parse_mt(st, sd)));
158134
}
159135
st.pos = st.pos + 1u;
160-
ret ty.ty_rec(fields);
136+
ret ty.mk_rec(fields);
161137
}
162138
case ('F') {
163139
auto func = parse_ty_fn(st, sd);
164-
ret ty.ty_fn(ast.proto_fn, func._0, func._1);
140+
ret ty.mk_fn(ast.proto_fn, func._0, func._1);
165141
}
166142
case ('W') {
167143
auto func = parse_ty_fn(st, sd);
168-
ret ty.ty_fn(ast.proto_iter, func._0, func._1);
144+
ret ty.mk_fn(ast.proto_iter, func._0, func._1);
169145
}
170146
case ('N') {
171147
auto abi;
@@ -175,7 +151,7 @@ fn parse_sty(@pstate st, str_def sd) -> ty.sty {
175151
case ('l') {abi = ast.native_abi_llvm;}
176152
}
177153
auto func = parse_ty_fn(st, sd);
178-
ret ty.ty_native_fn(abi,func._0,func._1);
154+
ret ty.mk_native_fn(abi,func._0,func._1);
179155
}
180156
case ('O') {
181157
check(next(st) as char == '[');
@@ -197,12 +173,31 @@ fn parse_sty(@pstate st, str_def sd) -> ty.sty {
197173
output=func._1));
198174
}
199175
st.pos += 1u;
200-
ret ty.ty_obj(methods);
176+
ret ty.mk_obj(methods);
201177
}
202-
case ('X') {ret ty.ty_var(parse_int(st));}
203-
case ('E') {ret ty.ty_native;}
204-
case ('Y') {ret ty.ty_type;}
178+
case ('X') { ret ty.mk_var(parse_int(st)); }
179+
case ('E') { ret ty.mk_native(); }
180+
case ('Y') { ret ty.mk_type(); }
181+
}
182+
}
183+
184+
fn parse_mt(@pstate st, str_def sd) -> ty.mt {
185+
auto mut;
186+
alt (peek(st) as char) {
187+
case ('m') {next(st); mut = ast.mut;}
188+
case ('?') {next(st); mut = ast.maybe_mut;}
189+
case (_) {mut=ast.imm;}
205190
}
191+
ret rec(ty=parse_ty(st, sd), mut=mut);
192+
}
193+
194+
fn parse_def(@pstate st, str_def sd) -> ast.def_id {
195+
auto def = "";
196+
while (peek(st) as char != '|') {
197+
def += _str.unsafe_from_byte(next(st));
198+
}
199+
st.pos = st.pos + 1u;
200+
ret sd(def);
206201
}
207202

208203
fn parse_int(@pstate st) -> int {

‎trunk/src/comp/middle/trans.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2843,12 +2843,12 @@ fn trans_lit(@crate_ctxt cx, &ast.lit lit, &ast.ann ann) -> ValueRef {
28432843
fn target_type(@crate_ctxt cx, @ty.t t) -> @ty.t {
28442844
alt (t.struct) {
28452845
case (ty.ty_int) {
2846-
auto tm = ty.ty_machine(cx.sess.get_targ_cfg().int_type);
2847-
ret @rec(struct=tm with *t);
2846+
auto struct_ty = ty.mk_mach(cx.sess.get_targ_cfg().int_type);
2847+
ret ty.copy_cname(struct_ty, t);
28482848
}
28492849
case (ty.ty_uint) {
2850-
auto tm = ty.ty_machine(cx.sess.get_targ_cfg().uint_type);
2851-
ret @rec(struct=tm with *t);
2850+
auto struct_ty = ty.mk_mach(cx.sess.get_targ_cfg().uint_type);
2851+
ret ty.copy_cname(struct_ty, t);
28522852
}
28532853
case (_) { /* fall through */ }
28542854
}

‎trunk/src/comp/middle/ty.rs

Lines changed: 23 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -386,10 +386,6 @@ fn walk_ty(ty_walk walker, @t ty) {
386386
type ty_fold = fn(@t) -> @t;
387387

388388
fn fold_ty(ty_fold fld, @t ty_0) -> @t {
389-
fn rewrap(@t orig, &sty new) -> @t {
390-
ret @rec(struct=new, cname=orig.cname);
391-
}
392-
393389
auto ty = ty_0;
394390
alt (ty.struct) {
395391
case (ty_nil) { /* no-op */ }
@@ -403,31 +399,33 @@ fn fold_ty(ty_fold fld, @t ty_0) -> @t {
403399
case (ty_type) { /* no-op */ }
404400
case (ty_native) { /* no-op */ }
405401
case (ty_box(?tm)) {
406-
ty = rewrap(ty, ty_box(rec(ty=fold_ty(fld, tm.ty), mut=tm.mut)));
402+
ty = copy_cname(mk_box(rec(ty=fold_ty(fld, tm.ty), mut=tm.mut)),
403+
ty);
407404
}
408405
case (ty_vec(?tm)) {
409-
ty = rewrap(ty, ty_vec(rec(ty=fold_ty(fld, tm.ty), mut=tm.mut)));
406+
ty = copy_cname(mk_vec(rec(ty=fold_ty(fld, tm.ty), mut=tm.mut)),
407+
ty);
410408
}
411409
case (ty_port(?subty)) {
412-
ty = rewrap(ty, ty_port(fold_ty(fld, subty)));
410+
ty = copy_cname(mk_port(fold_ty(fld, subty)), ty);
413411
}
414412
case (ty_chan(?subty)) {
415-
ty = rewrap(ty, ty_chan(fold_ty(fld, subty)));
413+
ty = copy_cname(mk_chan(fold_ty(fld, subty)), ty);
416414
}
417415
case (ty_tag(?tid, ?subtys)) {
418416
let vec[@t] new_subtys = vec();
419417
for (@t subty in subtys) {
420418
new_subtys += vec(fold_ty(fld, subty));
421419
}
422-
ty = rewrap(ty, ty_tag(tid, new_subtys));
420+
ty = copy_cname(mk_tag(tid, new_subtys), ty);
423421
}
424422
case (ty_tup(?mts)) {
425423
let vec[mt] new_mts = vec();
426424
for (mt tm in mts) {
427425
auto new_subty = fold_ty(fld, tm.ty);
428426
new_mts += vec(rec(ty=new_subty, mut=tm.mut));
429427
}
430-
ty = rewrap(ty, ty_tup(new_mts));
428+
ty = copy_cname(mk_tup(new_mts), ty);
431429
}
432430
case (ty_rec(?fields)) {
433431
let vec[field] new_fields = vec();
@@ -436,24 +434,24 @@ fn fold_ty(ty_fold fld, @t ty_0) -> @t {
436434
auto new_mt = rec(ty=new_ty, mut=fl.mt.mut);
437435
new_fields += vec(rec(ident=fl.ident, mt=new_mt));
438436
}
439-
ty = rewrap(ty, ty_rec(new_fields));
437+
ty = copy_cname(mk_rec(new_fields), ty);
440438
}
441439
case (ty_fn(?proto, ?args, ?ret_ty)) {
442440
let vec[arg] new_args = vec();
443441
for (arg a in args) {
444442
auto new_ty = fold_ty(fld, a.ty);
445443
new_args += vec(rec(mode=a.mode, ty=new_ty));
446444
}
447-
ty = rewrap(ty, ty_fn(proto, new_args, fold_ty(fld, ret_ty)));
445+
ty = copy_cname(mk_fn(proto, new_args, fold_ty(fld, ret_ty)), ty);
448446
}
449447
case (ty_native_fn(?abi, ?args, ?ret_ty)) {
450448
let vec[arg] new_args = vec();
451449
for (arg a in args) {
452450
auto new_ty = fold_ty(fld, a.ty);
453451
new_args += vec(rec(mode=a.mode, ty=new_ty));
454452
}
455-
ty = rewrap(ty, ty_native_fn(abi, new_args,
456-
fold_ty(fld, ret_ty)));
453+
ty = copy_cname(mk_native_fn(abi, new_args, fold_ty(fld, ret_ty)),
454+
ty);
457455
}
458456
case (ty_obj(?methods)) {
459457
let vec[method] new_methods = vec();
@@ -466,7 +464,7 @@ fn fold_ty(ty_fold fld, @t ty_0) -> @t {
466464
inputs=new_args,
467465
output=fold_ty(fld, m.output)));
468466
}
469-
ty = rewrap(ty, ty_obj(new_methods));
467+
ty = copy_cname(mk_obj(new_methods), ty);
470468
}
471469
case (ty_var(_)) { /* no-op */ }
472470
case (ty_local(_)) { /* no-op */ }
@@ -479,6 +477,16 @@ fn fold_ty(ty_fold fld, @t ty_0) -> @t {
479477

480478
// Type utilities
481479

480+
fn rename(@t typ, str new_cname) -> @t {
481+
ret @rec(struct=typ.struct, cname=some[str](new_cname));
482+
}
483+
484+
// Returns a type with the structural part taken from `struct_ty` and the
485+
// canonical name from `cname_ty`.
486+
fn copy_cname(@t struct_ty, @t cname_ty) -> @t {
487+
ret @rec(struct=struct_ty.struct, cname=cname_ty.cname);
488+
}
489+
482490
// FIXME: remove me when == works on these tags.
483491
fn mode_is_alias(ast.mode m) -> bool {
484492
alt (m) {

0 commit comments

Comments
 (0)