nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-17 09:23:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

auto merge of #13834 : nick29581/rust/str_fix, r=luqmana

Browse Source
This commit is contained in:
bors 2014-04-28 19:41:47 -07:00
commit 8fdf1e2cb8
26 changed files with 72 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/librustc/metadata/tydecode.rs
View File

@ -344,8 +344,7 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
return ty::mk_vec(st.tcx, mt, sz);
}
'v' => {
let sz = parse_size(st);
return ty::mk_str(st.tcx, sz);
return ty::mk_str(st.tcx);
}
'T' => {
assert_eq!(next(st), '[');

7
src/librustc/metadata/tyencode.rs
View File

@ -260,13 +260,8 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
None => mywrite!(w, "|"),
}
}
ty::ty_str(sz) => {
ty::ty_str => {
mywrite!(w, "v");
mywrite!(w, "/");
match sz {
Some(n) => mywrite!(w, "{}|", n),
None => mywrite!(w, "|"),
}
}
ty::ty_closure(ref f) => {
mywrite!(w, "f");

2
src/librustc/middle/check_match.rs
View File

@ -405,7 +405,7 @@ fn missing_ctor(cx: &MatchCheckCtxt,
ty::ty_struct(..) => check_matrix_for_wild(cx, m),
ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty: ty, ..}) => match ty::get(ty).sty {
ty::ty_vec(_, None) => ctor_for_slice(m),
ty::ty_str(None) => Some(single),
ty::ty_str => Some(single),
_ => check_matrix_for_wild(cx, m),
},
ty::ty_enum(eid, _) => {

4
src/librustc/middle/effect.rs
View File

@ -69,13 +69,13 @@ impl<'a> EffectCheckVisitor<'a> {
ppaux::ty_to_str(self.tcx, base_type));
match ty::get(base_type).sty {
ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty::get(ty).sty {
ty::ty_str(None) => {
ty::ty_str => {
self.tcx.sess.span_err(e.span,
"modification of string types is not allowed");
}
_ => {}
},
ty::ty_str(..) => {
ty::ty_str => {
self.tcx.sess.span_err(e.span,
"modification of string types is not allowed");
}

6
src/librustc/middle/mem_categorization.rs
View File

@ -204,8 +204,7 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
Some(deref_interior(InteriorField(PositionalField(0))))
}
ty::ty_vec(_, Some(_)) |
ty::ty_str(Some(_)) => {
ty::ty_vec(_, Some(_)) => {
Some(deref_interior(InteriorElement(element_kind(t))))
}
@ -1304,11 +1303,10 @@ fn element_kind(t: ty::t) -> ElementKind {
ty::ty_rptr(_, ty::mt{ty:ty, ..}) |
ty::ty_uniq(ty) => match ty::get(ty).sty {
ty::ty_vec(_, None) => VecElement,
ty::ty_str(None) => StrElement,
ty::ty_str => StrElement,
_ => OtherElement
},
ty::ty_vec(..) => VecElement,
ty::ty_str(..) => StrElement,
_ => OtherElement
}
}

5
src/librustc/middle/trans/_match.rs
View File

@ -1316,7 +1316,7 @@ fn compare_values<'a>(
match ty::get(rhs_t).sty {
ty::ty_uniq(t) => match ty::get(t).sty {
ty::ty_str(None) => {
ty::ty_str => {
let scratch_lhs = alloca(cx, val_ty(lhs), "__lhs");
Store(cx, lhs, scratch_lhs);
let scratch_rhs = alloca(cx, val_ty(rhs), "__rhs");
@ -1333,10 +1333,9 @@ fn compare_values<'a>(
_ => cx.sess().bug("only scalars and strings supported in compare_values"),
},
ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
ty::ty_str(None) => compare_str(cx, lhs, rhs, rhs_t),
ty::ty_str => compare_str(cx, lhs, rhs, rhs_t),
_ => cx.sess().bug("only scalars and strings supported in compare_values"),
},
ty::ty_str(Some(_)) => compare_str(cx, lhs, rhs, rhs_t),
_ => cx.sess().bug("only scalars and strings supported in compare_values"),
}
}

2
src/librustc/middle/trans/adt.rs
View File

@ -270,7 +270,7 @@ impl Case {
self.tys.iter().position(|&ty| {
match ty::get(ty).sty {
ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None)=> false,
ty::ty_vec(_, None) | ty::ty_str => false,
_ => true,
},
ty::ty_uniq(..) | ty::ty_box(..) |

5
src/librustc/middle/trans/base.rs
View File

@ -664,11 +664,6 @@ pub fn iter_structural_ty<'r,
}
})
}
ty::ty_str(Some(n)) => {
let unit_ty = ty::sequence_element_type(cx.tcx(), t);
let (base, len) = tvec::get_fixed_base_and_byte_len(cx, av, unit_ty, n);
cx = tvec::iter_vec_raw(cx, base, unit_ty, len, f);
}
ty::ty_vec(_, Some(n)) => {
let unit_ty = ty::sequence_element_type(cx.tcx(), t);
let (base, len) = tvec::get_fixed_base_and_byte_len(cx, av, unit_ty, n);

2
src/librustc/middle/trans/callee.rs
View File

@ -660,7 +660,7 @@ pub fn trans_call_inner<'a>(
// `~` pointer return values never alias because ownership
// is transferred
ty::ty_uniq(ty) => match ty::get(ty).sty {
ty::ty_str(None) => {}
ty::ty_str => {}
_ => attrs.push((0, NoAliasAttribute)),
},
_ => {}

10
src/librustc/middle/trans/consts.rs
View File

@ -141,7 +141,7 @@ fn const_deref(cx: &CrateContext, v: ValueRef, t: ty::t, explicit: bool)
let dv = match ty::get(t).sty {
ty::ty_ptr(mt) | ty::ty_rptr(_, mt) => {
match ty::get(mt.ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => cx.sess().bug("unexpected slice"),
ty::ty_vec(_, None) | ty::ty_str => cx.sess().bug("unexpected slice"),
_ => const_deref_ptr(cx, v),
}
}
@ -434,7 +434,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
let (arr, len) = match ty::get(bt).sty {
ty::ty_vec(_, Some(u)) => (bv, C_uint(cx, u)),
ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => {
ty::ty_vec(_, None) | ty::ty_str => {
let e1 = const_get_elt(cx, bv, [0]);
(const_deref_ptr(cx, e1), const_get_elt(cx, bv, [1]))
},
@ -448,16 +448,12 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
let len = match ty::get(bt).sty {
ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty::get(ty).sty {
ty::ty_str(None) => {
ty::ty_str => {
assert!(len > 0);
len - 1
}
_ => len
},
ty::ty_str(Some(_)) => {
assert!(len > 0);
len - 1
},
_ => len
};
if iv >= len {

8
src/librustc/middle/trans/debuginfo.rs
View File

@ -2183,10 +2183,6 @@ fn type_metadata(cx: &CrateContext,
ty::ty_float(_) => {
basic_type_metadata(cx, t)
}
ty::ty_str(Some(len)) => {
let i8_t = ty::mk_i8();
fixed_vec_metadata(cx, i8_t, len, usage_site_span)
}
ty::ty_enum(def_id, _) => {
prepare_enum_metadata(cx, t, def_id, usage_site_span).finalize(cx)
}
@ -2200,7 +2196,7 @@ fn type_metadata(cx: &CrateContext,
let vec_metadata = vec_metadata(cx, mt.ty, usage_site_span);
pointer_type_metadata(cx, t, vec_metadata)
}
ty::ty_str(None) => {
ty::ty_str => {
let i8_t = ty::mk_i8();
let vec_metadata = vec_metadata(cx, i8_t, usage_site_span);
pointer_type_metadata(cx, t, vec_metadata)
@ -2214,7 +2210,7 @@ fn type_metadata(cx: &CrateContext,
ty::ty_ptr(ref mt) | ty::ty_rptr(_, ref mt) => {
match ty::get(mt.ty).sty {
ty::ty_vec(ref mt, None) => vec_slice_metadata(cx, t, mt.ty, usage_site_span),
ty::ty_str(None) => {
ty::ty_str => {
let i8_t = ty::mk_i8();
vec_slice_metadata(cx, t, i8_t, usage_site_span)
}

6
src/librustc/middle/trans/expr.rs
View File

@ -1507,7 +1507,7 @@ pub fn cast_type_kind(t: ty::t) -> cast_kind {
ty::ty_float(..) => cast_float,
ty::ty_ptr(..) => cast_pointer,
ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty{
ty::ty_vec(_, None) | ty::ty_str(None) => cast_other,
ty::ty_vec(_, None) | ty::ty_str => cast_other,
_ => cast_pointer,
},
ty::ty_bare_fn(..) => cast_pointer,
@ -1717,7 +1717,7 @@ fn deref_once<'a>(bcx: &'a Block<'a>,
let r = match ty::get(datum.ty).sty {
ty::ty_uniq(content_ty) => {
match ty::get(content_ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None)
ty::ty_vec(_, None) | ty::ty_str
=> bcx.tcx().sess.span_bug(expr.span, "unexpected ~[T]"),
_ => deref_owned_pointer(bcx, expr, datum, content_ty),
}
@ -1735,7 +1735,7 @@ fn deref_once<'a>(bcx: &'a Block<'a>,
ty::ty_ptr(ty::mt { ty: content_ty, .. }) |
ty::ty_rptr(_, ty::mt { ty: content_ty, .. }) => {
match ty::get(content_ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None)
ty::ty_vec(_, None) | ty::ty_str
=> bcx.tcx().sess.span_bug(expr.span, "unexpected &[T]"),
_ => {
assert!(!ty::type_needs_drop(bcx.tcx(), datum.ty));

4
src/librustc/middle/trans/glue.rs
View File

@ -84,7 +84,7 @@ fn get_drop_glue_type(ccx: &CrateContext, t: ty::t) -> ty::t {
ty::ty_uniq(typ) if !ty::type_needs_drop(tcx, typ) => {
match ty::get(typ).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => t,
ty::ty_vec(_, None) | ty::ty_str => t,
_ => {
let llty = sizing_type_of(ccx, typ);
// Unique boxes do not allocate for zero-size types. The standard
@ -288,7 +288,7 @@ fn make_drop_glue<'a>(bcx: &'a Block<'a>, v0: ValueRef, t: ty::t) -> &'a Block<'
trans_exchange_free(bcx, llbox)
})
}
ty::ty_str(None) => {
ty::ty_str => {
with_cond(bcx, not_null, |bcx| {
let unit_ty = ty::sequence_element_type(bcx.tcx(), t);
let bcx = tvec::make_drop_glue_unboxed(bcx, llbox, unit_ty);

12
src/librustc/middle/trans/reflect.rs
View File

@ -150,17 +150,13 @@ impl<'a, 'b> Reflector<'a, 'b> {
ty::ty_float(ast::TyF64) => self.leaf("f64"),
ty::ty_float(ast::TyF128) => self.leaf("f128"),
// Should rename to str_*/vec_*.
ty::ty_str(Some(n)) => {
let extra = (vec!(self.c_uint(n))).append(self.c_size_and_align(t).as_slice());
self.visit("estr_fixed".to_owned(), extra.as_slice())
}
// Should rename to vec_*.
ty::ty_vec(ref mt, Some(sz)) => {
let extra = (vec!(self.c_uint(sz))).append(self.c_size_and_align(t).as_slice());
let extra = extra.append(self.c_mt(mt).as_slice());
self.visit("evec_fixed".to_owned(), extra.as_slice())
}
ty::ty_vec(..) | ty::ty_str(..) => fail!("unexpected unsized type"),
ty::ty_vec(..) | ty::ty_str => fail!("unexpected unsized type"),
// Should remove mt from box and uniq.
ty::ty_box(typ) => {
let extra = self.c_mt(&ty::mt {
@ -176,7 +172,7 @@ impl<'a, 'b> Reflector<'a, 'b> {
let extra = extra.append(self.c_mt(mt).as_slice());
self.visit("evec_uniq".to_owned(), extra.as_slice())
}
ty::ty_str(None) => self.visit("estr_uniq".to_owned(), &[]),
ty::ty_str => self.visit("estr_uniq".to_owned(), &[]),
_ => {
let extra = self.c_mt(&ty::mt {
ty: typ,
@ -197,7 +193,7 @@ impl<'a, 'b> Reflector<'a, 'b> {
let extra = extra.append(self.c_mt(mt).as_slice());
self.visit(~"evec_" + name, extra.as_slice())
}
ty::ty_str(None) => self.visit("estr_slice".to_owned(), &[]),
ty::ty_str => self.visit("estr_slice".to_owned(), &[]),
_ => {
let extra = self.c_mt(mt);
self.visit("rptr", extra.as_slice())

7
src/librustc/middle/trans/tvec.rs
View File

@ -244,7 +244,7 @@ pub fn trans_uniq_vstore<'a>(bcx: &'a Block<'a>,
let llptrval = C_cstr(ccx, (*s).clone(), false);
let llptrval = PointerCast(bcx, llptrval, Type::i8p(ccx));
let llsizeval = C_uint(ccx, s.get().len());
let typ = ty::mk_uniq(bcx.tcx(), ty::mk_str(bcx.tcx(), None));
let typ = ty::mk_uniq(bcx.tcx(), ty::mk_str(bcx.tcx()));
let lldestval = rvalue_scratch_datum(bcx,
typ,
"");
@ -478,13 +478,12 @@ pub fn get_base_and_len(bcx: &Block,
let ccx = bcx.ccx();
match ty::get(vec_ty).sty {
ty::ty_str(Some(n)) |
ty::ty_vec(_, Some(n)) => {
let base = GEPi(bcx, llval, [0u, 0u]);
(base, C_uint(ccx, n))
}
ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => {
ty::ty_vec(_, None) | ty::ty_str => {
assert!(!type_is_immediate(bcx.ccx(), vec_ty));
let base = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_base]));
let count = Load(bcx, GEPi(bcx, llval, [0u, abi::slice_elt_len]));
@ -493,7 +492,7 @@ pub fn get_base_and_len(bcx: &Block,
_ => ccx.sess().bug("unexpected type (ty_rptr) in get_base_and_len"),
},
ty::ty_uniq(t) => match ty::get(t).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => {
ty::ty_vec(_, None) | ty::ty_str => {
assert!(type_is_immediate(bcx.ccx(), vec_ty));
let vt = vec_types(bcx, ty::sequence_element_type(bcx.tcx(), vec_ty));
let body = Load(bcx, llval);

15
src/librustc/middle/trans/type_of.rs
View File

@ -121,7 +121,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
ty::ty_ptr(..) => Type::i8p(cx),
ty::ty_rptr(_, mt) => {
match ty::get(mt.ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => {
ty::ty_vec(_, None) | ty::ty_str => {
Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false)
}
_ => Type::i8p(cx),
@ -132,7 +132,6 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
ty::ty_closure(..) => Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false),
ty::ty_trait(..) => Type::opaque_trait(cx),
ty::ty_str(Some(size)) => Type::array(&Type::i8(cx), size as u64),
ty::ty_vec(mt, Some(size)) => {
Type::array(&sizing_type_of(cx, mt.ty), size as u64)
}
@ -154,7 +153,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
}
ty::ty_self(_) | ty::ty_infer(..) | ty::ty_param(..) |
ty::ty_err(..) | ty::ty_vec(_, None) | ty::ty_str(None) => {
ty::ty_err(..) | ty::ty_vec(_, None) | ty::ty_str => {
cx.sess().bug(format!("fictitious type {:?} in sizing_type_of()",
ty::get(t).sty))
}
@ -215,7 +214,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
ty::ty_uniq(typ) => {
match ty::get(typ).sty {
ty::ty_vec(mt, None) => Type::vec(cx, &type_of(cx, mt.ty)).ptr_to(),
ty::ty_str(None) => Type::vec(cx, &Type::i8(cx)).ptr_to(),
ty::ty_str => Type::vec(cx, &Type::i8(cx)).ptr_to(),
_ => type_of(cx, typ).ptr_to(),
}
}
@ -227,7 +226,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
let u_ty = Type::uint_from_ty(cx, ast::TyU);
Type::struct_(cx, [p_ty, u_ty], false)
}
ty::ty_str(None) => {
ty::ty_str => {
// This means we get a nicer name in the output
cx.tn.find_type("str_slice").unwrap()
}
@ -235,10 +234,6 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
}
}
ty::ty_str(Some(n)) => {
Type::array(&Type::i8(cx), (n + 1u) as u64)
}
ty::ty_vec(ref mt, Some(n)) => {
Type::array(&type_of(cx, mt.ty), n as u64)
}
@ -274,7 +269,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
}
ty::ty_vec(_, None) => cx.sess().bug("type_of with unsized ty_vec"),
ty::ty_str(None) => cx.sess().bug("type_of with unsized ty_str"),
ty::ty_str => cx.sess().bug("type_of with unsized (bare) ty_str"),
ty::ty_self(..) => cx.sess().unimpl("type_of with ty_self"),
ty::ty_infer(..) => cx.sess().bug("type_of with ty_infer"),
ty::ty_param(..) => cx.sess().bug("type_of with ty_param"),

56
src/librustc/middle/ty.rs
View File

@ -726,9 +726,8 @@ pub enum sty {
ty_enum(DefId, substs),
ty_box(t),
ty_uniq(t),
// ty_str and ty_vec have an optional length.
ty_str(Option<uint>),
ty_vec(mt, Option<uint>),
ty_str,
ty_vec(mt, Option<uint>), // Second field is length.
ty_ptr(mt),
ty_rptr(Region, mt),
ty_bare_fn(BareFnTy),
@ -1175,7 +1174,7 @@ pub fn mk_t(cx: &ctxt, st: sty) -> t {
}
match &st {
&ty_nil | &ty_bool | &ty_char | &ty_int(_) | &ty_float(_) | &ty_uint(_) |
&ty_str(_) => {}
&ty_str => {}
// You might think that we could just return ty_err for
// any type containing ty_err as a component, and get
// rid of the has_ty_err flag -- likewise for ty_bot (with
@ -1341,14 +1340,14 @@ pub fn mk_mach_float(tm: ast::FloatTy) -> t {
#[inline]
pub fn mk_char() -> t { mk_prim_t(&primitives::TY_CHAR) }
pub fn mk_str(cx: &ctxt, sz: Option<uint>) -> t {
mk_t(cx, ty_str(sz))
pub fn mk_str(cx: &ctxt) -> t {
mk_t(cx, ty_str)
}
pub fn mk_str_slice(cx: &ctxt, r: Region, m: ast::Mutability) -> t {
mk_rptr(cx, r,
mt {
ty: mk_t(cx, ty_str(None)),
ty: mk_t(cx, ty_str),
mutbl: m
})
}
@ -1471,7 +1470,7 @@ pub fn maybe_walk_ty(ty: t, f: |t| -> bool) {
}
match get(ty).sty {
ty_nil | ty_bot | ty_bool | ty_char | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_str(_) | ty_self(_) |
ty_str | ty_self(_) |
ty_infer(_) | ty_param(_) | ty_err => {}
ty_box(ty) | ty_uniq(ty) => maybe_walk_ty(ty, f),
ty_ptr(ref tm) | ty_rptr(_, ref tm) | ty_vec(ref tm, _) => {
@ -1612,7 +1611,7 @@ pub fn type_is_self(ty: t) -> bool {
fn type_is_slice(ty:t) -> bool {
match get(ty).sty {
ty_rptr(_, mt) => match get(mt.ty).sty {
ty_vec(_, None) | ty_str(None) => true,
ty_vec(_, None) | ty_str => true,
_ => false,
},
_ => false
@ -1622,8 +1621,7 @@ fn type_is_slice(ty:t) -> bool {
pub fn type_is_structural(ty: t) -> bool {
match get(ty).sty {
ty_struct(..) | ty_tup(_) | ty_enum(..) | ty_closure(_) | ty_trait(..) |
ty_vec(_, Some(_)) |
ty_str(Some(_)) => true,
ty_vec(_, Some(_)) => true,
_ => type_is_slice(ty)
}
}
@ -1637,12 +1635,11 @@ pub fn type_is_simd(cx: &ctxt, ty: t) -> bool {
pub fn sequence_element_type(cx: &ctxt, ty: t) -> t {
match get(ty).sty {
ty_str(Some(_)) => mk_mach_uint(ast::TyU8),
ty_vec(mt, Some(_)) => mt.ty,
ty_ptr(mt{ty: t, ..}) | ty_rptr(_, mt{ty: t, ..}) |
ty_box(t) | ty_uniq(t) => match get(t).sty {
ty_vec(mt, None) => mt.ty,
ty_str(None) => mk_mach_uint(ast::TyU8),
ty_str => mk_mach_uint(ast::TyU8),
_ => cx.sess.bug("sequence_element_type called on non-sequence value"),
},
_ => cx.sess.bug("sequence_element_type called on non-sequence value"),
@ -1681,7 +1678,7 @@ pub fn type_is_region_ptr(ty: t) -> bool {
ty_rptr(_, mt) => match get(mt.ty).sty {
// FIXME(nrc, DST) slices weren't regarded as rptrs, so we preserve this
// odd behaviour for now. (But ~[] were unique. I have no idea why).
ty_vec(_, None) | ty_str(None) => false,
ty_vec(_, None) | ty_str => false,
_ => true
},
_ => false
@ -2079,7 +2076,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
let result = match get(ty).sty {
// Scalar and unique types are sendable, and durable
ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
ty_bare_fn(_) | ty::ty_char => {
ty_bare_fn(_) | ty::ty_char | ty_str => {
TC::None
}
@ -2093,7 +2090,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
ty_uniq(typ) => {
match get(typ).sty {
ty_str(None) => TC::OwnsOwned,
ty_str => TC::OwnsOwned,
_ => tc_ty(cx, typ, cache).owned_pointer(),
}
}
@ -2108,7 +2105,7 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
ty_rptr(r, ref mt) => {
match get(mt.ty).sty {
ty_str(None) => borrowed_contents(r, ast::MutImmutable),
ty_str => borrowed_contents(r, ast::MutImmutable),
_ => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(r, mt.mutbl)),
}
}
@ -2117,10 +2114,6 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
tc_mt(cx, mt, cache)
}
ty_str(_) => {
TC::None
}
ty_struct(did, ref substs) => {
let flds = struct_fields(cx, did, substs);
let mut res =
@ -2348,7 +2341,7 @@ pub fn is_instantiable(cx: &ctxt, r_ty: t) -> bool {
ty_int(_) |
ty_uint(_) |
ty_float(_) |
ty_str(_) |
ty_str |
ty_bare_fn(_) |
ty_closure(_) |
ty_infer(_) |
@ -2612,7 +2605,7 @@ pub fn deref(t: t, explicit: bool) -> Option<mt> {
match get(t).sty {
ty_box(typ) | ty_uniq(typ) => match get(typ).sty {
// Don't deref ~[] etc., might need to generalise this to all DST.
ty_vec(_, None) | ty_str(None) => None,
ty_vec(_, None) | ty_str => None,
_ => Some(mt {
ty: typ,
mutbl: ast::MutImmutable,
@ -2620,7 +2613,7 @@ pub fn deref(t: t, explicit: bool) -> Option<mt> {
},
ty_rptr(_, mt) => match get(mt.ty).sty {
// Don't deref &[], might need to generalise this to all DST.
ty_vec(_, None) | ty_str(None) => None,
ty_vec(_, None) | ty_str => None,
_ => Some(mt),
},
ty_ptr(mt) if explicit => Some(mt),
@ -2635,10 +2628,9 @@ pub fn index(t: t) -> Option<mt> {
ty_ptr(mt{ty: t, ..}) | ty_rptr(_, mt{ty: t, ..}) |
ty_box(t) | ty_uniq(t) => match get(t).sty {
ty_vec(mt, None) => Some(mt),
ty_str(None) => Some(mt {ty: mk_u8(), mutbl: ast::MutImmutable}),
ty_str => Some(mt {ty: mk_u8(), mutbl: ast::MutImmutable}),
_ => None,
},
ty_str(Some(_)) => Some(mt {ty: mk_u8(), mutbl: ast::MutImmutable}),
_ => None
}
}
@ -2948,7 +2940,7 @@ pub fn adjust_ty(cx: &ctxt,
ty_uniq(t) | ty_ptr(mt{ty: t, ..}) |
ty_rptr(_, mt{ty: t, ..}) => match get(t).sty {
ty::ty_vec(mt, None) => ty::mk_slice(cx, r, ty::mt {ty: mt.ty, mutbl: m}),
ty::ty_str(None) => ty::mk_str_slice(cx, r, m),
ty::ty_str => ty::mk_str_slice(cx, r, m),
_ => {
cx.sess.span_bug(
span,
@ -2956,7 +2948,6 @@ pub fn adjust_ty(cx: &ctxt,
}
},
ty_vec(mt, Some(_)) => ty::mk_slice(cx, r, ty::mt {ty: mt.ty, mutbl: m}),
ty_str(Some(_)) => ty::mk_str_slice(cx, r, m),
ref s => {
cx.sess.span_bug(
@ -3262,7 +3253,7 @@ pub fn param_tys_in_type(ty: t) -> Vec<param_ty> {
pub fn ty_sort_str(cx: &ctxt, t: t) -> ~str {
match get(t).sty {
ty_nil | ty_bot | ty_bool | ty_char | ty_int(_) |
ty_uint(_) | ty_float(_) | ty_str(_) => {
ty_uint(_) | ty_float(_) | ty_str => {
::util::ppaux::ty_to_str(cx, t)
}
@ -4528,13 +4519,8 @@ pub fn hash_crate_independent(tcx: &ctxt, t: t, svh: &Svh) -> u64 {
byte!(6);
hash!(f);
}
ty_str(Some(_)) => {
ty_str => {
byte!(7);
1u8.hash(&mut state);
}
ty_str(None) => {
byte!(7);
0u8.hash(&mut state);
}
ty_enum(d, _) => {
byte!(8);

5
src/librustc/middle/ty_fold.rs
View File

@ -175,10 +175,7 @@ pub fn super_fold_sty<T:TypeFolder>(this: &mut T,
ty::ty_struct(did,
this.fold_substs(substs))
}
ty::ty_str(sz) => {
ty::ty_str(sz)
}
ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_char |
ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_char | ty::ty_str |
ty::ty_int(_) | ty::ty_uint(_) | ty::ty_float(_) |
ty::ty_err | ty::ty_infer(_) |
ty::ty_param(..) | ty::ty_self(_) => {

4
src/librustc/middle/typeck/astconv.rs
View File

@ -355,7 +355,7 @@ pub fn ast_ty_to_prim_ty(tcx: &ty::ctxt, ast_ty: &ast::Ty) -> Option<ty::t> {
tcx.sess.span_err(ast_ty.span,
"bare `str` is not a type");
// return /something/ so they can at least get more errors
Some(ty::mk_uniq(tcx, ty::mk_str(tcx, None)))
Some(ty::mk_uniq(tcx, ty::mk_str(tcx)))
}
}
}
@ -414,7 +414,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
match ptr_ty {
Uniq => {
return ty::mk_uniq(tcx, ty::mk_str(tcx, None));
return ty::mk_uniq(tcx, ty::mk_str(tcx));
}
RPtr(r) => {
return ty::mk_str_slice(tcx, r, ast::MutImmutable);

11
src/librustc/middle/typeck/check/method.rs
View File

@ -769,7 +769,7 @@ impl<'a> LookupContext<'a> {
self.infcx().next_region_var(infer::Autoref(self.span));
let (extra_derefs, auto) = match ty::get(self_mt.ty).sty {
ty::ty_vec(_, None) => (0, ty::AutoBorrowVec(region, self_mt.mutbl)),
ty::ty_str(None) => (0, ty::AutoBorrowVec(region, self_mt.mutbl)),
ty::ty_str => (0, ty::AutoBorrowVec(region, self_mt.mutbl)),
_ => (1, ty::AutoPtr(region, self_mt.mutbl)),
};
(ty::mk_rptr(tcx, region, self_mt),
@ -878,11 +878,10 @@ impl<'a> LookupContext<'a> {
},
ty_uniq(t) => match ty::get(t).sty {
ty_vec(mt, None) => self.auto_slice_vec(mt, autoderefs),
ty_str(None) => self.auto_slice_str(autoderefs),
ty_str => self.auto_slice_str(autoderefs),
_ => None
},
ty_vec(mt, Some(_)) => self.auto_slice_vec(mt, autoderefs),
ty_str(Some(_)) => self.auto_slice_str(autoderefs),
ty_trait(~ty::TyTrait { def_id: trt_did, substs: trt_substs, bounds: b, .. }) => {
// Coerce ~/&Trait instances to &Trait.
@ -921,7 +920,7 @@ impl<'a> LookupContext<'a> {
ty_self(_) | ty_param(..) | ty_nil | ty_bot | ty_bool |
ty_char | ty_int(..) | ty_uint(..) |
ty_float(..) | ty_enum(..) | ty_ptr(..) | ty_struct(..) | ty_tup(..) |
ty_str(..) | ty_vec(..) | ty_trait(..) | ty_closure(..) => {
ty_str | ty_vec(..) | ty_trait(..) | ty_closure(..) => {
self.search_for_some_kind_of_autorefd_method(
AutoPtr, autoderefs, [MutImmutable, MutMutable],
|m,r| ty::mk_rptr(tcx, r, ty::mt {ty:self_ty, mutbl:m}))
@ -1318,7 +1317,7 @@ impl<'a> LookupContext<'a> {
match ty::get(rcvr_ty).sty {
ty::ty_rptr(_, mt) => {
match ty::get(mt.ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => false,
ty::ty_vec(_, None) | ty::ty_str => false,
_ => mutability_matches(mt.mutbl, m) &&
rcvr_matches_ty(self.fcx, mt.ty, candidate),
}
@ -1340,7 +1339,7 @@ impl<'a> LookupContext<'a> {
match ty::get(rcvr_ty).sty {
ty::ty_uniq(typ) => {
match ty::get(typ).sty {
ty::ty_vec(_, None) | ty::ty_str(None) => false,
ty::ty_vec(_, None) | ty::ty_str => false,
_ => rcvr_matches_ty(self.fcx, typ, candidate),
}
}

2
src/librustc/middle/typeck/check/mod.rs
View File

@ -2567,7 +2567,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
ast::ExprVstore(ev, vst) => {
let typ = match ev.node {
ast::ExprLit(lit) if ast_util::lit_is_str(lit) => {
ast_expr_vstore_to_ty(fcx, ev, vst, || ty::mt{ ty: ty::mk_str(tcx, None),
ast_expr_vstore_to_ty(fcx, ev, vst, || ty::mt{ ty: ty::mk_str(tcx),
mutbl: ast::MutImmutable })
}
ast::ExprVec(ref args) => {

2
src/librustc/middle/typeck/check/regionck.rs
View File

@ -940,7 +940,7 @@ fn constrain_index(rcx: &mut Rcx,
let r_index_expr = ty::ReScope(index_expr.id);
match ty::get(indexed_ty).sty {
ty::ty_rptr(r_ptr, mt) => match ty::get(mt.ty).sty {
ty::ty_vec(_, None) | ty::ty_str(None)=> {
ty::ty_vec(_, None) | ty::ty_str => {
rcx.fcx.mk_subr(true, infer::IndexSlice(index_expr.span),
r_index_expr, r_ptr);
}

4
src/librustc/middle/typeck/infer/coercion.rs
View File

@ -108,7 +108,7 @@ impl<'f> Coerce<'f> {
});
}
ty::ty_vec(_, _) => {},
ty::ty_str(None) => {
ty::ty_str => {
return self.unpack_actual_value(a, |sty_a| {
self.coerce_borrowed_string(a, sty_a, b)
});
@ -263,7 +263,7 @@ impl<'f> Coerce<'f> {
match *sty_a {
ty::ty_uniq(t) => match ty::get(t).sty {
ty::ty_str(None) => {}
ty::ty_str => {}
_ => return self.subtype(a, b),
},
_ => {

12
src/librustc/middle/typeck/infer/combine.rs
View File

@ -383,9 +383,9 @@ pub fn super_tys<C:Combine>(this: &C, a: ty::t, b: ty::t) -> cres<ty::t> {
result: ty::t) -> cres<ty::t> {
match (&ty::get(a_inner).sty, &ty::get(b_inner).sty) {
(&ty::ty_vec(_, None), &ty::ty_vec(_, None)) |
(&ty::ty_str(None), &ty::ty_str(None)) => Ok(result),
(&ty::ty_str, &ty::ty_str) => Ok(result),
(&ty::ty_vec(_, None), _) | (_, &ty::ty_vec(_, None)) |
(&ty::ty_str(None), _) | (_, &ty::ty_str(None))
(&ty::ty_str, _) | (_, &ty::ty_str)
=> Err(ty::terr_sorts(expected_found(this, a, b))),
_ => Ok(result),
}
@ -520,12 +520,8 @@ pub fn super_tys<C:Combine>(this: &C, a: ty::t, b: ty::t) -> cres<ty::t> {
})
}
(&ty::ty_str(sz_a), &ty::ty_str(sz_b)) => {
if sz_a == sz_b {
Ok(ty::mk_str(tcx,sz_a))
} else {
Err(ty::terr_sorts(expected_found(this, a, b)))
}
(&ty::ty_str, &ty::ty_str) => {
Ok(ty::mk_str(tcx))
}
(&ty::ty_tup(ref as_), &ty::ty_tup(ref bs)) => {

2
src/librustc/middle/typeck/variance.rs
View File

@ -706,7 +706,7 @@ impl<'a> ConstraintContext<'a> {
match ty::get(ty).sty {
ty::ty_nil | ty::ty_bot | ty::ty_bool |
ty::ty_char | ty::ty_int(_) | ty::ty_uint(_) |
ty::ty_float(_) | ty::ty_str(_) => {
ty::ty_float(_) | ty::ty_str => {
/* leaf type -- noop */
}

7
src/librustc/util/ppaux.rs
View File

@ -395,12 +395,7 @@ pub fn ty_to_str(cx: &ctxt, typ: t) -> ~str {
let bound_str = bounds.repr(cx);
format!("{}{}{}{}", trait_store_to_str(cx, store), ty, bound_sep, bound_str)
}
ty_str(sz) => {
match sz {
Some(n) => format!("str/{}", n),
None => "str".to_owned(),
}
}
ty_str => "str".to_owned(),
ty_vec(ref mt, sz) => {
match sz {
Some(n) => format!("[{}, .. {}]", mt_to_str(cx, mt), n),