use collections::HashSet;
use libc::{c_uint, c_ulonglong, c_longlong};
use std::ptr;
-use std::slice;
use std::strbuf::StrBuf;
use std::sync::atomics;
use syntax::codemap::{Span, Pos};
return create_DIArray(DIB(cx), []);
}
- let mut signature = slice::with_capacity(fn_decl.inputs.len() + 1);
+ let mut signature = Vec::with_capacity(fn_decl.inputs.len() + 1);
// Return type -- llvm::DIBuilder wants this at index 0
match fn_decl.output.node {
signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP));
}
- return create_DIArray(DIB(cx), signature);
+ return create_DIArray(DIB(cx), signature.as_slice());
}
fn get_template_parameters(cx: &CrateContext,
// prepend "./" if necessary
let dotdot = bytes!("..");
let prefix = &[dotdot[0], ::std::path::SEP_BYTE];
- let mut path_bytes = p.as_vec().to_owned();
+ let mut path_bytes = Vec::from_slice(p.as_vec());
if path_bytes.slice_to(2) != prefix &&
path_bytes.slice_to(2) != dotdot {
path_bytes.insert(1, prefix[1]);
}
- path_bytes.to_c_str()
+ path_bytes.as_slice().to_c_str()
}
_ => fallback_path(cx)
}
debug!("basic_type_metadata: {:?}", ty::get(t));
let (name, encoding) = match ty::get(t).sty {
- ty::ty_nil => (~"()", DW_ATE_unsigned),
- ty::ty_bot => (~"!", DW_ATE_unsigned),
- ty::ty_bool => (~"bool", DW_ATE_boolean),
- ty::ty_char => (~"char", DW_ATE_unsigned_char),
+ ty::ty_nil => ("()".to_owned(), DW_ATE_unsigned),
+ ty::ty_bot => ("!".to_owned(), DW_ATE_unsigned),
+ ty::ty_bool => ("bool".to_owned(), DW_ATE_boolean),
+ ty::ty_char => ("char".to_owned(), DW_ATE_unsigned_char),
ty::ty_int(int_ty) => match int_ty {
- ast::TyI => (~"int", DW_ATE_signed),
- ast::TyI8 => (~"i8", DW_ATE_signed),
- ast::TyI16 => (~"i16", DW_ATE_signed),
- ast::TyI32 => (~"i32", DW_ATE_signed),
- ast::TyI64 => (~"i64", DW_ATE_signed)
+ ast::TyI => ("int".to_owned(), DW_ATE_signed),
+ ast::TyI8 => ("i8".to_owned(), DW_ATE_signed),
+ ast::TyI16 => ("i16".to_owned(), DW_ATE_signed),
+ ast::TyI32 => ("i32".to_owned(), DW_ATE_signed),
+ ast::TyI64 => ("i64".to_owned(), DW_ATE_signed)
},
ty::ty_uint(uint_ty) => match uint_ty {
- ast::TyU => (~"uint", DW_ATE_unsigned),
- ast::TyU8 => (~"u8", DW_ATE_unsigned),
- ast::TyU16 => (~"u16", DW_ATE_unsigned),
- ast::TyU32 => (~"u32", DW_ATE_unsigned),
- ast::TyU64 => (~"u64", DW_ATE_unsigned)
+ ast::TyU => ("uint".to_owned(), DW_ATE_unsigned),
+ ast::TyU8 => ("u8".to_owned(), DW_ATE_unsigned),
+ ast::TyU16 => ("u16".to_owned(), DW_ATE_unsigned),
+ ast::TyU32 => ("u32".to_owned(), DW_ATE_unsigned),
+ ast::TyU64 => ("u64".to_owned(), DW_ATE_unsigned)
},
ty::ty_float(float_ty) => match float_ty {
- ast::TyF32 => (~"f32", DW_ATE_float),
- ast::TyF64 => (~"f64", DW_ATE_float)
+ ast::TyF32 => ("f32".to_owned(), DW_ATE_float),
+ ast::TyF64 => ("f64".to_owned(), DW_ATE_float)
},
_ => cx.sess().bug("debuginfo::basic_type_metadata - t is invalid type")
};
-> Vec<MemberDescription> {
self.fields.iter().map(|field| {
let name = if field.ident.name == special_idents::unnamed_field.name {
- ~""
+ "".to_owned()
} else {
token::get_ident(field.ident).get().to_str()
};
-> Vec<MemberDescription> {
self.component_types.iter().map(|&component_type| {
MemberDescription {
- name: ~"",
+ name: "".to_owned(),
llvm_type: type_of::type_of(cx, component_type),
type_metadata: type_metadata(cx, component_type, self.span),
offset: ComputedMemberOffset,
self.file_metadata,
codemap::DUMMY_SP);
MemberDescription {
- name: ~"",
+ name: "".to_owned(),
llvm_type: variant_llvm_type,
type_metadata: variant_type_metadata,
offset: FixedMemberOffset { bytes: 0 },
Some(ref names) => {
names.iter().map(|ident| token::get_ident(*ident).get().to_str()).collect()
}
- None => variant_info.args.iter().map(|_| ~"").collect()
+ None => variant_info.args.iter().map(|_| "".to_owned()).collect()
};
// If this is not a univariant enum, there is also the (unnamed) discriminant field
if discriminant_type_metadata.is_some() {
- arg_names.insert(0, ~"");
+ arg_names.insert(0, "".to_owned());
}
// Build an array of (field name, field type) pairs to be captured in the factory closure.
-> DICompositeType {
let box_type_name = match content_type_name {
Some(content_type_name) => format!("Boxed<{}>", content_type_name),
- None => ~"BoxedType"
+ None => "BoxedType".to_owned()
};
let box_llvm_type = Type::at_box(cx, content_llvm_type);
let member_descriptions = [
MemberDescription {
- name: ~"refcnt",
+ name: "refcnt".to_owned(),
llvm_type: *member_llvm_types.get(0),
type_metadata: type_metadata(cx, int_type, codemap::DUMMY_SP),
offset: ComputedMemberOffset,
},
MemberDescription {
- name: ~"drop_glue",
+ name: "drop_glue".to_owned(),
llvm_type: *member_llvm_types.get(1),
type_metadata: nil_pointer_type_metadata,
offset: ComputedMemberOffset,
},
MemberDescription {
- name: ~"prev",
+ name: "prev".to_owned(),
llvm_type: *member_llvm_types.get(2),
type_metadata: nil_pointer_type_metadata,
offset: ComputedMemberOffset,
},
MemberDescription {
- name: ~"next",
+ name: "next".to_owned(),
llvm_type: *member_llvm_types.get(3),
type_metadata: nil_pointer_type_metadata,
offset: ComputedMemberOffset,
},
MemberDescription {
- name: ~"val",
+ name: "val".to_owned(),
llvm_type: *member_llvm_types.get(4),
type_metadata: content_type_metadata,
offset: ComputedMemberOffset,
let member_descriptions = [
MemberDescription {
- name: ~"fill",
+ name: "fill".to_owned(),
llvm_type: *member_llvm_types.get(0),
type_metadata: int_type_metadata,
offset: ComputedMemberOffset,
},
MemberDescription {
- name: ~"alloc",
+ name: "alloc".to_owned(),
llvm_type: *member_llvm_types.get(1),
type_metadata: int_type_metadata,
offset: ComputedMemberOffset,
},
MemberDescription {
- name: ~"elements",
+ name: "elements".to_owned(),
llvm_type: *member_llvm_types.get(2),
type_metadata: array_type_metadata,
offset: ComputedMemberOffset,
let member_descriptions = [
MemberDescription {
- name: ~"data_ptr",
+ name: "data_ptr".to_owned(),
llvm_type: *member_llvm_types.get(0),
type_metadata: type_metadata(cx, data_ptr_type, span),
offset: ComputedMemberOffset,
},
MemberDescription {
- name: ~"length",
+ name: "length".to_owned(),
llvm_type: *member_llvm_types.get(1),
type_metadata: type_metadata(cx, ty::mk_uint(), span),
offset: ComputedMemberOffset,