Similar to my recent changes to ~[T]/&[T], these changes remove the vstore abstraction and represent str types as ~(str) and &(str). The Option<uint> in ty_str is the length of the string, None if the string is dynamically sized.
parse_substs(&mut st, conv)
}
-fn parse_vstore(st: &mut PState, conv: conv_did) -> ty::Vstore {
- assert_eq!(next(st), '/');
-
- let c = peek(st);
- if '0' <= c && c <= '9' {
- let n = parse_uint(st);
- assert_eq!(next(st), '|');
- return ty::VstoreFixed(n);
- }
-
- match next(st) {
- '~' => ty::VstoreUniq,
- '&' => ty::VstoreSlice(parse_region(st, conv)),
- c => st.tcx.sess.bug(format!("parse_vstore(): bad input '{}'", c))
- }
-}
-
fn parse_size(st: &mut PState) -> Option<uint> {
assert_eq!(next(st), '/');
return ty::mk_vec(st.tcx, mt, sz);
}
'v' => {
- let v = parse_vstore(st, |x,y| conv(x,y));
- return ty::mk_str(st.tcx, v);
+ let sz = parse_size(st);
+ return ty::mk_str(st.tcx, sz);
}
'T' => {
assert_eq!(next(st), '[');
}
}
-pub fn enc_vstore(w: &mut MemWriter, cx: &ctxt,
- v: ty::Vstore,
- enc_mut: |&mut MemWriter|) {
- mywrite!(w, "/");
- match v {
- ty::VstoreFixed(u) => mywrite!(w, "{}|", u),
- ty::VstoreUniq => mywrite!(w, "~"),
- ty::VstoreSlice(r) => {
- mywrite!(w, "&");
- enc_region(w, cx, r);
- enc_mut(w);
- }
- }
-}
-
pub fn enc_trait_ref(w: &mut MemWriter, cx: &ctxt, s: &ty::TraitRef) {
mywrite!(w, "{}|", (cx.ds)(s.def_id));
enc_substs(w, cx, &s.substs);
None => mywrite!(w, "|"),
}
}
- ty::ty_str(v) => {
+ ty::ty_str(sz) => {
mywrite!(w, "v");
- enc_vstore(w, cx, v, |_| {});
+ mywrite!(w, "/");
+ match sz {
+ Some(n) => mywrite!(w, "{}|", n),
+ None => mywrite!(w, "|"),
+ }
}
ty::ty_closure(ref f) => {
mywrite!(w, "f");
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),
_ => check_matrix_for_wild(cx, m),
},
ty::ty_enum(eid, _) => {
debug!("effect: checking index with base type {}",
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) => {
+ self.tcx.sess.span_err(e.span,
+ "modification of string types is not allowed");
+ }
+ _ => {}
+ },
ty::ty_str(..) => {
self.tcx.sess.span_err(e.span,
"modification of string types is not allowed");
ty::ty_box(_) => {
n_box += 1;
}
- ty::ty_uniq(_) | ty::ty_str(ty::VstoreUniq) |
+ ty::ty_uniq(_) |
ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) |
ty::ty_closure(~ty::ClosureTy { store: ty::UniqTraitStore, .. }) => {
n_uniq += 1;
match ty::get(t).sty {
ty::ty_uniq(_) |
ty::ty_trait(~ty::TyTrait { store: ty::UniqTraitStore, .. }) |
- ty::ty_str(ty::VstoreUniq) |
ty::ty_closure(~ty::ClosureTy {store: ty::UniqTraitStore, ..}) => {
Some(deref_ptr(OwnedPtr))
}
Some(deref_ptr(BorrowedPtr(kind, r)))
}
- ty::ty_str(ty::VstoreSlice(r)) |
ty::ty_closure(~ty::ClosureTy {store: ty::RegionTraitStore(r, _), ..}) => {
Some(deref_ptr(BorrowedPtr(ty::ImmBorrow, r)))
}
}
ty::ty_vec(_, Some(_)) |
- ty::ty_str(ty::VstoreFixed(_)) => {
+ ty::ty_str(Some(_)) => {
Some(deref_interior(InteriorElement(element_kind(t))))
}
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,
_ => OtherElement
},
ty::ty_vec(..) => VecElement,
rhs: ValueRef,
rhs_t: ty::t)
-> Result<'a> {
+ fn compare_str<'a>(cx: &'a Block<'a>,
+ lhs: ValueRef,
+ rhs: ValueRef,
+ rhs_t: ty::t)
+ -> Result<'a> {
+ let did = langcall(cx, None,
+ format!("comparison of `{}`", cx.ty_to_str(rhs_t)),
+ StrEqFnLangItem);
+ let result = callee::trans_lang_call(cx, did, [lhs, rhs], None);
+ Result {
+ bcx: result.bcx,
+ val: bool_to_i1(result.bcx, result.val)
+ }
+ }
+
let _icx = push_ctxt("compare_values");
if ty::type_is_scalar(rhs_t) {
- let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, ast::BiEq);
- return rslt(rs.bcx, rs.val);
+ let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, ast::BiEq);
+ return rslt(rs.bcx, rs.val);
}
match ty::get(rhs_t).sty {
- ty::ty_str(ty::VstoreUniq) => {
- let scratch_lhs = alloca(cx, val_ty(lhs), "__lhs");
- Store(cx, lhs, scratch_lhs);
- let scratch_rhs = alloca(cx, val_ty(rhs), "__rhs");
- Store(cx, rhs, scratch_rhs);
- let did = langcall(cx, None,
- format!("comparison of `{}`", cx.ty_to_str(rhs_t)),
- UniqStrEqFnLangItem);
- let result = callee::trans_lang_call(cx, did, [scratch_lhs, scratch_rhs], None);
- Result {
- bcx: result.bcx,
- val: bool_to_i1(result.bcx, result.val)
- }
- }
- ty::ty_str(_) => {
- let did = langcall(cx, None,
- format!("comparison of `{}`", cx.ty_to_str(rhs_t)),
- StrEqFnLangItem);
- let result = callee::trans_lang_call(cx, did, [lhs, rhs], None);
- Result {
- bcx: result.bcx,
- val: bool_to_i1(result.bcx, result.val)
+ ty::ty_uniq(t) => match ty::get(t).sty {
+ ty::ty_str(None) => {
+ let scratch_lhs = alloca(cx, val_ty(lhs), "__lhs");
+ Store(cx, lhs, scratch_lhs);
+ let scratch_rhs = alloca(cx, val_ty(rhs), "__rhs");
+ Store(cx, rhs, scratch_rhs);
+ let did = langcall(cx, None,
+ format!("comparison of `{}`", cx.ty_to_str(rhs_t)),
+ UniqStrEqFnLangItem);
+ let result = callee::trans_lang_call(cx, did, [scratch_lhs, scratch_rhs], None);
+ Result {
+ bcx: result.bcx,
+ val: bool_to_i1(result.bcx, result.val)
+ }
}
- }
- _ => {
- cx.sess().bug("only scalars and strings supported in compare_values");
- }
+ _ => 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),
+ _ => 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"),
}
}
self.tys.iter().position(|&ty| {
match ty::get(ty).sty {
ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
- ty::ty_vec(_, None) => false,
+ ty::ty_vec(_, None) | ty::ty_str(None)=> false,
_ => true,
},
ty::ty_uniq(..) | ty::ty_box(..) |
- ty::ty_str(ty::VstoreUniq) |
ty::ty_bare_fn(..) => true,
// Is that everything? Would closures or slices qualify?
_ => false
// `~` pointer return values never alias because ownership is transferred
// FIXME #6750 ~Trait cannot be directly marked as
// noalias because the actual object pointer is nested.
- ty::ty_uniq(..) | // ty::ty_trait(_, _, ty::UniqTraitStore, _, _) |
- ty::ty_str(ty::VstoreUniq) => {
+ ty::ty_uniq(..) // | ty::ty_trait(_, _, ty::UniqTraitStore, _, _)
+ => {
unsafe {
llvm::LLVMAddReturnAttribute(llfn, lib::llvm::NoAliasAttribute as c_uint);
}
// FIXME #6750 ~Trait cannot be directly marked as
// noalias because the actual object pointer is nested.
ty::ty_uniq(..) | // ty::ty_trait(_, _, ty::UniqTraitStore, _, _) |
- ty::ty_str(ty::VstoreUniq) |
ty::ty_closure(~ty::ClosureTy {store: ty::UniqTraitStore, ..}) => {
unsafe {
llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
}
})
}
- ty::ty_str(ty::VstoreFixed(n)) => {
+ 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);
match ty::get(ret_ty).sty {
// `~` pointer return values never alias because ownership
// is transferred
- ty::ty_uniq(..) => {
- attrs.push((0, NoAliasAttribute));
- }
+ ty::ty_uniq(ty) => match ty::get(ty).sty {
+ ty::ty_str(None) => {}
+ _ => attrs.push((0, NoAliasAttribute)),
+ },
_ => {}
}
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) => cx.sess().bug("unexpected slice"),
+ ty::ty_vec(_, None) | ty::ty_str(None) => cx.sess().bug("unexpected slice"),
_ => const_deref_ptr(cx, v),
}
}
"index is not an integer-constant expression")
};
let (arr, len) = match ty::get(bt).sty {
- ty::ty_str(ty::VstoreSlice(..)) => {
- let e1 = const_get_elt(cx, bv, [0]);
- (const_deref_ptr(cx, e1), const_get_elt(cx, bv, [1]))
- },
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_vec(_, None) | ty::ty_str(None) => {
let e1 = const_get_elt(cx, bv, [0]);
(const_deref_ptr(cx, e1), const_get_elt(cx, bv, [1]))
},
let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
let len = match ty::get(bt).sty {
- ty::ty_str(..) => {assert!(len > 0); len - 1},
+ ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty::get(ty).sty {
+ ty::ty_str(None) => {
+ assert!(len > 0);
+ len - 1
+ }
+ _ => len
+ },
+ ty::ty_str(Some(_)) => {
+ assert!(len > 0);
+ len - 1
+ },
_ => len
};
if iv >= len {
ty::ty_uint(_) |
ty::ty_float(_) => {
basic_type_metadata(cx, t)
- },
- ty::ty_str(ref vstore) => {
+ }
+ ty::ty_str(Some(len)) => {
let i8_t = ty::mk_i8();
- match *vstore {
- ty::VstoreFixed(len) => {
- fixed_vec_metadata(cx, i8_t, len, usage_site_span)
- },
- ty::VstoreUniq => {
- let vec_metadata = vec_metadata(cx, i8_t, usage_site_span);
- pointer_type_metadata(cx, t, vec_metadata)
- }
- ty::VstoreSlice(..) => {
- vec_slice_metadata(cx, t, i8_t, usage_site_span)
- }
- }
- },
+ 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)
- },
+ }
ty::ty_box(typ) => {
create_pointer_to_box_metadata(cx, t, typ)
- },
+ }
ty::ty_vec(ref mt, Some(len)) => fixed_vec_metadata(cx, mt.ty, len, usage_site_span),
ty::ty_uniq(typ) => {
match ty::get(typ).sty {
let vec_metadata = vec_metadata(cx, mt.ty, usage_site_span);
pointer_type_metadata(cx, t, vec_metadata)
}
+ ty::ty_str(None) => {
+ let i8_t = ty::mk_i8();
+ let vec_metadata = vec_metadata(cx, i8_t, usage_site_span);
+ pointer_type_metadata(cx, t, vec_metadata)
+ }
_ => {
let pointee = type_metadata(cx, typ, usage_site_span);
pointer_type_metadata(cx, t, pointee)
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) => {
+ let i8_t = ty::mk_i8();
+ vec_slice_metadata(cx, t, i8_t, usage_site_span)
+ }
_ => {
let pointee = type_metadata(cx, mt.ty, usage_site_span);
pointer_type_metadata(cx, t, pointee)
}
}
- },
+ }
ty::ty_bare_fn(ref barefnty) => {
subroutine_type_metadata(cx, &barefnty.sig, usage_site_span)
- },
+ }
ty::ty_closure(ref closurety) => {
subroutine_type_metadata(cx, &closurety.sig, usage_site_span)
- },
+ }
ty::ty_trait(~ty::TyTrait { def_id, ref substs, store, ref bounds }) => {
trait_metadata(cx, def_id, t, substs, store, bounds)
- },
+ }
ty::ty_struct(def_id, ref substs) => {
if ty::type_is_simd(cx.tcx(), t) {
let element_type = ty::simd_type(cx.tcx(), t);
} else {
prepare_struct_metadata(cx, t, def_id, substs, usage_site_span).finalize(cx)
}
- },
+ }
ty::ty_tup(ref elements) => {
prepare_tuple_metadata(cx,
t,
ty::ty_float(..) => cast_float,
ty::ty_ptr(..) => cast_pointer,
ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty{
- ty::ty_vec(_, None) => cast_other,
+ ty::ty_vec(_, None) | ty::ty_str(None) => cast_other,
_ => cast_pointer,
},
ty::ty_bare_fn(..) => cast_pointer,
let r = match ty::get(datum.ty).sty {
ty::ty_uniq(content_ty) => {
match ty::get(content_ty).sty {
- ty::ty_vec(_, None) => bcx.tcx().sess.span_bug(expr.span, "unexpected ~[T]"),
+ ty::ty_vec(_, None) | ty::ty_str(None)
+ => bcx.tcx().sess.span_bug(expr.span, "unexpected ~[T]"),
_ => deref_owned_pointer(bcx, expr, datum, content_ty),
}
}
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) => bcx.tcx().sess.span_bug(expr.span, "unexpected &[T]"),
+ ty::ty_vec(_, None) | ty::ty_str(None)
+ => bcx.tcx().sess.span_bug(expr.span, "unexpected &[T]"),
_ => {
assert!(!ty::type_needs_drop(bcx.tcx(), datum.ty));
ty::ty_uniq(typ) if !ty::type_needs_drop(tcx, typ) => {
match ty::get(typ).sty {
- ty::ty_vec(_, None) => t,
+ ty::ty_vec(_, None) | ty::ty_str(None) => t,
_ => {
let llty = sizing_type_of(ccx, typ);
// Unique boxes do not allocate for zero-size types. The standard
trans_exchange_free(bcx, llbox)
})
}
+ ty::ty_str(None) => {
+ 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);
+ trans_exchange_free(bcx, llbox)
+ })
+ }
_ => {
with_cond(bcx, not_null, |bcx| {
let bcx = drop_ty(bcx, llbox, content_ty);
}
}
}
- ty::ty_str(ty::VstoreUniq) => {
- let llbox = Load(bcx, v0);
- let not_null = IsNotNull(bcx, llbox);
- 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);
- trans_exchange_free(bcx, llbox)
- })
- }
ty::ty_struct(did, ref substs) => {
let tcx = bcx.tcx();
match ty::ty_dtor(tcx, did) {
// We're careful to not use first class aggregates here because that
// will kick us off fast isel. (Issue #4352.)
let bcx = self.bcx;
- let str_vstore = ty::VstoreSlice(ty::ReStatic);
- let str_ty = ty::mk_str(bcx.tcx(), str_vstore);
+ let str_ty = ty::mk_str_slice(bcx.tcx(), ty::ReStatic, ast::MutImmutable);
let scratch = rvalue_scratch_datum(bcx, str_ty, "");
let len = C_uint(bcx.ccx(), s.get().len());
let c_str = PointerCast(bcx, C_cstr(bcx.ccx(), s, false), Type::i8p(bcx.ccx()));
self.visit("leave_" + bracket_name, extra);
}
- pub fn vstore_name_and_extra(&mut self,
- t: ty::t,
- vstore: ty::Vstore)
- -> (~str, Vec<ValueRef> ) {
- match vstore {
- ty::VstoreFixed(n) => {
- let extra = (vec!(self.c_uint(n))).append(self.c_size_and_align(t).as_slice());
- ("fixed".to_owned(), extra)
- }
- ty::VstoreSlice(..) => ("slice".to_owned(), Vec::new()),
- ty::VstoreUniq => ("uniq".to_owned(), Vec::new()),
- }
- }
-
pub fn leaf(&mut self, name: &str) {
self.visit(name, []);
}
ty::ty_float(ast::TyF128) => self.leaf("f128"),
// Should rename to str_*/vec_*.
- ty::ty_str(vst) => {
- let (name, extra) = self.vstore_name_and_extra(t, vst);
- self.visit("estr_".to_owned() + name, extra.as_slice())
+ 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())
}
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(..) => fail!("unexpected unsized vec"),
+ 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 {
ty::ty_uniq(typ) => {
match ty::get(typ).sty {
ty::ty_vec(ref mt, None) => {
- let (name, extra) = (~"uniq", Vec::new());
+ let extra = Vec::new();
let extra = extra.append(self.c_mt(mt).as_slice());
- self.visit(~"evec_" + name, extra.as_slice())
+ self.visit("evec_uniq".to_owned(), extra.as_slice())
}
+ ty::ty_str(None) => self.visit("estr_uniq".to_owned(), &[]),
_ => {
let extra = self.c_mt(&ty::mt {
ty: typ,
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(), &[]),
_ => {
let extra = self.c_mt(mt);
self.visit("rptr", extra.as_slice())
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_str(bcx.tcx(), ty::VstoreUniq);
+ let typ = ty::mk_uniq(bcx.tcx(), ty::mk_str(bcx.tcx(), None));
let lldestval = rvalue_scratch_datum(bcx,
typ,
"");
(base, len)
}
-pub fn get_base_and_byte_len_for_vec(bcx: &Block,
- llval: ValueRef,
- vec_ty: ty::t)
- -> (ValueRef, ValueRef) {
- /*!
- * Converts a vector into the slice pair. The vector should be
- * stored in `llval` which should be by ref. If you have a datum,
- * you would probably prefer to call
- * `Datum::get_base_and_byte_len()`.
- */
-
- let ccx = bcx.ccx();
- let vt = vec_types(bcx, ty::sequence_element_type(bcx.tcx(), vec_ty));
-
- let size = match ty::get(vec_ty).sty {
- ty::ty_vec(_, size) => size,
- _ => ccx.sess().bug("non-vector in get_base_and_byte_len_for_vec"),
- };
-
- match size {
- Some(n) => {
- let base = GEPi(bcx, llval, [0u, 0u]);
- let len = Mul(bcx, C_uint(ccx, n), vt.llunit_size);
- (base, len)
- }
- None => ccx.sess().bug("unsized vector in get_base_and_byte_len_for_vec")
- }
-}
-
pub fn get_base_and_len(bcx: &Block,
llval: ValueRef,
vec_ty: ty::t)
*/
let ccx = bcx.ccx();
- let vt = vec_types(bcx, ty::sequence_element_type(bcx.tcx(), vec_ty));
- let vstore = match ty::get(vec_ty).sty {
- ty::ty_str(vst) => vst,
- ty::ty_vec(_, Some(n)) => ty::VstoreFixed(n),
- ty::ty_rptr(r, mt) => match ty::get(mt.ty).sty {
- ty::ty_vec(_, None) => ty::VstoreSlice(r),
+ 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) => {
+ 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]));
+ (base, count)
+ }
_ => 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::VstoreUniq,
+ ty::ty_vec(_, None) | ty::ty_str(None) => {
+ 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);
+ (get_dataptr(bcx, body), UDiv(bcx, get_fill(bcx, body), vt.llunit_size))
+ }
_ => ccx.sess().bug("unexpected type (ty_uniq) in get_base_and_len"),
},
_ => ccx.sess().bug("unexpected type in get_base_and_len"),
- };
-
- match vstore {
- ty::VstoreFixed(n) => {
- let base = GEPi(bcx, llval, [0u, 0u]);
- (base, C_uint(ccx, n))
- }
- ty::VstoreSlice(..) => {
- 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]));
- (base, count)
- }
- ty::VstoreUniq => {
- assert!(type_is_immediate(bcx.ccx(), vec_ty));
- let body = Load(bcx, llval);
- (get_dataptr(bcx, body), UDiv(bcx, get_fill(bcx, body), vt.llunit_size))
- }
}
}
ty::ty_uint(t) => Type::uint_from_ty(cx, t),
ty::ty_float(t) => Type::float_from_ty(cx, t),
- ty::ty_str(ty::VstoreUniq) |
ty::ty_box(..) |
ty::ty_uniq(..) |
ty::ty_ptr(..) => Type::i8p(cx),
ty::ty_rptr(_, mt) => {
match ty::get(mt.ty).sty {
- ty::ty_vec(_, None) => Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false),
+ ty::ty_vec(_, None) | ty::ty_str(None) => {
+ Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false)
+ }
_ => Type::i8p(cx),
}
}
- ty::ty_str(ty::VstoreSlice(..)) => {
- Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false)
- }
-
ty::ty_bare_fn(..) => Type::i8p(cx),
ty::ty_closure(..) => Type::struct_(cx, [Type::i8p(cx), Type::i8p(cx)], false),
ty::ty_trait(..) => Type::opaque_trait(cx),
- ty::ty_str(ty::VstoreFixed(size)) => Type::array(&Type::i8(cx), size as u64),
+ 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)
}
}
ty::ty_self(_) | ty::ty_infer(..) | ty::ty_param(..) |
- ty::ty_err(..) | ty::ty_vec(_, None) => {
+ ty::ty_err(..) | ty::ty_vec(_, None) | ty::ty_str(None) => {
cx.sess().bug(format!("fictitious type {:?} in sizing_type_of()",
ty::get(t).sty))
}
ty::ty_int(t) => Type::int_from_ty(cx, t),
ty::ty_uint(t) => Type::uint_from_ty(cx, t),
ty::ty_float(t) => Type::float_from_ty(cx, t),
- ty::ty_str(ty::VstoreUniq) => {
- Type::vec(cx, &Type::i8(cx)).ptr_to()
- }
ty::ty_enum(did, ref substs) => {
// Only create the named struct, but don't fill it in. We
// fill it in *after* placing it into the type cache. This
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(),
_ => type_of(cx, typ).ptr_to(),
}
}
let u_ty = Type::uint_from_ty(cx, ast::TyU);
Type::struct_(cx, [p_ty, u_ty], false)
}
+ ty::ty_str(None) => {
+ // This means we get a nicer name in the output
+ cx.tn.find_type("str_slice").unwrap()
+ }
_ => type_of(cx, mt.ty).ptr_to(),
}
}
- ty::ty_str(ty::VstoreSlice(..)) => {
- // This means we get a nicer name in the output
- cx.tn.find_type("str_slice").unwrap()
- }
-
- ty::ty_str(ty::VstoreFixed(n)) => {
+ ty::ty_str(Some(n)) => {
Type::array(&Type::i8(cx), (n + 1u) as u64)
}
}
}
- ty::ty_vec(_, None) => cx.sess().bug("type_of with unszied ty_vec"),
+ 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_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"),
pub mutbl: ast::Mutability,
}
-#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash, Show)]
-/// Describes the "storage mode" of a str, whether it's fixed length or a slice.
-pub enum Vstore {
- /// [T, ..N]
- VstoreFixed(uint),
- /// ~[T]
- VstoreUniq,
- /// &[T] and &mut [T]
- VstoreSlice(Region)
-}
-
#[deriving(Clone, Eq, TotalEq, Hash, Encodable, Decodable, Show)]
pub enum TraitStore {
/// ~Trait
ty_enum(DefId, substs),
ty_box(t),
ty_uniq(t),
- ty_str(Vstore),
+ // ty_str and ty_vec have an optional length.
+ ty_str(Option<uint>),
ty_vec(mt, Option<uint>),
ty_ptr(mt),
ty_rptr(Region, mt),
terr_regions_no_overlap(Region, Region),
terr_regions_insufficiently_polymorphic(BoundRegion, Region),
terr_regions_overly_polymorphic(BoundRegion, Region),
- terr_vstores_differ(terr_vstore_kind, expected_found<Vstore>),
terr_trait_stores_differ(terr_vstore_kind, expected_found<TraitStore>),
terr_sorts(expected_found<t>),
terr_integer_as_char,
return f;
}
match &st {
- &ty_str(VstoreSlice(r)) => {
- flags |= rflags(r);
- }
&ty_nil | &ty_bool | &ty_char | &ty_int(_) | &ty_float(_) | &ty_uint(_) |
&ty_str(_) => {}
// You might think that we could just return ty_err for
#[inline]
pub fn mk_char() -> t { mk_prim_t(&primitives::TY_CHAR) }
-pub fn mk_str(cx: &ctxt, v: Vstore) -> t {
- mk_t(cx, ty_str(v))
+pub fn mk_str(cx: &ctxt, sz: Option<uint>) -> t {
+ mk_t(cx, ty_str(sz))
+}
+
+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)),
+ mutbl: m
+ })
}
pub fn mk_enum(cx: &ctxt, did: ast::DefId, substs: substs) -> t {
fn type_is_slice(ty:t) -> bool {
match get(ty).sty {
ty_rptr(_, mt) => match get(mt.ty).sty {
- ty_vec(_, None) => true,
+ ty_vec(_, None) | ty_str(None) => true,
_ => false,
},
_ => false
match get(ty).sty {
ty_struct(..) | ty_tup(_) | ty_enum(..) | ty_closure(_) | ty_trait(..) |
ty_vec(_, Some(_)) |
- ty_str(VstoreFixed(_)) | ty_str(VstoreSlice(_))
- => true,
+ ty_str(Some(_)) => true,
_ => type_is_slice(ty)
}
}
pub fn sequence_element_type(cx: &ctxt, ty: t) -> t {
match get(ty).sty {
- ty_str(_) => mk_mach_uint(ast::TyU8),
- ty_vec(mt, _) => mt.ty,
+ 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),
_ => cx.sess.bug("sequence_element_type called on non-sequence value"),
},
_ => cx.sess.bug("sequence_element_type called on non-sequence value"),
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) => false,
+ ty_vec(_, None) | ty_str(None) => false,
_ => true
},
_ => false
pub fn type_is_unique(ty: t) -> bool {
match get(ty).sty {
- ty_uniq(_) | ty_str(VstoreUniq) => true,
+ ty_uniq(_) => true,
_ => false
}
}
}
!needs_unwind_cleanup
}
- ty_uniq(_) |
- ty_str(VstoreUniq) => {
+ ty_uniq(_) => {
// Once we're inside a box, the annihilator will find
// it and destroy it.
if !encountered_box {
TC::None
}
- ty_str(VstoreUniq) => {
- TC::OwnsOwned
- }
-
ty_closure(ref c) => {
closure_contents(cx, *c)
}
}
ty_uniq(typ) => {
- tc_ty(cx, typ, cache).owned_pointer()
+ match get(typ).sty {
+ ty_str(None) => TC::OwnsOwned,
+ _ => tc_ty(cx, typ, cache).owned_pointer(),
+ }
}
ty_trait(~ty::TyTrait { store, bounds, .. }) => {
}
ty_rptr(r, ref mt) => {
- tc_ty(cx, mt.ty, cache).reference(
- borrowed_contents(r, mt.mutbl))
+ match get(mt.ty).sty {
+ ty_str(None) => borrowed_contents(r, ast::MutImmutable),
+ _ => tc_ty(cx, mt.ty, cache).reference(borrowed_contents(r, mt.mutbl)),
+ }
}
ty_vec(mt, _) => {
tc_mt(cx, mt, cache)
}
- ty_str(VstoreSlice(r)) => {
- borrowed_contents(r, ast::MutImmutable)
- }
-
- ty_str(VstoreFixed(_)) => {
+ ty_str(_) => {
TC::None
}
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) => None,
+ ty_vec(_, None) | ty_str(None) => None,
_ => Some(mt {
ty: typ,
mutbl: ast::MutImmutable,
},
ty_rptr(_, mt) => match get(mt.ty).sty {
// Don't deref &[], might need to generalise this to all DST.
- ty_vec(_, None) => None,
+ ty_vec(_, None) | ty_str(None) => None,
_ => Some(mt),
},
ty_ptr(mt) if explicit => Some(mt),
// Returns the type of t[i]
pub fn index(t: t) -> Option<mt> {
match get(t).sty {
- ty_vec(mt, _) => Some(mt),
+ ty_vec(mt, Some(_)) => Some(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}),
_ => None,
},
- ty_str(_) => Some(mt {ty: mk_u8(), mutbl: ast::MutImmutable}),
+ ty_str(Some(_)) => Some(mt {ty: mk_u8(), mutbl: ast::MutImmutable}),
_ => None
}
}
ty: t) -> Region {
match get(ty).sty {
ty_rptr(r, _) => r,
- ty_str(VstoreSlice(r)) => r,
ref s => {
tcx.sess.span_bug(
span,
None => unadjusted_ty
};
- fn borrow_vec(cx: &ctxt, span: Span,
- r: Region, m: ast::Mutability,
+ fn borrow_vec(cx: &ctxt,
+ span: Span,
+ r: Region,
+ m: ast::Mutability,
ty: ty::t) -> ty::t {
match get(ty).sty {
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}),
- ref s => {
+ ty::ty_str(None) => ty::mk_str_slice(cx, r, m),
+ _ => {
cx.sess.span_bug(
span,
- format!("borrow-vec associated with bad sty: {:?}",
- s));
+ format!("borrow-vec associated with bad sty: {:?}", get(ty).sty));
}
},
- ty_vec(mt, Some(_)) => {
- ty::mk_slice(cx, r, ty::mt {ty: mt.ty, mutbl: m})
- }
-
- ty_str(_) => {
- ty::mk_str(cx, VstoreSlice(r))
- }
+ 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(
span,
- format!("borrow-vec associated with bad sty: {:?}",
- s));
+ format!("borrow-vec associated with bad sty: {:?}", s));
}
}
}
* to present additional details, particularly when
* it comes to lifetime-related errors. */
- fn terr_vstore_kind_to_str(k: terr_vstore_kind) -> ~str {
- match k {
- terr_vec => "[]".to_owned(),
- terr_str => "str".to_owned(),
- terr_fn => "fn".to_owned(),
- terr_trait => "trait".to_owned()
- }
- }
-
fn tstore_to_closure(s: &TraitStore) -> ~str {
match s {
&UniqTraitStore => "proc".to_owned(),
but found bound lifetime parameter {}",
bound_region_ptr_to_str(cx, br))
}
- terr_vstores_differ(k, ref values) => {
- format!("{} storage differs: expected `{}` but found `{}`",
- terr_vstore_kind_to_str(k),
- (*values).expected.repr(cx),
- (*values).found.repr(cx))
- }
terr_trait_stores_differ(_, ref values) => {
format!("trait storage differs: expected `{}` but found `{}`",
trait_store_to_str(cx, (*values).expected),
return t_norm;
}
- fn fold_vstore(&mut self, vstore: Vstore) -> Vstore {
- match vstore {
- VstoreFixed(..) | VstoreUniq => vstore,
- VstoreSlice(_) => VstoreSlice(ReStatic)
- }
- }
-
fn fold_region(&mut self, _: ty::Region) -> ty::Region {
ty::ReStatic
}
byte!(6);
hash!(f);
}
- ty_str(v) => {
+ ty_str(Some(_)) => {
byte!(7);
- hash!(v);
+ 1u8.hash(&mut state);
+ }
+ ty_str(None) => {
+ byte!(7);
+ 0u8.hash(&mut state);
}
ty_enum(d, _) => {
byte!(8);
r
}
- fn fold_vstore(&mut self, vstore: ty::Vstore) -> ty::Vstore {
- super_fold_vstore(self, vstore)
- }
-
fn fold_trait_store(&mut self, s: ty::TraitStore) -> ty::TraitStore {
super_fold_trait_store(self, s)
}
ty::ty_struct(did,
this.fold_substs(substs))
}
- ty::ty_str(vst) => {
- ty::ty_str(this.fold_vstore(vst))
+ ty::ty_str(sz) => {
+ ty::ty_str(sz)
}
ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_char |
ty::ty_int(_) | ty::ty_uint(_) | ty::ty_float(_) |
}
}
-pub fn super_fold_vstore<T:TypeFolder>(this: &mut T,
- vstore: ty::Vstore)
- -> ty::Vstore {
- match vstore {
- ty::VstoreFixed(i) => ty::VstoreFixed(i),
- ty::VstoreUniq => ty::VstoreUniq,
- ty::VstoreSlice(r) => ty::VstoreSlice(this.fold_region(r)),
- }
-}
-
pub fn super_fold_trait_store<T:TypeFolder>(this: &mut T,
trait_store: ty::TraitStore)
-> ty::TraitStore {
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_str(tcx, ty::VstoreUniq))
+ Some(ty::mk_uniq(tcx, ty::mk_str(tcx, None)))
}
}
}
enum PointerTy {
Box,
- VStore(ty::Vstore)
- }
- impl PointerTy {
- fn expect_vstore(&self, tcx: &ty::ctxt, span: Span, ty: &str) -> ty::Vstore {
- match *self {
- Box => {
- tcx.sess.span_err(span, format!("managed {} are not supported", ty));
- // everything can be ~, so this is a worth substitute
- ty::VstoreUniq
- }
- VStore(vst) => vst
- }
- }
+ RPtr(ty::Region),
+ Uniq
}
fn ast_ty_to_mt<AC:AstConv, RS:RegionScope>(this: &AC,
match tcx.def_map.borrow().find(&id) {
Some(&ast::DefPrimTy(ast::TyStr)) => {
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
- let vst = ptr_ty.expect_vstore(tcx, path.span, "strings");
- match vst {
- ty::VstoreUniq => {
- return ty::mk_str(tcx, ty::VstoreUniq);
+ match ptr_ty {
+ Uniq => {
+ return ty::mk_uniq(tcx, ty::mk_str(tcx, None));
}
- ty::VstoreSlice(r) => {
- return ty::mk_str(tcx, ty::VstoreSlice(r));
+ RPtr(r) => {
+ return ty::mk_str_slice(tcx, r, ast::MutImmutable);
}
- _ => {}
+ _ => tcx.sess.span_err(path.span,
+ format!("managed strings are not supported")),
}
}
Some(&ast::DefTrait(trait_def_id)) => {
let result = ast_path_to_trait_ref(
this, rscope, trait_def_id, None, path);
let trait_store = match ptr_ty {
- VStore(ty::VstoreUniq) => ty::UniqTraitStore,
- VStore(ty::VstoreSlice(r)) => {
+ Uniq => ty::UniqTraitStore,
+ RPtr(r) => {
ty::RegionTraitStore(r, a_seq_ty.mutbl)
}
_ => {
}
ast::TyUniq(ty) => {
let mt = ast::MutTy { ty: ty, mutbl: ast::MutImmutable };
- mk_pointer(this, rscope, &mt, VStore(ty::VstoreUniq),
+ mk_pointer(this, rscope, &mt, Uniq,
|ty| ty::mk_uniq(tcx, ty))
}
ast::TyVec(ty) => {
ast::TyRptr(ref region, ref mt) => {
let r = opt_ast_region_to_region(this, rscope, ast_ty.span, region);
debug!("ty_rptr r={}", r.repr(this.tcx()));
- mk_pointer(this, rscope, mt, VStore(ty::VstoreSlice(r)),
+ mk_pointer(this, rscope, mt, RPtr(r),
|ty| ty::mk_rptr(tcx, r, ty::mt {ty: ty, mutbl: mt.mutbl}))
}
ast::TyTup(ref fields) => {
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)),
_ => (1, ty::AutoPtr(region, self_mt.mutbl)),
};
(ty::mk_rptr(tcx, region, self_mt),
})
}
+
+ fn auto_slice_str(&self, autoderefs: uint) -> Option<MethodCallee> {
+ let tcx = self.tcx();
+ debug!("auto_slice_str");
+
+ let entry = self.search_for_some_kind_of_autorefd_method(
+ AutoBorrowVec, autoderefs, [MutImmutable],
+ |_m,r| ty::mk_str_slice(tcx, r, MutImmutable));
+
+ if entry.is_some() {
+ return entry;
+ }
+
+ self.search_for_some_kind_of_autorefd_method(
+ AutoBorrowVecRef, autoderefs, [MutImmutable],
+ |m,r| {
+ let slice_ty = ty::mk_str_slice(tcx, r, m);
+ ty::mk_rptr(tcx, r, ty::mt {ty:slice_ty, mutbl:m})
+ })
+ }
+
fn search_for_autosliced_method(&self,
self_ty: ty::t,
autoderefs: uint)
},
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),
_ => None
},
ty_vec(mt, Some(_)) => self.auto_slice_vec(mt, autoderefs),
-
- ty_str(VstoreUniq) |
- ty_str(VstoreFixed(_)) => {
- let entry = self.search_for_some_kind_of_autorefd_method(
- AutoBorrowVec, autoderefs, [MutImmutable],
- |_m,r| ty::mk_str(tcx, VstoreSlice(r)));
-
- if entry.is_some() { return entry; }
-
- self.search_for_some_kind_of_autorefd_method(
- AutoBorrowVecRef, autoderefs, [MutImmutable],
- |m,r| {
- let slice_ty = ty::mk_str(tcx, VstoreSlice(r));
- ty::mk_rptr(tcx, r, ty::mt {ty:slice_ty, mutbl:m})
- })
- }
+ 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.
match ty::get(rcvr_ty).sty {
ty::ty_rptr(_, mt) => {
match ty::get(mt.ty).sty {
- ty::ty_vec(_, None) => false,
+ ty::ty_vec(_, None) | ty::ty_str(None) => false,
_ => mutability_matches(mt.mutbl, m) &&
rcvr_matches_ty(self.fcx, mt.ty, candidate),
}
match ty::get(rcvr_ty).sty {
ty::ty_uniq(typ) => {
match ty::get(typ).sty {
- ty::ty_vec(_, None) => false,
+ ty::ty_vec(_, None) | ty::ty_str(None) => false,
_ => rcvr_matches_ty(self.fcx, typ, candidate),
}
}
let tcx = fcx.ccx.tcx;
match lit.node {
- ast::LitStr(..) => ty::mk_str(tcx, ty::VstoreSlice(ty::ReStatic)),
+ ast::LitStr(..) => ty::mk_str_slice(tcx, ty::ReStatic, ast::MutImmutable),
ast::LitBinary(..) => {
ty::mk_slice(tcx, ty::ReStatic, ty::mt{ ty: ty::mk_u8(), mutbl: ast::MutImmutable })
}
ast::ExprVstore(ev, vst) => {
let typ = match ev.node {
ast::ExprLit(lit) if ast_util::lit_is_str(lit) => {
- let v = ast_expr_vstore_to_vstore(fcx, ev, vst);
- ty::mk_str(tcx, v)
+ ast_expr_vstore_to_ty(fcx, ev, vst, || ty::mt{ ty: ty::mk_str(tcx, None),
+ mutbl: ast::MutImmutable })
}
ast::ExprVec(ref args) => {
let mutability = match vst {
ast::ExprVstoreMutSlice => ast::MutMutable,
_ => ast::MutImmutable,
};
- let v = ast_expr_vstore_to_vstore(fcx, ev, vst);
let mut any_error = false;
let mut any_bot = false;
let t: ty::t = fcx.infcx().next_ty_var();
} else if any_bot {
ty::mk_bot()
} else {
- match v {
- ty::VstoreFixed(sz) => ty::mk_vec(tcx,
- ty::mt {ty: t, mutbl: mutability},
- Some(sz)),
- ty::VstoreUniq => ty::mk_uniq(tcx,
- ty::mk_vec(tcx,
- ty::mt {ty: t, mutbl: mutability},
- None)), // Sadly, we know the length
- // - Some(args.len()) - but
- // must throw it away or cause
- // confusion further down the
- // pipeline. Hopefully we can
- // remedy this later.
- // See below (x3) too.
- ty::VstoreSlice(r) => ty::mk_slice(tcx, r,
- ty::mt {ty: t, mutbl: mutability}),
- }
+ ast_expr_vstore_to_ty(fcx, ev, vst, ||
+ ty::mt{ ty: ty::mk_vec(tcx,
+ ty::mt {ty: t, mutbl: mutability},
+ None),
+ mutbl: mutability })
}
}
ast::ExprRepeat(element, count_expr) => {
ast::ExprVstoreMutSlice => ast::MutMutable,
_ => ast::MutImmutable,
};
- let tt = ast_expr_vstore_to_vstore(fcx, ev, vst);
let t = fcx.infcx().next_ty_var();
check_expr_has_type(fcx, element, t);
let arg_t = fcx.expr_ty(element);
} else if ty::type_is_bot(arg_t) {
ty::mk_bot()
} else {
- match tt {
- ty::VstoreFixed(sz) => ty::mk_vec(tcx,
- ty::mt {ty: t, mutbl: mutability},
- Some(sz)),
- ty::VstoreUniq => ty::mk_uniq(tcx,
- ty::mk_vec(tcx,
- ty::mt {ty: t, mutbl: mutability},
- None)),
- ty::VstoreSlice(r) => ty::mk_slice(tcx, r,
- ty::mt {ty: t, mutbl: mutability}),
- }
+ ast_expr_vstore_to_ty(fcx, ev, vst, ||
+ ty::mt{ ty: ty::mk_vec(tcx,
+ ty::mt {ty: t, mutbl: mutability},
+ None),
+ mutbl: mutability})
}
}
_ =>
return ty::type_is_c_like_enum(fcx.ccx.tcx, typ_s);
}
-pub fn ast_expr_vstore_to_vstore(fcx: &FnCtxt,
- e: &ast::Expr,
- v: ast::ExprVstore)
- -> ty::Vstore {
+pub fn ast_expr_vstore_to_ty(fcx: &FnCtxt,
+ e: &ast::Expr,
+ v: ast::ExprVstore,
+ mk_inner: || -> ty::mt)
+ -> ty::t {
match v {
- ast::ExprVstoreUniq => ty::VstoreUniq,
+ ast::ExprVstoreUniq => ty::mk_uniq(fcx.ccx.tcx, mk_inner().ty),
ast::ExprVstoreSlice | ast::ExprVstoreMutSlice => {
match e.node {
ast::ExprLit(..) => {
// string literals and *empty slices* live in static memory
- ty::VstoreSlice(ty::ReStatic)
+ ty::mk_rptr(fcx.ccx.tcx, ty::ReStatic, mk_inner())
}
ast::ExprVec(ref elements) if elements.len() == 0 => {
// string literals and *empty slices* live in static memory
- ty::VstoreSlice(ty::ReStatic)
+ ty::mk_rptr(fcx.ccx.tcx, ty::ReStatic, mk_inner())
}
ast::ExprRepeat(..) |
ast::ExprVec(..) => {
// vector literals are temporaries on the stack
match fcx.tcx().region_maps.temporary_scope(e.id) {
- Some(scope) => {
- ty::VstoreSlice(ty::ReScope(scope))
- }
- None => {
- // this slice occurs in a static somewhere
- ty::VstoreSlice(ty::ReStatic)
- }
+ Some(scope) => ty::mk_rptr(fcx.ccx.tcx, ty::ReScope(scope), mk_inner()),
+ None => ty::mk_rptr(fcx.ccx.tcx, ty::ReStatic, mk_inner()),
}
}
_ => {
let r_index_expr = ty::ReScope(index_expr.id);
match ty::get(indexed_ty).sty {
- ty::ty_str(ty::VstoreSlice(r_ptr)) => {
- rcx.fcx.mk_subr(true, infer::IndexSlice(index_expr.span),
- r_index_expr, r_ptr);
- }
ty::ty_rptr(r_ptr, mt) => match ty::get(mt.ty).sty {
- ty::ty_vec(_, None) => {
+ ty::ty_vec(_, None) | ty::ty_str(None)=> {
rcx.fcx.mk_subr(true, infer::IndexSlice(index_expr.span),
r_index_expr, r_ptr);
}
use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowObj, AutoDerefRef};
-use middle::ty::{VstoreSlice, VstoreUniq};
use middle::ty::{mt};
use middle::ty;
use middle::typeck::infer::{CoerceResult, resolve_type, Coercion};
});
}
ty::ty_vec(_, _) => {},
+ ty::ty_str(None) => {
+ return self.unpack_actual_value(a, |sty_a| {
+ self.coerce_borrowed_string(a, sty_a, b)
+ });
+ }
_ => {
return self.unpack_actual_value(a, |sty_a| {
self.coerce_borrowed_pointer(a, sty_a, b, mt_b)
};
}
- ty::ty_str(VstoreSlice(..)) => {
- return self.unpack_actual_value(a, |sty_a| {
- self.coerce_borrowed_string(a, sty_a, b)
- });
- }
-
ty::ty_closure(~ty::ClosureTy {store: ty::RegionTraitStore(..), ..}) => {
return self.unpack_actual_value(a, |sty_a| {
self.coerce_borrowed_fn(a, sty_a, b)
b.inf_str(self.get_ref().infcx));
match *sty_a {
- ty::ty_str(VstoreUniq) => {}
+ ty::ty_uniq(t) => match ty::get(t).sty {
+ ty::ty_str(None) => {}
+ _ => return self.subtype(a, b),
+ },
_ => {
return self.subtype(a, b);
}
let coercion = Coercion(self.get_ref().trace.clone());
let r_a = self.get_ref().infcx.next_region_var(coercion);
- let a_borrowed = ty::mk_str(self.get_ref().infcx.tcx, VstoreSlice(r_a));
+ let a_borrowed = ty::mk_str_slice(self.get_ref().infcx.tcx, r_a, ast::MutImmutable);
if_ok!(self.subtype(a_borrowed, b));
Ok(Some(AutoDerefRef(AutoDerefRef {
autoderefs: 0,
-> cres<ty::Region>;
fn regions(&self, a: ty::Region, b: ty::Region) -> cres<ty::Region>;
- fn vstores(&self,
- vk: ty::terr_vstore_kind,
- a: ty::Vstore,
- b: ty::Vstore)
- -> cres<ty::Vstore> {
- debug!("{}.vstores(a={:?}, b={:?})", self.tag(), a, b);
-
- match (a, b) {
- (ty::VstoreSlice(a_r), ty::VstoreSlice(b_r)) => {
- self.contraregions(a_r, b_r).and_then(|r| {
- Ok(ty::VstoreSlice(r))
- })
- }
-
- _ if a == b => {
- Ok(a)
- }
-
- _ => {
- Err(ty::terr_vstores_differ(vk, expected_found(self, a, b)))
- }
- }
- }
-
fn trait_stores(&self,
vk: ty::terr_vstore_kind,
a: ty::TraitStore,
}
pub fn super_tys<C:Combine>(this: &C, a: ty::t, b: ty::t) -> cres<ty::t> {
+
+ // This is a horible hack - historically, [T] was not treated as a type,
+ // so, for example, &T and &[U] should not unify. In fact the only thing
+ // &[U] should unify with is &[T]. We preserve that behaviour with this
+ // check.
+ fn check_ptr_to_vec<C:Combine>(this: &C,
+ a: ty::t,
+ b: ty::t,
+ a_inner: ty::t,
+ b_inner: 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_vec(_, None), _) | (_, &ty::ty_vec(_, None)) |
+ (&ty::ty_str(None), _) | (_, &ty::ty_str(None))
+ => Err(ty::terr_sorts(expected_found(this, a, b))),
+ _ => Ok(result),
+ }
+ }
+
let tcx = this.infcx().tcx;
let a_sty = &ty::get(a).sty;
let b_sty = &ty::get(b).sty;
(&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => {
let typ = if_ok!(this.tys(a_inner, b_inner));
-
- match (&ty::get(a_inner).sty, &ty::get(b_inner).sty) {
- (&ty::ty_vec(_, None), &ty::ty_vec(_, None)) => Ok(ty::mk_uniq(tcx, typ)),
- (&ty::ty_vec(_, None), _) |
- (_, &ty::ty_vec(_, None)) => Err(ty::terr_sorts(expected_found(this, a, b))),
- _ => Ok(ty::mk_uniq(tcx, typ)),
- }
+ check_ptr_to_vec(this, a, b, a_inner, b_inner, ty::mk_uniq(tcx, typ))
}
(&ty::ty_ptr(ref a_mt), &ty::ty_ptr(ref b_mt)) => {
let mt = if_ok!(this.mts(a_mt, b_mt));
- match (&ty::get(a_mt.ty).sty, &ty::get(b_mt.ty).sty) {
- (&ty::ty_vec(_, None), &ty::ty_vec(_, None)) => Ok(ty::mk_ptr(tcx, mt)),
- (&ty::ty_vec(_, None), _) |
- (_, &ty::ty_vec(_, None)) => Err(ty::terr_sorts(expected_found(this, a, b))),
- _ => Ok(ty::mk_ptr(tcx, mt)),
- }
+ check_ptr_to_vec(this, a, b, a_mt.ty, b_mt.ty, ty::mk_ptr(tcx, mt))
}
(&ty::ty_rptr(a_r, ref a_mt), &ty::ty_rptr(b_r, ref b_mt)) => {
let r = if_ok!(this.contraregions(a_r, b_r));
let mt = if_ok!(this.mts(a_mt, b_mt));
-
- // This is a horible hack - historically, [T] was not treated as a type,
- // so, for example, &T and &[U] should not unify. In fact the only thing
- // &[U] should unify with is &[T]. We preserve that behaviour with this
- // check. See also ty_uniq, ty_ptr.
- match (&ty::get(a_mt.ty).sty, &ty::get(b_mt.ty).sty) {
- (&ty::ty_vec(_, None), &ty::ty_vec(_, None)) => Ok(ty::mk_rptr(tcx, r, mt)),
- (&ty::ty_vec(_, None), _) |
- (_, &ty::ty_vec(_, None)) => Err(ty::terr_sorts(expected_found(this, a, b))),
- _ => Ok(ty::mk_rptr(tcx, r, mt)),
- }
+ check_ptr_to_vec(this, a, b, a_mt.ty, b_mt.ty, ty::mk_rptr(tcx, r, mt))
}
(&ty::ty_vec(ref a_mt, sz_a), &ty::ty_vec(ref b_mt, sz_b)) => {
})
}
- (&ty::ty_str(vs_a), &ty::ty_str(vs_b)) => {
- let vs = if_ok!(this.vstores(ty::terr_str, vs_a, vs_b));
- Ok(ty::mk_str(tcx,vs))
+ (&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_tup(ref as_), &ty::ty_tup(ref bs)) => {
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_float(_) | ty::ty_str(_) => {
/* leaf type -- noop */
}
self.add_constraints_from_mt(mt, variance);
}
- ty::ty_str(vstore) => {
- self.add_constraints_from_vstore(vstore, variance);
- }
-
ty::ty_vec(ref mt, _) => {
self.add_constraints_from_mt(mt, variance);
}
}
}
- /// Adds constraints appropriate for a vector with Vstore `vstore`
- /// appearing in a context with ambient variance `variance`
- fn add_constraints_from_vstore(&mut self,
- vstore: ty::Vstore,
- variance: VarianceTermPtr<'a>) {
- match vstore {
- ty::VstoreSlice(r) => {
- let contra = self.contravariant(variance);
- self.add_constraints_from_region(r, contra);
- }
-
- ty::VstoreFixed(_) | ty::VstoreUniq => {}
- }
- }
/// Adds constraints appropriate for a nominal type (enum, struct,
/// object, etc) appearing in a context with ambient variance `variance`
let bound_str = bounds.repr(cx);
format!("{}{}{}{}", trait_store_to_str(cx, store), ty, bound_sep, bound_str)
}
- ty_str(vs) => {
- match vs {
- ty::VstoreFixed(n) => format!("str/{}", n),
- ty::VstoreUniq => "~str".to_owned(),
- ty::VstoreSlice(r) => format!("{}str", region_ptr_to_str(cx, r))
+ ty_str(sz) => {
+ match sz {
+ Some(n) => format!("str/{}", n),
+ None => "str".to_owned(),
}
}
ty_vec(ref mt, sz) => {
match sz {
- Some(n) => {
- format!("[{}, .. {}]", mt_to_str(cx, mt), n)
- }
- None => {
- format!("[{}]", ty_to_str(cx, mt.ty))
- }
+ Some(n) => format!("[{}, .. {}]", mt_to_str(cx, mt), n),
+ None => format!("[{}]", ty_to_str(cx, mt.ty)),
}
}
}
}
}
-impl Repr for ty::Vstore {
- fn repr(&self, tcx: &ctxt) -> ~str {
- match *self {
- ty::VstoreFixed(n) => format!("{}", n),
- ty::VstoreUniq => "~".to_owned(),
- ty::VstoreSlice(r) => region_ptr_to_str(tcx, r)
- }
- }
-}
-
impl Repr for ty::BuiltinBound {
fn repr(&self, _tcx: &ctxt) -> ~str {
format!("{:?}", *self)
}
fn has_slice(x: &str) {
- wants_uniq(x); //~ ERROR str storage differs: expected `~` but found `&`
+ wants_uniq(x); //~ ERROR mismatched types: expected `~str` but found `&str` (expected ~-ptr but f
wants_slice(x);
}
fn main() {
format!("{0, select, other{}}", 2);
- //~^ ERROR: expected &str but found integral
+ //~^ ERROR: mismatched types: expected `&&str` but found `&<generic integer #0>` (expected &-ptr
}
projects / rust.git / commitdiff