Skip to content

Commit ee4c770

Browse files
eddybeddyb
committed
rustc: fix the fallout from moving mutability into VstoreSlice and RegionTraitStore.
1 parent a62eba7 commit ee4c770

28 files changed

+409
-478
lines changed

‎src/librustc/metadata/encoder.rs

-12
Original file line numberDiff line numberDiff line change
@@ -232,18 +232,6 @@ pub fn write_type(ecx: &EncodeContext,
232232
tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
233233
}
234234

235-
pub fn write_vstore(ecx: &EncodeContext,
236-
ebml_w: &mut Encoder,
237-
vstore: ty::Vstore) {
238-
let ty_str_ctxt = &tyencode::ctxt {
239-
diag: ecx.diag,
240-
ds: def_to_str,
241-
tcx: ecx.tcx,
242-
abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)
243-
};
244-
tyencode::enc_vstore(ebml_w.writer, ty_str_ctxt, vstore);
245-
}
246-
247235
fn encode_type(ecx: &EncodeContext,
248236
ebml_w: &mut Encoder,
249237
typ: ty::t) {

‎src/librustc/metadata/tydecode.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -145,7 +145,8 @@ fn parse_sigil(st: &mut PState) -> ast::Sigil {
145145
}
146146
}
147147

148-
fn parse_vstore(st: &mut PState, conv: conv_did) -> ty::Vstore {
148+
fn parse_vstore<M>(st: &mut PState, conv: conv_did,
149+
parse_mut: |&mut PState| -> M) -> ty::Vstore<M> {
149150
assert_eq!(next(st), '/');
150151

151152
let c = peek(st);
@@ -156,16 +157,16 @@ fn parse_vstore(st: &mut PState, conv: conv_did) -> ty::Vstore {
156157
}
157158

158159
match next(st) {
159-
'~' => ty::VstoreUniq,
160-
'&' => ty::VstoreSlice(parse_region(st, conv)),
161-
c => st.tcx.sess.bug(format!("parse_vstore(): bad input '{}'", c))
160+
'~' => ty::VstoreUniq,
161+
'&' => ty::VstoreSlice(parse_region(st, conv), parse_mut(st)),
162+
c => st.tcx.sess.bug(format!("parse_vstore(): bad input '{}'", c))
162163
}
163164
}
164165

165166
fn parse_trait_store(st: &mut PState, conv: conv_did) -> ty::TraitStore {
166167
match next(st) {
167168
'~' => ty::UniqTraitStore,
168-
'&' => ty::RegionTraitStore(parse_region(st, conv)),
169+
'&' => ty::RegionTraitStore(parse_region(st, conv), parse_mutability(st)),
169170
c => st.tcx.sess.bug(format!("parse_trait_store(): bad input '{}'", c))
170171
}
171172
}
@@ -327,10 +328,9 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
327328
let def = parse_def(st, NominalType, |x,y| conv(x,y));
328329
let substs = parse_substs(st, |x,y| conv(x,y));
329330
let store = parse_trait_store(st, |x,y| conv(x,y));
330-
let mt = parse_mutability(st);
331331
let bounds = parse_bounds(st, |x,y| conv(x,y));
332332
assert_eq!(next(st), ']');
333-
return ty::mk_trait(st.tcx, def, substs, store, mt, bounds.builtin_bounds);
333+
return ty::mk_trait(st.tcx, def, substs, store, bounds.builtin_bounds);
334334
}
335335
'p' => {
336336
let did = parse_def(st, TypeParameter, |x,y| conv(x,y));
@@ -350,12 +350,12 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
350350
return ty::mk_rptr(st.tcx, r, mt);
351351
}
352352
'V' => {
353-
let mt = parse_mt(st, |x,y| conv(x,y));
354-
let v = parse_vstore(st, |x,y| conv(x,y));
355-
return ty::mk_vec(st.tcx, mt, v);
353+
let ty = parse_ty(st, |x,y| conv(x,y));
354+
let v = parse_vstore(st, |x,y| conv(x,y), parse_mutability);
355+
return ty::mk_vec(st.tcx, ty, v);
356356
}
357357
'v' => {
358-
let v = parse_vstore(st, |x,y| conv(x,y));
358+
let v = parse_vstore(st, |x,y| conv(x,y), |_| ());
359359
return ty::mk_str(st.tcx, v);
360360
}
361361
'T' => {

‎src/librustc/metadata/tyencode.rs

+12-9
Original file line numberDiff line numberDiff line change
@@ -204,14 +204,17 @@ fn enc_bound_region(w: &mut MemWriter, cx: &ctxt, br: ty::BoundRegion) {
204204
}
205205
}
206206

