.arg(ADB_TEST_DIR));
let target_dir = format!("{}/{}", ADB_TEST_DIR, target);
- build.run(Command::new("adb").args(&["shell", "mkdir", &target_dir[..]]));
+ build.run(Command::new("adb").args(&["shell", "mkdir", &target_dir]));
for f in t!(build.sysroot_libdir(compiler, target).read_dir()) {
let f = t!(f);
let toknum = &s[content_end + 3 .. toknum_end];
let not_found = format!("didn't find token {:?} in the map", toknum);
- let proto_tok = tokens.get(toknum).expect(¬_found[..]);
+ let proto_tok = tokens.get(toknum).expect(¬_found);
let nm = Symbol::intern(content);
let mut token_file = File::open(&Path::new(&args.next().unwrap())).unwrap();
let mut token_list = String::new();
token_file.read_to_string(&mut token_list).unwrap();
- let token_map = parse_token_list(&token_list[..]);
+ let token_map = parse_token_list(&token_list);
let stdin = std::io::stdin();
let lock = stdin.lock();
let lines = lock.lines();
let antlr_tokens = lines.map(|l| parse_antlr_token(l.unwrap().trim(),
&token_map,
- &surrogate_pairs_pos[..],
+ &surrogate_pairs_pos,
has_bom));
for antlr_tok in antlr_tokens {
thread::spawn(move || {
check_links(&n);
let a: &[_] = &[&1, &2, &3];
- assert_eq!(a, &n.iter().collect::<Vec<_>>()[..]);
+ assert_eq!(a, &*n.iter().collect::<Vec<_>>());
})
.join()
.ok()
pub fn to_dot_string(&self) -> String {
match self {
&LabelStr(ref s) => format!("\"{}\"", s.escape_default()),
- &EscStr(ref s) => format!("\"{}\"", LabelText::escape_str(&s[..])),
+ &EscStr(ref s) => format!("\"{}\"", LabelText::escape_str(&s)),
&HtmlStr(ref s) => format!("<{}>", s),
}
}
let mut prefix = self.pre_escaped_content().into_owned();
let suffix = suffix.pre_escaped_content();
prefix.push_str(r"\n\n");
- prefix.push_str(&suffix[..]);
+ prefix.push_str(&suffix);
EscStr(prefix.into_cow())
}
}
type Node = Node;
type Edge = &'a Edge;
fn graph_id(&'a self) -> Id<'a> {
- Id::new(&self.name[..]).unwrap()
+ Id::new(self.name).unwrap()
}
fn node_id(&'a self, n: &Node) -> Id<'a> {
id_name(n)
impl Encodable for Fingerprint {
#[inline]
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- for &byte in &self.0[..] {
+ for &byte in &self.0 {
s.emit_u8(byte)?;
}
Ok(())
#[inline]
fn decode<D: Decoder>(d: &mut D) -> Result<Fingerprint, D::Error> {
let mut result = Fingerprint([0u8; FINGERPRINT_LENGTH]);
- for byte in &mut result.0[..] {
+ for byte in &mut result.0 {
*byte = d.read_u8()?;
}
Ok(result)
use std::default::Default as StdDefault;
use std::mem;
use std::fmt;
-use std::ops::Deref;
use syntax::attr;
use syntax::ast;
use syntax::symbol::Symbol;
Allow => bug!("earlier conditional return should handle Allow case")
};
let hyphen_case_lint_name = name.replace("_", "-");
- if lint_flag_val.as_str().deref() == name {
+ if lint_flag_val.as_str() == name {
err.note(&format!("requested on the command line with `{} {}`",
flag, hyphen_case_lint_name));
} else {
},
Node(lint_attr_name, src) => {
def = Some(src);
- if lint_attr_name.as_str().deref() != name {
+ if lint_attr_name.as_str() != name {
let level_str = level.as_str();
err.note(&format!("#[{}({})] implied by #[{}({})]",
level_str, name, level_str, lint_attr_name));
if !self.stability.borrow().active_features.contains(feature) {
let msg = match *reason {
Some(ref r) => format!("use of unstable library feature '{}': {}",
- &feature.as_str(), &r),
+ feature.as_str(), &r),
None => format!("use of unstable library feature '{}'", &feature)
};
emit_feature_err(&self.sess.parse_sess, &feature.as_str(), span,
// First, filter out duplicates
moved.sort();
moved.dedup();
- debug!("fragments 1 moved: {:?}", path_lps(&moved[..]));
+ debug!("fragments 1 moved: {:?}", path_lps(&moved));
assigned.sort();
assigned.dedup();
- debug!("fragments 1 assigned: {:?}", path_lps(&assigned[..]));
+ debug!("fragments 1 assigned: {:?}", path_lps(&assigned));
// Second, build parents from the moved and assigned.
for m in &moved {
parents.sort();
parents.dedup();
- debug!("fragments 2 parents: {:?}", path_lps(&parents[..]));
+ debug!("fragments 2 parents: {:?}", path_lps(&parents));
// Third, filter the moved and assigned fragments down to just the non-parents
- moved.retain(|f| non_member(*f, &parents[..]));
- debug!("fragments 3 moved: {:?}", path_lps(&moved[..]));
+ moved.retain(|f| non_member(*f, &parents));
+ debug!("fragments 3 moved: {:?}", path_lps(&moved));
- assigned.retain(|f| non_member(*f, &parents[..]));
- debug!("fragments 3 assigned: {:?}", path_lps(&assigned[..]));
+ assigned.retain(|f| non_member(*f, &parents));
+ debug!("fragments 3 assigned: {:?}", path_lps(&assigned));
// Fourth, build the leftover from the moved, assigned, and parents.
for m in &moved {
unmoved.sort();
unmoved.dedup();
- debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved[..]));
+ debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved));
// Fifth, filter the leftover fragments down to its core.
unmoved.retain(|f| match *f {
AllButOneFrom(_) => true,
- Just(mpi) => non_member(mpi, &parents[..]) &&
- non_member(mpi, &moved[..]) &&
- non_member(mpi, &assigned[..])
+ Just(mpi) => non_member(mpi, &parents) &&
+ non_member(mpi, &moved) &&
+ non_member(mpi, &assigned)
});
- debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved[..]));
+ debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved));
// Swap contents back in.
fragments.unmoved_fragments = unmoved;
&flowed_moves.move_data,
owner_id);
- check_loans::check_loans(bccx, &loan_dfcx, &flowed_moves, &all_loans[..], body);
+ check_loans::check_loans(bccx, &loan_dfcx, &flowed_moves, &all_loans, body);
}
fn build_borrowck_dataflow_data<'a, 'tcx>(this: &mut BorrowckCtxt<'a, 'tcx>,
set.push_str(", ");
}
let loan_str = self.borrowck_ctxt.loan_path_to_string(&lp);
- set.push_str(&loan_str[..]);
+ set.push_str(&loan_str);
saw_some = true;
true
});
}).collect();
let wild_patterns: Vec<_> = wild_patterns_owned.iter().collect();
let matrix = Matrix(m.iter().flat_map(|r| {
- specialize(cx, &r[..], &ctor, &wild_patterns)
+ specialize(cx, &r, &ctor, &wild_patterns)
}).collect());
match specialize(cx, v, &ctor, &wild_patterns) {
- Some(v) => match is_useful(cx, &matrix, &v[..], witness) {
+ Some(v) => match is_useful(cx, &matrix, &v, witness) {
UsefulWithWitness(witnesses) => UsefulWithWitness(
witnesses.into_iter()
.map(|witness| witness.apply_constructor(cx, &ctor, lty))
for &(pat, hir_pat) in pats {
let v = vec![pat];
- match is_useful(cx, &seen, &v[..], LeaveOutWitness) {
+ match is_useful(cx, &seen, &v, LeaveOutWitness) {
NotUseful => {
match source {
hir::MatchSource::IfLetDesugar { .. } => {
type Target = [A::Element];
fn deref(&self) -> &Self::Target {
match *self {
- AccumulateVec::Array(ref v) => &v[..],
- AccumulateVec::Heap(ref v) => &v[..],
+ AccumulateVec::Array(ref v) => v,
+ AccumulateVec::Heap(ref v) => v,
}
}
}
impl<A: Array> DerefMut for AccumulateVec<A> {
fn deref_mut(&mut self) -> &mut [A::Element] {
match *self {
- AccumulateVec::Array(ref mut v) => &mut v[..],
- AccumulateVec::Heap(ref mut v) => &mut v[..],
+ AccumulateVec::Array(ref mut v) => v,
+ AccumulateVec::Heap(ref mut v) => v,
}
}
}
#[test]
fn test_encode() {
fn test(n: u64, base: u64) {
- assert_eq!(Ok(n), u64::from_str_radix(&encode(n, base)[..], base as u32));
+ assert_eq!(Ok(n), u64::from_str_radix(&encode(n, base), base as u32));
}
for base in 2..37 {
impl ::std::fmt::Debug for Blake2bCtx {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
try!(write!(fmt, "hash: "));
- for v in &self.h[..] {
+ for v in &self.h {
try!(write!(fmt, "{:x}", v));
}
Ok(())
impl<T: Idx> Deref for IdxSetBuf<T> {
type Target = IdxSet<T>;
fn deref(&self) -> &IdxSet<T> {
- unsafe { IdxSet::from_slice(&self.bits[..]) }
+ unsafe { IdxSet::from_slice(&self.bits) }
}
}
impl<T: Idx> DerefMut for IdxSetBuf<T> {
fn deref_mut(&mut self) -> &mut IdxSet<T> {
- unsafe { IdxSet::from_slice_mut(&mut self.bits[..]) }
+ unsafe { IdxSet::from_slice_mut(&mut self.bits) }
}
}
}
pub fn words(&self) -> &[Word] {
- &self.bits[..]
+ &self.bits
}
pub fn words_mut(&mut self) -> &mut [Word] {
- &mut self.bits[..]
+ &mut self.bits
}
pub fn clone_from(&mut self, other: &IdxSet<T>) {
// Extract input (string or file and optional path) from matches.
fn make_input(free_matches: &[String]) -> Option<(Input, Option<PathBuf>)> {
if free_matches.len() == 1 {
- let ifile = &free_matches[0][..];
+ let ifile = &free_matches[0];
if ifile == "-" {
let mut src = String::new();
io::stdin().read_to_string(&mut src).unwrap();
for lint in lints {
let name = lint.name_lower().replace("_", "-");
println!(" {} {:7.7} {}",
- padded(&name[..]),
+ padded(&name),
lint.default_level.as_str(),
lint.desc);
}
.map(|x| x.to_string().replace("_", "-"))
.collect::<Vec<String>>()
.join(", ");
- println!(" {} {}", padded(&name[..]), desc);
+ println!(" {} {}", padded(&name), desc);
}
println!("\n");
};
.into_iter()
.map(|x| x.opt_group)
.collect();
- let matches = match getopts::getopts(&args[..], &all_groups) {
+ let matches = match getopts::getopts(&args, &all_groups) {
Ok(m) => m,
Err(f) => early_error(ErrorOutputType::default(), &f.to_string()),
};
format!("we would appreciate a bug report: {}", BUG_REPORT_URL)];
for note in &xs {
handler.emit(&MultiSpan::new(),
- ¬e[..],
+ ¬e,
errors::Level::Note);
}
if match env::var_os("RUST_BACKTRACE") {
-> NodesMatchingUII<'a, 'hir> {
match *self {
ItemViaNode(node_id) => NodesMatchingDirect(Some(node_id).into_iter()),
- ItemViaPath(ref parts) => NodesMatchingSuffix(map.nodes_matching_suffix(&parts[..])),
+ ItemViaPath(ref parts) => NodesMatchingSuffix(map.nodes_matching_suffix(&parts)),
}
}
user_option,
self.reconstructed_input(),
is_wrong_because);
- sess.fatal(&message[..])
+ sess.fatal(&message)
};
let mut saw_node = ast::DUMMY_NODE_ID;
fn expand_err_details(r: io::Result<()>) -> io::Result<()> {
r.map_err(|ioerr| {
io::Error::new(io::ErrorKind::Other,
- &format!("graphviz::render failed: {}", ioerr)[..])
+ format!("graphviz::render failed: {}", ioerr))
})
}
}
pub fn t_param(&self, index: u32) -> Ty<'tcx> {
let name = format!("T{}", index);
- self.infcx.tcx.mk_param(index, Symbol::intern(&name[..]))
+ self.infcx.tcx.mk_param(index, Symbol::intern(&name))
}
pub fn re_early_bound(&self, index: u32, name: &'static str) -> &'tcx ty::Region {
let rustc_version_str_len = rustc_version_str_len[0] as usize;
let mut buffer = Vec::with_capacity(rustc_version_str_len);
buffer.resize(rustc_version_str_len, 0);
- file.read_exact(&mut buffer[..])?;
+ file.read_exact(&mut buffer)?;
- if &buffer[..] != rustc_version().as_bytes() {
+ if buffer != rustc_version().as_bytes() {
report_format_mismatch(sess, path, "Different compiler version");
return Ok(None);
}
} else {
format!("{} `{}` should have a camel case name such as `{}`", sort, name, c)
};
- cx.span_lint(NON_CAMEL_CASE_TYPES, span, &m[..]);
+ cx.span_lint(NON_CAMEL_CASE_TYPES, span, &m);
}
}
}
attr.check_name("doc") &&
match attr.meta_item_list() {
None => false,
- Some(l) => attr::list_contains_name(&l[..], "hidden"),
+ Some(l) => attr::list_contains_name(&l, "hidden"),
}
});
self.doc_hidden_stack.push(doc_hidden);
ty::TyBool => return,
ty::TyAdt(def, _) => {
let attrs = cx.tcx.get_attrs(def.did);
- check_must_use(cx, &attrs[..], s.span)
+ check_must_use(cx, &attrs, s.span)
}
_ => false,
};
cfg.flag(flag);
}
- for component in &components[..] {
+ for component in &components {
let mut flag = String::from("-DLLVM_COMPONENT_");
flag.push_str(&component.to_uppercase());
cfg.flag(&flag);
if !is_crossed {
cmd.arg("--system-libs");
}
- cmd.args(&components[..]);
+ cmd.args(&components);
for lib in output(&mut cmd).split_whitespace() {
let name = if lib.starts_with("-l") {
name,
config::host_triple(),
self.sess.opts.target_triple);
- span_fatal!(self.sess, span, E0456, "{}", &message[..]);
+ span_fatal!(self.sess, span, E0456, "{}", &message);
}
let root = ekrate.metadata.get_root();
self.encode_fields(def_id);
}
hir::ItemImpl(..) => {
- for &trait_item_def_id in &self.tcx.associated_item_def_ids(def_id)[..] {
+ for &trait_item_def_id in self.tcx.associated_item_def_ids(def_id).iter() {
self.record(trait_item_def_id,
EncodeContext::encode_info_for_impl_item,
trait_item_def_id);
}
}
hir::ItemTrait(..) => {
- for &item_def_id in &self.tcx.associated_item_def_ids(def_id)[..] {
+ for &item_def_id in self.tcx.associated_item_def_ids(def_id).iter() {
self.record(item_def_id,
EncodeContext::encode_info_for_trait_item,
item_def_id);
Some(file) => file,
};
let (hash, found_kind) =
- if file.starts_with(&rlib_prefix[..]) && file.ends_with(".rlib") {
+ if file.starts_with(&rlib_prefix) && file.ends_with(".rlib") {
(&file[(rlib_prefix.len())..(file.len() - ".rlib".len())], CrateFlavor::Rlib)
- } else if file.starts_with(&rlib_prefix[..]) && file.ends_with(".rmeta") {
+ } else if file.starts_with(&rlib_prefix) && file.ends_with(".rmeta") {
(&file[(rlib_prefix.len())..(file.len() - ".rmeta".len())], CrateFlavor::Rmeta)
} else if file.starts_with(&dylib_prefix) &&
file.ends_with(&dypair.1) {
(&file[(dylib_prefix.len())..(file.len() - dypair.1.len())], CrateFlavor::Dylib)
} else {
- if file.starts_with(&staticlib_prefix[..]) && file.ends_with(&staticpair.1) {
+ if file.starts_with(&staticlib_prefix) && file.ends_with(&staticpair.1) {
staticlibs.push(CrateMismatch {
path: path.to_path_buf(),
got: "static".to_string(),
// inside this crate, so continue would spew "macro undefined"
// errors
Err(err) => {
- self.sess.span_fatal(span, &err[..])
+ self.sess.span_fatal(span, &err)
}
};
unsafe {
let registrar =
- match lib.symbol(&symbol[..]) {
+ match lib.symbol(&symbol) {
Ok(registrar) => {
mem::transmute::<*mut u8,PluginRegistrarFun>(registrar)
}
// again fatal if we can't register macros
Err(err) => {
- self.sess.span_fatal(span, &err[..])
+ self.sess.span_fatal(span, &err)
}
};
let strs = pairs.map(|(f, v)| format!(",{},\"{}\"", f, escape(String::from(v))));
strs.fold(String::new(), |mut s, ss| {
- s.push_str(&ss[..]);
+ s.push_str(&ss);
s
})
}
match sig.inputs().last().unwrap().sty {
ty::TyTuple(ref tupled_arguments, _) => {
inputs = &sig.inputs()[0..sig.inputs().len() - 1];
- &tupled_arguments[..]
+ &tupled_arguments
}
_ => {
bug!("argument to function with \"rust-call\" ABI \
variant_fill].iter().cloned().collect();
match name {
None => {
- Type::struct_(cx, &fields[..], false)
+ Type::struct_(cx, &fields, false)
}
Some(name) => {
let mut llty = Type::named_struct(cx, name);
- llty.set_struct_body(&fields[..], false);
+ llty.set_struct_body(&fields, false);
llty
}
}
alignment: Alignment,
) -> ValueRef {
let llptrptr = bcx.gepi(scrutinee,
- &discrfield.iter().map(|f| *f as usize).collect::<Vec<_>>()[..]);
+ &discrfield.iter().map(|f| *f as usize).collect::<Vec<_>>());
let llptr = bcx.load(llptrptr, alignment.to_align());
let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
bcx.icmp(cmp, llptr, C_null(val_ty(llptr)))
base::call_memset(bcx, llptr, fill_byte, size, align, false);
} else {
let path = discrfield.iter().map(|&i| i as usize).collect::<Vec<_>>();
- let llptrptr = bcx.gepi(val, &path[..]);
+ let llptrptr = bcx.gepi(val, &path);
let llptrty = val_ty(llptrptr).element_type();
bcx.store(C_null(llptrty), llptrptr, None);
}
.chain(arch_clobbers.iter().map(|s| s.to_string()))
.collect::<Vec<String>>().join(",");
- debug!("Asm Constraints: {}", &all_constraints[..]);
+ debug!("Asm Constraints: {}", &all_constraints);
// Depending on how many outputs we have, the return type is different
let num_outputs = output_types.len();
let output_type = match num_outputs {
0 => Type::void(bcx.ccx),
1 => output_types[0],
- _ => Type::struct_(bcx.ccx, &output_types[..], false)
+ _ => Type::struct_(bcx.ccx, &output_types, false)
};
let dialect = match ia.dialect {
for path in search_paths {
debug!("looking for {} inside {:?}", name, path);
- let test = path.join(&oslibname[..]);
+ let test = path.join(&oslibname);
if test.exists() { return test }
if oslibname != unixlibname {
- let test = path.join(&unixlibname[..]);
+ let test = path.join(&unixlibname);
if test.exists() { return test }
}
}
attrs: &[ast::Attribute],
input: &Input) -> String {
let validate = |s: String, span: Option<Span>| {
- cstore::validate_crate_name(sess, &s[..], span);
+ cstore::validate_crate_name(sess, &s, span);
s
};
let msg = format!("--crate-name and #[crate_name] are \
required to match, but `{}` != `{}`",
s, name);
- sess.span_err(attr.span, &msg[..]);
+ sess.span_err(attr.span, &msg);
}
}
return validate(s.clone(), None);
outputs: &OutputFilenames)
-> Vec<PathBuf> {
trans.modules.iter().map(|module| {
- outputs.temp_path(OutputType::Object, Some(&module.name[..]))
+ outputs.temp_path(OutputType::Object, Some(&module.name))
}).collect()
}
e))
}
- let bc_data_deflated = flate::deflate_bytes(&bc_data[..]);
+ let bc_data_deflated = flate::deflate_bytes(&bc_data);
let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) {
Ok(file) => file,
pname,
prog.status))
.note(&format!("{:?}", &cmd))
- .note(&escape_string(&output[..]))
+ .note(&escape_string(&output))
.emit();
sess.abort_if_errors();
}
- info!("linker stderr:\n{}", escape_string(&prog.stderr[..]));
- info!("linker stdout:\n{}", escape_string(&prog.stdout[..]));
+ info!("linker stderr:\n{}", escape_string(&prog.stderr));
+ info!("linker stdout:\n{}", escape_string(&prog.stdout));
},
Err(e) => {
sess.struct_err(&format!("could not exec the linker `{}`: {}", pname, e))
}
let export_threshold =
- symbol_export::crates_export_threshold(&sess.crate_types.borrow()[..]);
+ symbol_export::crates_export_threshold(&sess.crate_types.borrow());
let symbol_filter = &|&(ref name, level): &(String, _)| {
if symbol_export::is_below_threshold(level, export_threshold) {
bc_decoded.len() as libc::size_t) {
write::llvm_err(sess.diagnostic(),
format!("failed to load bc of `{}`",
- &name[..]));
+ name));
}
});
}
let libs = config.used_crates.clone();
let libs = libs.into_iter().filter_map(|(_, l)| l.option()).collect::<Vec<_>>();
- let rpaths = get_rpaths(config, &libs[..]);
- flags.extend_from_slice(&rpaths_to_flags(&rpaths[..]));
+ let rpaths = get_rpaths(config, &libs);
+ flags.extend_from_slice(&rpaths_to_flags(&rpaths));
// Use DT_RUNPATH instead of DT_RPATH if available
if config.linker_is_gnu {
}
}
- log_rpaths("relative", &rel_rpaths[..]);
- log_rpaths("fallback", &fallback_rpaths[..]);
+ log_rpaths("relative", &rel_rpaths);
+ log_rpaths("fallback", &fallback_rpaths);
let mut rpaths = rel_rpaths;
- rpaths.extend_from_slice(&fallback_rpaths[..]);
+ rpaths.extend_from_slice(&fallback_rpaths);
// Remove duplicates
- let rpaths = minimize_rpaths(&rpaths[..]);
+ let rpaths = minimize_rpaths(&rpaths);
return rpaths;
}
let mut set = HashSet::new();
let mut minimized = Vec::new();
for rpath in rpaths {
- if set.insert(&rpath[..]) {
+ if set.insert(rpath) {
minimized.push(rpath.clone());
}
}
cnum: CrateNum)
-> &[(String, SymbolExportLevel)] {
match self.exports.get(&cnum) {
- Some(exports) => &exports[..],
+ Some(exports) => exports,
None => &[]
}
}
{
for &(ref name, export_level) in self.exported_symbols(cnum) {
if is_below_threshold(export_level, export_threshold) {
- f(&name[..], export_level)
+ f(&name, export_level)
}
}
}
if !result.is_empty() &&
result.as_bytes()[0] != '_' as u8 &&
! (result.as_bytes()[0] as char).is_xid_start() {
- return format!("_{}", &result[..]);
+ return format!("_{}", result);
}
return result;
Some(ref code) => {
handler.emit_with_code(&MultiSpan::new(),
&diag.msg,
- &code[..],
+ &code,
diag.lvl);
},
None => {
let fdata_sections = ffunction_sections;
let code_model_arg = match sess.opts.cg.code_model {
- Some(ref s) => &s[..],
- None => &sess.target.target.options.code_model[..],
+ Some(ref s) => &s,
+ None => &sess.target.target.options.code_model,
};
let code_model = match CODE_GEN_MODEL_ARGS.iter().find(
let msg = llvm::build_string(|s| llvm::LLVMRustWriteSMDiagnosticToString(diag, s))
.expect("non-UTF8 SMDiagnostic");
- report_inline_asm(cgcx, &msg[..], cookie);
+ report_inline_asm(cgcx, &msg, cookie);
}
unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_void) {
if trans.modules.len() == 1 {
// 1) Only one codegen unit. In this case it's no difficulty
// to copy `foo.0.x` to `foo.x`.
- let module_name = Some(&(trans.modules[0].name)[..]);
+ let module_name = Some(&trans.modules[0].name[..]);
let path = crate_output.temp_path(output_type, module_name);
copy_gracefully(&path,
&crate_output.path(output_type));
if metadata_config.emit_bc && !user_wants_bitcode {
let path = crate_output.temp_path(OutputType::Bitcode,
- Some(&trans.metadata_module.name[..]));
+ Some(&trans.metadata_module.name));
remove(sess, &path);
}
}
n_bytes: ValueRef,
align: u32) {
let ccx = b.ccx;
- let ptr_width = &ccx.sess().target.target.target_pointer_width[..];
+ let ptr_width = &ccx.sess().target.target.target_pointer_width;
let key = format!("llvm.memcpy.p0i8.p0i8.i{}", ptr_width);
let memcpy = ccx.get_intrinsic(&key);
let src_ptr = b.pointercast(src, Type::i8p(ccx));
size: ValueRef,
align: ValueRef,
volatile: bool) -> ValueRef {
- let ptr_width = &b.ccx.sess().target.target.target_pointer_width[..];
+ let ptr_width = &b.ccx.sess().target.target.target_pointer_width;
let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
let llintrinsicfn = b.ccx.get_intrinsic(&intrinsic_key);
let volatile = C_bool(b.ccx, volatile);
let mut compressed = cstore.metadata_encoding_version().to_vec();
compressed.extend_from_slice(&flate::deflate_bytes(&metadata));
- let llmeta = C_bytes_in_context(cx.metadata_llcx(), &compressed[..]);
+ let llmeta = C_bytes_in_context(cx.metadata_llcx(), &compressed);
let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false);
let name = cx.metadata_symbol_name();
let buf = CString::new(name).unwrap();
symbol_map: &SymbolMap<'tcx>,
exported_symbols: &ExportedSymbols) {
let export_threshold =
- symbol_export::crates_export_threshold(&sess.crate_types.borrow()[..]);
+ symbol_export::crates_export_threshold(&sess.crate_types.borrow());
let exported_symbols = exported_symbols
.exported_symbols(LOCAL_CRATE)
(generics.parent_types == 0 && generics.types.is_empty()) &&
// Functions marked with #[inline] are only ever translated
// with "internal" linkage and are never exported.
- !attr::requests_inline(&attributes[..])
+ !attr::requests_inline(&attributes)
}
_ => false
cgus.dedup();
for &(ref cgu_name, linkage) in cgus.iter() {
output.push_str(" ");
- output.push_str(&cgu_name[..]);
+ output.push_str(&cgu_name);
let linkage_abbrev = match linkage {
llvm::Linkage::ExternalLinkage => "External",
} else {
let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::<Vec<ValueRef>>();
self.count_insn("gepi");
- self.inbounds_gep(base, &v[..])
+ self.inbounds_gep(base, &v)
}
}
let s = format!("{} ({})",
text,
self.ccx.sess().codemap().span_to_string(sp));
- debug!("{}", &s[..]);
- self.add_comment(&s[..]);
+ debug!("{}", s);
+ self.add_comment(&s);
}
}
if attr.is_word() {
Some(format!("{}", name))
} else if let Some(v) = attr.value_str() {
- Some(format!("{} = {:?}", name, &v.as_str()[..]))
+ Some(format!("{} = {:?}", name, v.as_str()))
} else if let Some(values) = attr.meta_item_list() {
let display: Vec<_> = values.iter().filter_map(|attr| {
attr.meta_item().and_then(|mi| render_attribute(mi))
for attr in &it.attrs.other_attrs {
let name = attr.name().unwrap();
- if !ATTRIBUTE_WHITELIST.contains(&&name.as_str()[..]) {
+ if !ATTRIBUTE_WHITELIST.contains(&&*name.as_str()) {
continue;
}
if let Some(s) = render_attribute(&attr.meta().unwrap()) {
};
let mut p = Parser::new(cx.parse_sess(), tts, Some(directory), false);
p.root_module_name = cx.current_expansion.module.mod_path.last()
- .map(|id| (*id.name.as_str()).to_owned());
+ .map(|id| id.name.as_str().to_string());
p.check_unknown_macro_variable();
// Let the context choose how to interpret the result.
impl GatedCfg {
pub fn gate(cfg: &ast::MetaItem) -> Option<GatedCfg> {
- let name = &*cfg.name().as_str();
+ let name = cfg.name().as_str();
GATED_CFGS.iter()
.position(|info| info.0 == name)
.map(|idx| {
impl<'a> Context<'a> {
fn check_attribute(&self, attr: &ast::Attribute, is_macro: bool) {
debug!("check_attribute(attr = {:?})", attr);
- let name = unwrap_or!(attr.name(), return);
-
+ let name = unwrap_or!(attr.name(), return).as_str();
for &(n, ty, ref gateage) in BUILTIN_ATTRIBUTES {
if name == n {
if let &Gated(_, ref name, ref desc, ref has_feature) = gateage {
return;
}
}
- if name.as_str().starts_with("rustc_") {
+ if name.starts_with("rustc_") {
gate_feature!(self, rustc_attrs, attr.span,
"unless otherwise specified, attributes \
with the prefix `rustc_` \
are reserved for internal compiler diagnostics");
- } else if name.as_str().starts_with("derive_") {
+ } else if name.starts_with("derive_") {
gate_feature!(self, custom_derive, attr.span, EXPLAIN_DERIVE_UNDERSCORE);
} else if !attr::is_known(attr) {
// Only run the custom attribute lint during regular
fn push_directory(&mut self, id: Ident, attrs: &[Attribute]) {
if let Some(path) = attr::first_attr_value_str_by_name(attrs, "path") {
- self.directory.path.push(&*path.as_str());
+ self.directory.path.push(&path.as_str());
self.directory.ownership = DirectoryOwnership::Owned;
} else {
- self.directory.path.push(&*id.name.as_str());
+ self.directory.path.push(&id.name.as_str());
}
}
pub fn submod_path_from_attr(attrs: &[ast::Attribute], dir_path: &Path) -> Option<PathBuf> {
- attr::first_attr_value_str_by_name(attrs, "path").map(|d| dir_path.join(&*d.as_str()))
+ attr::first_attr_value_str_by_name(attrs, "path").map(|d| dir_path.join(&d.as_str()))
}
/// Returns either a path to a module, or .
fn is_test_crate(krate: &ast::Crate) -> bool {
match attr::find_crate_name(&krate.attrs) {
- Some(s) if "test" == &*s.as_str() => true,
+ Some(s) if "test" == s.as_str() => true,
_ => false
}
}