207-
pub fn enc_vstore(w: &mut MemWriter, cx: &ctxt, v: ty::Vstore) {
207+
pub fn enc_vstore<M>(w: &mut MemWriter, cx: &ctxt,
208+
v: ty::Vstore<M>,
209+
enc_mut: |&mut MemWriter, M|) {
208210
mywrite!(w, "/");
209211
match v {
210212
ty::VstoreFixed(u) => mywrite!(w, "{}|", u),
211213
ty::VstoreUniq => mywrite!(w, "~"),
212-
ty::VstoreSlice(r) => {
214+
ty::VstoreSlice(r, m) => {
213215
mywrite!(w, "&");
214216
enc_region(w, cx, r);
217+
enc_mut(w, m);
215218
}
216219
}
217220
}
@@ -224,9 +227,10 @@ pub fn enc_trait_ref(w: &mut MemWriter, cx: &ctxt, s: &ty::TraitRef) {
224227
pub fn enc_trait_store(w: &mut MemWriter, cx: &ctxt, s: ty::TraitStore) {
225228
match s {
226229
ty::UniqTraitStore => mywrite!(w, "~"),
227-
ty::RegionTraitStore(re) => {
230+
ty::RegionTraitStore(re, m) => {
228231
mywrite!(w, "&");
229232
enc_region(w, cx, re);
233+
enc_mutability(w, m);
230234
}
231235
}
232236
}
@@ -266,11 +270,10 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
266270
enc_substs(w, cx, substs);
267271
mywrite!(w, "]");
268272
}
269-
ty::ty_trait(~ty::TyTrait { def_id, ref substs, store, mutability, bounds }) => {
273+
ty::ty_trait(~ty::TyTrait { def_id, ref substs, store, bounds }) => {
270274
mywrite!(w, "x[{}|", (cx.ds)(def_id));
271275
enc_substs(w, cx, substs);
272276
enc_trait_store(w, cx, store);
273-
enc_mutability(w, mutability);
274277
let bounds = ty::ParamBounds {builtin_bounds: bounds,
275278
trait_bounds: Vec::new()};
276279
enc_bounds(w, cx, &bounds);
@@ -289,14 +292,14 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
289292
enc_region(w, cx, r);
290293
enc_mt(w, cx, mt);
291294
}
292-
ty::ty_vec(mt, v) => {
295+
ty::ty_vec(ty, v) => {
293296
mywrite!(w, "V");
294-
enc_mt(w, cx, mt);
295-
enc_vstore(w, cx, v);
297+
enc_ty(w, cx, ty);
298+
enc_vstore(w, cx, v, enc_mutability);
296299
}
297300
ty::ty_str(v) => {
298301
mywrite!(w, "v");
299-
enc_vstore(w, cx, v);
302+
enc_vstore(w, cx, v, |_, ()| {});
300303
}
301304
ty::ty_closure(ref f) => {
302305
mywrite!(w, "f");

‎src/librustc/middle/astencode.rs

+22-27
Original file line numberDiff line numberDiff line change
@@ -513,6 +513,17 @@ impl tr for ty::BoundRegion {
513513
}
514514
}
515515

516+
impl tr for ty::TraitStore {
517+
fn tr(&self, xcx: &ExtendedDecodeContext) -> ty::TraitStore {
518+
match *self {
519+
ty::RegionTraitStore(r, m) => {
520+
ty::RegionTraitStore(r.tr(xcx), m)
521+
}
522+
ty::UniqTraitStore => ty::UniqTraitStore
523+
}
524+
}
525+
}
526+
516527
// ______________________________________________________________________
517528
// Encoding and decoding of freevar information
518529

@@ -823,7 +834,6 @@ impl<'a> get_ty_str_ctxt for e::EncodeContext<'a> {
823834

824835
trait ebml_writer_helpers {
825836
fn emit_ty(&mut self, ecx: &e::EncodeContext, ty: ty::t);
826-
fn emit_vstore(&mut self, ecx: &e::EncodeContext, vstore: ty::Vstore);
827837
fn emit_tys(&mut self, ecx: &e::EncodeContext, tys: &[ty::t]);
828838
fn emit_type_param_def(&mut self,
829839
ecx: &e::EncodeContext,
@@ -840,10 +850,6 @@ impl<'a> ebml_writer_helpers for Encoder<'a> {
840850
self.emit_opaque(|this| Ok(e::write_type(ecx, this, ty)));
841851
}
842852

843-
fn emit_vstore(&mut self, ecx: &e::EncodeContext, vstore: ty::Vstore) {
844-
self.emit_opaque(|this| Ok(e::write_vstore(ecx, this, vstore)));
845-
}
846-
847853
fn emit_tys(&mut self, ecx: &e::EncodeContext, tys: &[ty::t]) {
848854
self.emit_from_vec(tys, |this, ty| Ok(this.emit_ty(ecx, *ty)));
849855
}
@@ -903,14 +909,12 @@ impl<'a> ebml_writer_helpers for Encoder<'a> {
903909
})
904910
}
905911

906-
ty::AutoObject(sigil, region, m, b, def_id, ref substs) => {
907-
this.emit_enum_variant("AutoObject", 2, 6, |this| {
908-
this.emit_enum_variant_arg(0, |this| sigil.encode(this));
909-
this.emit_enum_variant_arg(1, |this| region.encode(this));
910-
this.emit_enum_variant_arg(2, |this| m.encode(this));
911-
this.emit_enum_variant_arg(3, |this| b.encode(this));
912-
this.emit_enum_variant_arg(4, |this| def_id.encode(this));
913-
this.emit_enum_variant_arg(5, |this| Ok(this.emit_substs(ecx, substs)))
912+
ty::AutoObject(store, b, def_id, ref substs) => {
913+
this.emit_enum_variant("AutoObject", 2, 4, |this| {
914+
this.emit_enum_variant_arg(0, |this| store.encode(this));
915+
this.emit_enum_variant_arg(1, |this| b.encode(this));
916+
this.emit_enum_variant_arg(2, |this| def_id.encode(this));
917+
this.emit_enum_variant_arg(3, |this| Ok(this.emit_substs(ecx, substs)))
914918
})
915919
}
916920
}
@@ -1279,25 +1283,16 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> {
12791283
ty::AutoDerefRef(auto_deref_ref.tr(xcx))
12801284
}
12811285
2 => {
1282-
let sigil: ast::Sigil =
1286+
let store: ty::TraitStore =
12831287
this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap();
1284-
let region: Option<ty::Region> =
1285-
this.read_enum_variant_arg(1, |this| Decodable::decode(this)).unwrap();
1286-
let m: ast::Mutability =
1287-
this.read_enum_variant_arg(2, |this| Decodable::decode(this)).unwrap();
12881288
let b: ty::BuiltinBounds =
1289-
this.read_enum_variant_arg(3, |this| Decodable::decode(this)).unwrap();
1289+
this.read_enum_variant_arg(1, |this| Decodable::decode(this)).unwrap();
12901290
let def_id: ast::DefId =
1291-
this.read_enum_variant_arg(4, |this| Decodable::decode(this)).unwrap();
1292-
let substs = this.read_enum_variant_arg(5, |this| Ok(this.read_substs(xcx)))
1291+
this.read_enum_variant_arg(2, |this| Decodable::decode(this)).unwrap();
1292+
let substs = this.read_enum_variant_arg(3, |this| Ok(this.read_substs(xcx)))
12931293
.unwrap();
12941294

1295-
let region = match region {
1296-
Some(r) => Some(r.tr(xcx)),
1297-
None => None
1298-
};
1299-
1300-
ty::AutoObject(sigil, region, m, b, def_id.tr(xcx), substs)
1295+
ty::AutoObject(store.tr(xcx), b, def_id.tr(xcx), substs)
13011296
}
13021297
_ => fail!("bad enum variant for ty::AutoAdjustment")
13031298
})

‎src/librustc/middle/mem_categorization.rs

+8-9
Original file line numberDiff line numberDiff line change
@@ -176,18 +176,17 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
176176
Some(deref_ptr(OwnedPtr))
177177
}
178178

179-
ty::ty_rptr(r, mt) |
180-
ty::ty_vec(mt, ty::VstoreSlice(r)) => {
179+
ty::ty_rptr(r, mt) => {
181180
let kind = ty::BorrowKind::from_mutbl(mt.mutbl);
182181
Some(deref_ptr(BorrowedPtr(kind, r)))
183182
}
184-
185-
ty::ty_trait(~ty::TyTrait { store: ty::RegionTraitStore(r), mutability: m, .. }) => {
186-
let kind = ty::BorrowKind::from_mutbl(m);
183+
ty::ty_vec(_, ty::VstoreSlice(r, mutbl)) |
184+
ty::ty_trait(~ty::TyTrait { store: ty::RegionTraitStore(r, mutbl), .. }) => {
185+
let kind = ty::BorrowKind::from_mutbl(mutbl);
187186
Some(deref_ptr(BorrowedPtr(kind, r)))
188187
}
189188

190-
ty::ty_str(ty::VstoreSlice(r)) |
189+
ty::ty_str(ty::VstoreSlice(r, ())) |
191190
ty::ty_closure(~ty::ClosureTy {sigil: ast::BorrowedSigil,
192191
region: r, ..}) => {
193192
Some(deref_ptr(BorrowedPtr(ty::ImmBorrow, r)))
@@ -799,7 +798,7 @@ impl<TYPER:Typer> MemCategorizationContext<TYPER> {
799798
//! the implicit index deref, if any (see above)
800799
801800
let element_ty = match ty::index(base_cmt.ty) {
802-
Some(ref mt) => mt.ty,
801+
Some(ty) => ty,
803802
None => {
804803
self.tcx().sess.span_bug(
805804
elt.span(),
@@ -882,8 +881,8 @@ impl<TYPER:Typer> MemCategorizationContext<TYPER> {
882881
*/
883882

884883
match ty::get(slice_ty).sty {
885-
ty::ty_vec(slice_mt, ty::VstoreSlice(slice_r)) => {
886-
(slice_mt.mutbl, slice_r)
884+
ty::ty_vec(_, ty::VstoreSlice(slice_r, mutbl)) => {
885+
(mutbl, slice_r)
887886
}
888887

889888
ty::ty_rptr(_, ref mt) => {

‎src/librustc/middle/trans/_match.rs

+2-4
Original file line numberDiff line numberDiff line change
@@ -1109,10 +1109,8 @@ fn extract_vec_elems<'a>(
11091109
let slice_begin = tvec::pointer_add_byte(bcx, base, slice_byte_offset);
11101110
let slice_len_offset = C_uint(bcx.ccx(), elem_count - 1u);
11111111
let slice_len = Sub(bcx, len, slice_len_offset);
1112-
let slice_ty = ty::mk_vec(bcx.tcx(),
1113-
ty::mt {ty: vt.unit_ty, mutbl: ast::MutImmutable},
1114-
ty::VstoreSlice(ty::ReStatic)
1115-
);
1112+
let slice_ty = ty::mk_vec(bcx.tcx(), vt.unit_ty,
1113+
ty::VstoreSlice(ty::ReStatic, ast::MutImmutable));
11161114
let scratch = rvalue_scratch_datum(bcx, slice_ty, "");
11171115
Store(bcx, slice_begin,
11181116
GEPi(bcx, scratch.val, [0u, abi::slice_elt_base]));

‎src/librustc/middle/trans/base.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -657,10 +657,10 @@ pub fn iter_structural_ty<'r,
657657
}
658658
})
659659
}
660-
ty::ty_str(ty::VstoreFixed(_)) |
661-
ty::ty_vec(_, ty::VstoreFixed(_)) => {
662-
let (base, len) = tvec::get_base_and_byte_len(cx, av, t);
660+
ty::ty_str(ty::VstoreFixed(n)) |
661+
ty::ty_vec(_, ty::VstoreFixed(n)) => {
663662
let unit_ty = ty::sequence_element_type(cx.tcx(), t);
663+
let (base, len) = tvec::get_fixed_base_and_byte_len(cx, av, unit_ty, n);
664664
cx = tvec::iter_vec_raw(cx, base, unit_ty, len, f);
665665
}
666666
ty::ty_tup(ref args) => {

‎src/librustc/middle/trans/consts.rs

+7-13
Original file line numberDiff line numberDiff line change
@@ -434,20 +434,14 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
434434
"index is not an integer-constant expression")
435435
};
436436
let (arr, len) = match ty::get(bt).sty {
437-
ty::ty_vec(_, vstore) | ty::ty_str(vstore) =>
438-
match vstore {
439-
ty::VstoreFixed(u) =>
440-
(bv, C_uint(cx, u)),
441-
442-
ty::VstoreSlice(_) => {
443-
let e1 = const_get_elt(cx, bv, [0]);
444-
(const_deref_ptr(cx, e1), const_get_elt(cx, bv, [1]))
445-
},
446-
_ => cx.sess().span_bug(base.span,
447-
"index-expr base must be fixed-size or slice")
437+
ty::ty_vec(_, ty::VstoreFixed(u)) => (bv, C_uint(cx, u)),
438+
ty::ty_vec(_, ty::VstoreSlice(..)) |
439+
ty::ty_str(ty::VstoreSlice(..)) => {
440+
let e1 = const_get_elt(cx, bv, [0]);
441+
(const_deref_ptr(cx, e1), const_get_elt(cx, bv, [1]))
448442
},
449-
_ => cx.sess().span_bug(base.span,
450-
"index-expr base must be a vector or string type")
443+
_ => cx.sess().span_bug(base.span,
444+
"index-expr base must be a fixed-size vector or a slice")
451445
};
452446

453447
let len = llvm::LLVMConstIntGetZExtValue(len) as u64;

0 commit comments

Comments
 (0)