use std::borrow::Cow;
use std::env;
-use std::fs::{self, File};
+use std::fs;
use std::io::BufReader;
use std::io::prelude::*;
use std::path::{Path, PathBuf};
}
let stamp = codegen_backend_stamp(builder, compiler, target, backend);
let codegen_backend = codegen_backend.to_str().unwrap();
- t!(t!(File::create(&stamp)).write_all(codegen_backend.as_bytes()));
+ t!(fs::write(&stamp, &codegen_backend));
}
}
for backend in builder.config.rust_codegen_backends.iter() {
let stamp = codegen_backend_stamp(builder, compiler, target, *backend);
- let mut dylib = String::new();
- t!(t!(File::open(&stamp)).read_to_string(&mut dylib));
+ let dylib = t!(fs::read_to_string(&stamp));
let file = Path::new(&dylib);
let filename = file.file_name().unwrap().to_str().unwrap();
// change `librustc_codegen_llvm-xxxxxx.so` to `librustc_codegen_llvm-llvm.so`
// contents (the list of files to copy) is different or if any dep's mtime
// is newer then we rewrite the stamp file.
deps.sort();
- let mut stamp_contents = Vec::new();
- if let Ok(mut f) = File::open(stamp) {
- t!(f.read_to_end(&mut stamp_contents));
- }
+ let stamp_contents = fs::read(stamp);
let stamp_mtime = mtime(&stamp);
let mut new_contents = Vec::new();
let mut max = None;
}
let max = max.unwrap();
let max_path = max_path.unwrap();
- if stamp_contents == new_contents && max <= stamp_mtime {
+ let contents_equal = stamp_contents
+ .map(|contents| contents == new_contents)
+ .unwrap_or_default();
+ if contents_equal && max <= stamp_mtime {
builder.verbose(&format!("not updating {:?}; contents equal and {:?} <= {:?}",
stamp, max, stamp_mtime));
return deps
} else {
builder.verbose(&format!("updating {:?} as deps changed", stamp));
}
- t!(t!(File::create(stamp)).write_all(&new_contents));
+ t!(fs::write(&stamp, &new_contents));
deps
}
use std::collections::{HashMap, HashSet};
use std::env;
-use std::fs::{self, File};
-use std::io::prelude::*;
+use std::fs;
use std::path::{Path, PathBuf};
use std::process;
use std::cmp;
config.run_host_only = !(flags.host.is_empty() && !flags.target.is_empty());
let toml = file.map(|file| {
- let mut f = t!(File::open(&file));
- let mut contents = String::new();
- t!(f.read_to_string(&mut contents));
+ let contents = t!(fs::read_to_string(&file));
match toml::from_str(&contents) {
Ok(table) => table,
Err(err) => {
//! pieces of `rustup.rs`!
use std::env;
-use std::fs::{self, File};
-use std::io::{Read, Write};
+use std::fs;
+use std::io::Write;
use std::path::{PathBuf, Path};
use std::process::{Command, Stdio};
}
let xform = |p: &Path| {
- let mut contents = String::new();
- t!(t!(File::open(p)).read_to_string(&mut contents));
+ let mut contents = t!(fs::read_to_string(p));
if rls_installer.is_none() {
contents = filter(&contents, "rls");
}
contents = filter(&contents, "rustfmt");
}
let ret = tmp.join(p.file_name().unwrap());
- t!(t!(File::create(&ret)).write_all(contents.as_bytes()));
- return ret
+ t!(fs::write(&ret, &contents));
+ ret
};
if target.contains("apple-darwin") {
let file = builder.config.dist_gpg_password_file.as_ref().unwrap_or_else(|| {
panic!("\n\nfailed to specify `dist.gpg-password-file` in `config.toml`\n\n")
});
- let mut pass = String::new();
- t!(t!(File::open(&file)).read_to_string(&mut pass));
+ let pass = t!(fs::read_to_string(&file));
let today = output(Command::new("date").arg("+%Y-%m-%d"));
//! `rustdoc`.
use std::collections::HashSet;
-use std::fs::{self, File};
-use std::io::prelude::*;
+use std::fs;
use std::io;
use std::path::{PathBuf, Path};
let version_info = out.join("version_info.html");
if !builder.config.dry_run && !up_to_date(&version_input, &version_info) {
- let mut info = String::new();
- t!(t!(File::open(&version_input)).read_to_string(&mut info));
- let info = info.replace("VERSION", &builder.rust_release())
- .replace("SHORT_HASH", builder.rust_info.sha_short().unwrap_or(""))
- .replace("STAMP", builder.rust_info.sha().unwrap_or(""));
- t!(t!(File::create(&version_info)).write_all(info.as_bytes()));
+ let info = t!(fs::read_to_string(&version_input))
+ .replace("VERSION", &builder.rust_release())
+ .replace("SHORT_HASH", builder.rust_info.sha_short().unwrap_or(""))
+ .replace("STAMP", builder.rust_info.sha().unwrap_or(""));
+ t!(fs::write(&version_info, &info));
}
for file in t!(fs::read_dir(builder.src.join("src/doc"))) {
/// Returns the `a.b.c` version that the given package is at.
fn release_num(&self, package: &str) -> String {
- let mut toml = String::new();
let toml_file_name = self.src.join(&format!("src/tools/{}/Cargo.toml", package));
- t!(t!(File::open(toml_file_name)).read_to_string(&mut toml));
+ let toml = t!(fs::read_to_string(&toml_file_name));
for line in toml.lines() {
let prefix = "version = \"";
let suffix = "\"";
}
let mut paths = Vec::new();
- let mut contents = Vec::new();
- t!(t!(File::open(stamp)).read_to_end(&mut contents));
+ let contents = t!(fs::read(stamp));
// This is the method we use for extracting paths from the stamp file passed to us. See
// run_cargo for more information (in compile.rs).
for part in contents.split(|b| *b == 0) {
use std::env;
use std::ffi::OsString;
use std::fs::{self, File};
-use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::process::Command;
}
let rebuild_trigger = builder.src.join("src/rustllvm/llvm-rebuild-trigger");
- let mut rebuild_trigger_contents = String::new();
- t!(t!(File::open(&rebuild_trigger)).read_to_string(&mut rebuild_trigger_contents));
+ let rebuild_trigger_contents = t!(fs::read_to_string(&rebuild_trigger));
let (out_dir, llvm_config_ret_dir) = if emscripten {
let dir = builder.emscripten_llvm_out(target);
let build_llvm_config = llvm_config_ret_dir
.join(exe("llvm-config", &*builder.config.build));
if done_stamp.exists() {
- let mut done_contents = String::new();
- t!(t!(File::open(&done_stamp)).read_to_string(&mut done_contents));
+ let done_contents = t!(fs::read_to_string(&done_stamp));
// If LLVM was already built previously and contents of the rebuild-trigger file
// didn't change from the previous build, then no action is required.
cfg.build();
- t!(t!(File::create(&done_stamp)).write_all(rebuild_trigger_contents.as_bytes()));
+ t!(fs::write(&done_stamp, &rebuild_trigger_contents));
build_llvm_config
}
use std::collections::HashMap;
use std::env;
use std::ffi::{OsString, OsStr};
-use std::fs::{self, File};
-use std::io::Read;
+use std::fs;
use std::path::PathBuf;
use std::process::Command;
}
if build.config.channel == "stable" {
- let mut stage0 = String::new();
- t!(t!(File::open(build.src.join("src/stage0.txt")))
- .read_to_string(&mut stage0));
+ let stage0 = t!(fs::read_to_string(build.src.join("src/stage0.txt")));
if stage0.contains("\ndev:") {
panic!("bootstrapping from a dev compiler in a stable release, but \
should only be bootstrapping from a released compiler!");
use std::env;
use std::ffi::OsString;
use std::fmt;
-use std::fs::{self, File};
-use std::io::Read;
+use std::fs;
use std::iter;
use std::path::{Path, PathBuf};
use std::process::Command;
}
fn markdown_test(builder: &Builder, compiler: Compiler, markdown: &Path) -> bool {
- match File::open(markdown) {
- Ok(mut file) => {
- let mut contents = String::new();
- t!(file.read_to_string(&mut contents));
+ match fs::read_to_string(markdown) {
+ Ok(contents) => {
if !contents.contains("```") {
return true;
}
/// An example usage for error handling:
///
/// ```
-/// use std::io::{self, Read};
+/// use std::fs;
+/// use std::io;
/// use std::num;
///
/// enum CliError {
/// }
///
/// fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {
-/// let mut file = std::fs::File::open("test")?;
-/// let mut contents = String::new();
-/// file.read_to_string(&mut contents)?;
+/// let mut contents = fs::read_to_string(&file_name)?;
/// let num: i32 = contents.trim().parse()?;
/// Ok(num)
/// }
use std::collections::hash_map::Entry::Vacant;
use std::collections::btree_map::BTreeMap;
use std::env;
-use std::fs::File;
+use std::fs;
use std::io;
-use std::io::prelude::*;
use std::sync::atomic::{AtomicBool, Ordering};
fn print_help_message() {
debug!("dump_region_data calling render");
let mut v = Vec::new();
dot::render(&g, &mut v).unwrap();
- File::create(path).and_then(|mut f| f.write_all(&v))
+ fs::write(path, &v)
}
#![feature(box_syntax)]
use std::any::Any;
-use std::io::{self, Write};
-use std::fs::File;
+use std::io::Write;
+use std::fs;
use std::path::Path;
use std::sync::{mpsc, Arc};
impl MetadataLoader for NoLlvmMetadataLoader {
fn get_rlib_metadata(&self, _: &Target, filename: &Path) -> Result<MetadataRef, String> {
- let mut file = File::open(filename)
- .map_err(|e| format!("metadata file open err: {:?}", e))?;
-
- let mut buf = Vec::new();
- io::copy(&mut file, &mut buf).unwrap();
+ let buf = fs::read(filename).map_err(|e| format!("metadata file open err: {:?}", e))?;
let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf);
Ok(rustc_erase_owner!(buf.map_owner_box()))
}
} else {
&ongoing_codegen.metadata.raw_data
};
- let mut file = File::create(&output_name).unwrap();
- file.write_all(metadata).unwrap();
+ fs::write(&output_name, metadata).unwrap();
}
sess.abort_if_errors();
let mut themes: FxHashSet<String> = FxHashSet::default();
for entry in &cx.shared.themes {
- let mut content = Vec::with_capacity(100000);
-
- let mut f = try_err!(File::open(&entry), &entry);
- try_err!(f.read_to_end(&mut content), &entry);
+ let content = try_err!(fs::read(&entry), &entry);
let theme = try_none!(try_none!(entry.file_stem(), &entry).to_str(), &entry);
let extension = try_none!(try_none!(entry.extension(), &entry).to_str(), &entry);
write(cx.dst.join(format!("{}{}.{}", theme, cx.shared.resource_suffix, extension)),
if !options.enable_minification {
try_err!(fs::copy(css, out), css);
} else {
- let mut f = try_err!(File::open(css), css);
- let mut buffer = String::with_capacity(1000);
-
- try_err!(f.read_to_string(&mut buffer), css);
+ let buffer = try_err!(fs::read_to_string(css), css);
write_minify(out, &buffer, options.enable_minification)?;
}
}
if !buf.is_empty() {
try_err!(this.shared.ensure_dir(&this.dst), &this.dst);
let joint_dst = this.dst.join("index.html");
- let mut dst = try_err!(File::create(&joint_dst), &joint_dst);
- try_err!(dst.write_all(&buf), &joint_dst);
+ try_err!(fs::write(&joint_dst, buf), &joint_dst);
}
let m = match item.inner {
let file_name = &item_path(item_type, name);
try_err!(self.shared.ensure_dir(&self.dst), &self.dst);
let joint_dst = self.dst.join(file_name);
- let mut dst = try_err!(File::create(&joint_dst), &joint_dst);
- try_err!(dst.write_all(&buf), &joint_dst);
+ try_err!(fs::write(&joint_dst, buf), &joint_dst);
if !self.render_redirect_pages {
all.append(full_path(self, &item), &item_type);
// except according to those terms.
use rustc_data_structures::fx::FxHashSet;
-use std::fs::File;
+use std::fs;
use std::hash::{Hash, Hasher};
-use std::io::Read;
use std::path::Path;
use errors::Handler;
pub fn test_theme_against<P: AsRef<Path>>(f: &P, against: &CssPath, diag: &Handler)
-> (bool, Vec<String>)
{
- let mut file = try_something!(File::open(f), diag, (false, Vec::new()));
- let mut data = Vec::with_capacity(1000);
-
- try_something!(file.read_to_end(&mut data), diag, (false, Vec::new()));
+ let data = try_something!(fs::read(f), diag, (false, vec![]));
let paths = load_css_paths(&data);
- let mut ret = Vec::new();
+ let mut ret = vec![];
get_differences(against, &paths, &mut ret);
(true, ret)
}
use visit::{self, Visitor};
use rustc_data_structures::fx::FxHashMap;
-use std::fs::File;
-use std::io::Read;
+use std::fs;
+use std::io::ErrorKind;
use std::{iter, mem};
use std::rc::Rc;
use std::path::PathBuf;
return noop_fold_attribute(at, self);
}
- let mut buf = vec![];
let filename = self.cx.root_path.join(file.to_string());
-
- match File::open(&filename).and_then(|mut f| f.read_to_end(&mut buf)) {
- Ok(..) => {}
- Err(e) => {
- self.cx.span_err(at.span,
- &format!("couldn't read {}: {}",
- filename.display(),
- e));
- }
- }
-
- match String::from_utf8(buf) {
+ match fs::read_to_string(&filename) {
Ok(src) => {
let src_interned = Symbol::intern(&src);
let include_info = vec![
dummy_spanned(ast::NestedMetaItemKind::MetaItem(
- attr::mk_name_value_item_str(Ident::from_str("file"),
- dummy_spanned(file)))),
+ attr::mk_name_value_item_str(
+ Ident::from_str("file"),
+ dummy_spanned(file),
+ ),
+ )),
dummy_spanned(ast::NestedMetaItemKind::MetaItem(
- attr::mk_name_value_item_str(Ident::from_str("contents"),
- dummy_spanned(src_interned)))),
+ attr::mk_name_value_item_str(
+ Ident::from_str("contents"),
+ dummy_spanned(src_interned),
+ ),
+ )),
];
let include_ident = Ident::from_str("include");
let item = attr::mk_list_item(DUMMY_SP, include_ident, include_info);
items.push(dummy_spanned(ast::NestedMetaItemKind::MetaItem(item)));
}
- Err(_) => {
- self.cx.span_err(at.span,
- &format!("{} wasn't a utf-8 file",
- filename.display()));
+ Err(ref e) if e.kind() == ErrorKind::InvalidData => {
+ self.cx.span_err(
+ at.span,
+ &format!("{} wasn't a utf-8 file", filename.display()),
+ );
+ }
+ Err(e) => {
+ self.cx.span_err(
+ at.span,
+ &format!("couldn't read {}: {}", filename.display(), e),
+ );
}
}
} else {
use symbol::Symbol;
use tokenstream;
-use std::fs::File;
-use std::io::prelude::*;
+use std::fs;
+use std::io::ErrorKind;
use std::path::PathBuf;
use rustc_data_structures::sync::Lrc;
None => return DummyResult::expr(sp)
};
let file = res_rel_file(cx, sp, file);
- let mut bytes = Vec::new();
- match File::open(&file).and_then(|mut f| f.read_to_end(&mut bytes)) {
- Ok(..) => {}
- Err(e) => {
- cx.span_err(sp,
- &format!("couldn't read {}: {}",
- file.display(),
- e));
- return DummyResult::expr(sp);
- }
- };
- match String::from_utf8(bytes) {
+ match fs::read_to_string(&file) {
Ok(src) => {
let interned_src = Symbol::intern(&src);
cx.source_map().new_source_file(file.into(), src);
base::MacEager::expr(cx.expr_str(sp, interned_src))
+ },
+ Err(ref e) if e.kind() == ErrorKind::InvalidData => {
+ cx.span_err(sp, &format!("{} wasn't a utf-8 file", file.display()));
+ DummyResult::expr(sp)
}
- Err(_) => {
- cx.span_err(sp,
- &format!("{} wasn't a utf-8 file",
- file.display()));
+ Err(e) => {
+ cx.span_err(sp, &format!("couldn't read {}: {}", file.display(), e));
DummyResult::expr(sp)
}
}
None => return DummyResult::expr(sp)
};
let file = res_rel_file(cx, sp, file);
- let mut bytes = Vec::new();
- match File::open(&file).and_then(|mut f| f.read_to_end(&mut bytes)) {
- Err(e) => {
- cx.span_err(sp,
- &format!("couldn't read {}: {}", file.display(), e));
- DummyResult::expr(sp)
- }
- Ok(..) => {
- let src = match String::from_utf8(bytes.clone()) {
- Ok(contents) => contents,
- Err(..) => "".to_string()
+ match fs::read(&file) {
+ Ok(bytes) => {
+ // Add the contents to the source map if it contains UTF-8.
+ let (contents, bytes) = match String::from_utf8(bytes) {
+ Ok(s) => {
+ let bytes = s.as_bytes().to_owned();
+ (s, bytes)
+ },
+ Err(e) => (String::new(), e.into_bytes()),
};
-
- cx.source_map().new_source_file(file.into(), src);
+ cx.source_map().new_source_file(file.into(), contents);
base::MacEager::expr(cx.expr_lit(sp, ast::LitKind::ByteStr(Lrc::new(bytes))))
+ },
+ Err(e) => {
+ cx.span_err(sp, &format!("couldn't read {}: {}", file.display(), e));
+ DummyResult::expr(sp)
}
}
}
use std::env;
use std::fs;
-use std::io::{self, Read};
+use std::io;
use errors::SourceMapper;
/// Return the span itself if it doesn't come from a macro expansion,
}
fn read_file(&self, path: &Path) -> io::Result<String> {
- let mut src = String::new();
- fs::File::open(path)?.read_to_string(&mut src)?;
- Ok(src)
+ fs::read_to_string(path)
}
}
let filename = path.file_name().unwrap().to_str().unwrap();
let sha256 = self.output.join(format!("{}.sha256", filename));
- t!(t!(File::create(&sha256)).write_all(&sha.stdout));
+ t!(fs::write(&sha256, &sha.stdout));
let stdout = String::from_utf8_lossy(&sha.stdout);
stdout.split_whitespace().next().unwrap().to_string()
fn write(&self, contents: &str, channel_name: &str, suffix: &str) {
let dst = self.output.join(format!("channel-rust-{}{}", channel_name, suffix));
- t!(t!(File::create(&dst)).write_all(contents.as_bytes()));
+ t!(fs::write(&dst, contents));
self.hash(&dst);
self.sign(&dst);
}
use std::env;
use std::process::Command;
use std::path::{Path, PathBuf};
-use std::fs::File;
-use std::io::Write;
+use std::fs;
struct Test {
repo: &'static str,
println!("testing {}", test.repo);
let dir = clone_repo(test, out_dir);
if let Some(lockfile) = test.lock {
- File::create(&dir.join("Cargo.lock"))
- .expect("")
- .write_all(lockfile.as_bytes())
- .expect("");
+ fs::write(&dir.join("Cargo.lock"), lockfile).unwrap();
}
if !run_cargo_test(cargo, &dir, test.packages) {
panic!("tests failed for {}", test.repo);
use std::env;
use std::ffi::OsString;
use std::fs;
-use std::io::{self, Read};
+use std::io::{self, ErrorKind};
use std::path::{Path, PathBuf};
use std::process::Command;
use test::ColorConfig;
) -> bool {
let stamp_name = stamp(config, testpaths, revision);
// Check hash.
- let mut f = match fs::File::open(&stamp_name) {
+ let contents = match fs::read_to_string(&stamp_name) {
Ok(f) => f,
+ Err(ref e) if e.kind() == ErrorKind::InvalidData => panic!("Can't read stamp contents"),
Err(_) => return true,
};
- let mut contents = String::new();
- f.read_to_string(&mut contents)
- .expect("Can't read stamp contents");
let expected_hash = runtest::compute_stamp_hash(config);
if contents != expected_hash {
return true;
None => 2,
};
- let mut src = String::new();
- File::open(&self.testpaths.file)
- .unwrap()
- .read_to_string(&mut src)
- .unwrap();
+ let src = fs::read_to_string(&self.testpaths.file).unwrap();
let mut srcs = vec![src];
let mut round = 0;
let mut expected = match self.props.pp_exact {
Some(ref file) => {
let filepath = self.testpaths.file.parent().unwrap().join(file);
- let mut s = String::new();
- File::open(&filepath)
- .unwrap()
- .read_to_string(&mut s)
- .unwrap();
- s
+ fs::read_to_string(&filepath).unwrap()
}
None => srcs[srcs.len() - 2].clone(),
};
fn dump_output_file(&self, out: &str, extension: &str) {
let outfile = self.make_out_name(extension);
- File::create(&outfile)
- .unwrap()
- .write_all(out.as_bytes())
- .unwrap();
+ fs::write(&outfile, out).unwrap();
}
/// Create a filename for output with the given extension. Example:
path: &P,
mut other_files: Option<&mut Vec<String>>,
) -> Vec<usize> {
- let mut file =
- fs::File::open(path).expect("markdown_test_output_check_entry File::open failed");
- let mut content = String::new();
- file.read_to_string(&mut content)
- .expect("markdown_test_output_check_entry read_to_string failed");
+ let content = fs::read_to_string(&path).unwrap();
let mut ignore = false;
content
.lines()
}
fn check_mir_dump(&self) {
- let mut test_file_contents = String::new();
- fs::File::open(self.testpaths.file.clone())
- .unwrap()
- .read_to_string(&mut test_file_contents)
- .unwrap();
+ let test_file_contents = fs::read_to_string(&self.testpaths.file).unwrap();
if let Some(idx) = test_file_contents.find("// END RUST SOURCE") {
let (_, tests_text) = test_file_contents.split_at(idx + "// END_RUST SOURCE".len());
let tests_text_str = String::from(tests_text);
}
self.check_mir_test_timestamp(test_name, &output_file);
- let mut dumped_file = fs::File::open(output_file.clone()).unwrap();
- let mut dumped_string = String::new();
- dumped_file.read_to_string(&mut dumped_string).unwrap();
+ let dumped_string = fs::read_to_string(&output_file).unwrap();
let mut dumped_lines = dumped_string
.lines()
.map(|l| nocomment_mir_line(l))
}
fn load_expected_output_from_path(&self, path: &Path) -> Result<String, String> {
- let mut result = String::new();
- match File::open(path).and_then(|mut f| f.read_to_string(&mut result)) {
- Ok(_) => Ok(result),
- Err(e) => Err(format!(
- "failed to load expected output from `{}`: {}",
- path.display(),
- e
- )),
- }
+ fs::read_to_string(path).map_err(|err| {
+ format!("failed to load expected output from `{}`: {}", path.display(), err)
+ })
}
fn delete_file(&self, file: &PathBuf) {
- if let Err(e) = ::std::fs::remove_file(file) {
+ if let Err(e) = fs::remove_file(file) {
self.fatal(&format!(
"failed to delete `{}`: {}",
file.display(),
for output_file in &files {
if actual.is_empty() {
self.delete_file(output_file);
- } else {
- match File::create(&output_file).and_then(|mut f| f.write_all(actual.as_bytes())) {
- Ok(()) => {}
- Err(e) => self.fatal(&format!(
- "failed to write {} to `{}`: {}",
- kind,
- output_file.display(),
- e
- )),
- }
+ } else if let Err(err) = fs::write(&output_file, &actual) {
+ self.fatal(&format!(
+ "failed to write {} to `{}`: {}",
+ kind,
+ output_file.display(),
+ err,
+ ));
}
}
}
fn create_stamp(&self) {
- let mut f = File::create(::stamp(&self.config, self.testpaths, self.revision)).unwrap();
- f.write_all(compute_stamp_hash(&self.config).as_bytes())
- .unwrap();
+ let stamp = ::stamp(&self.config, self.testpaths, self.revision);
+ fs::write(&stamp, compute_stamp_hash(&self.config)).unwrap();
}
}
use std::collections::BTreeMap;
use std::env;
use std::error::Error;
-use std::fs::{read_dir, File};
-use std::io::{Read, Write};
+use std::fs::{self, read_dir, File};
+use std::io::Write;
use std::path::Path;
use std::path::PathBuf;
use std::cell::RefCell;
for entry in read_dir(metadata_dir)? {
let path = entry?.path();
- let mut metadata_str = String::new();
- File::open(&path).and_then(|mut f| f.read_to_string(&mut metadata_str))?;
+ let metadata_str = fs::read_to_string(&path)?;
let some_errors: ErrorMetadataMap = json::decode(&metadata_str)?;
#[cfg(unix)]
pub fn check(path: &Path, bad: &mut bool) {
use std::fs;
- use std::io::Read;
use std::process::{Command, Stdio};
use std::os::unix::prelude::*;
- if let Ok(mut file) = fs::File::open("/proc/version") {
- let mut contents = String::new();
- file.read_to_string(&mut contents).unwrap();
+ if let Ok(contents) = fs::read_to_string("/proc/version") {
// Probably on Windows Linux Subsystem or Docker via VirtualBox,
// all files will be marked as executable, so skip checking.
if contents.contains("Microsoft") || contents.contains("boot2docker") {
//! `extern crate` declarations. This should help us keep the DAG correctly
//! structured through various refactorings to prune out unnecessary edges.
-use std::io::prelude::*;
-use std::fs::File;
+use std::fs;
use std::path::Path;
pub fn check(path: &Path, bad: &mut bool) {
// Verify that the dependencies in Cargo.toml at `tomlfile` are sync'd with the
// `extern crate` annotations in the lib.rs at `libfile`.
fn verify(tomlfile: &Path, libfile: &Path, bad: &mut bool) {
- let mut toml = String::new();
- let mut librs = String::new();
- t!(t!(File::open(tomlfile)).read_to_string(&mut toml));
- t!(t!(File::open(libfile)).read_to_string(&mut librs));
+ let toml = t!(fs::read_to_string(&tomlfile));
+ let librs = t!(fs::read_to_string(&libfile));
if toml.contains("name = \"bootstrap\"") {
return
//! Check license of third-party deps by inspecting vendor
use std::collections::{BTreeSet, HashSet, HashMap};
-use std::fs::File;
-use std::io::Read;
+use std::fs;
use std::path::Path;
use std::process::Command;
if !path.exists() {
panic!("{} does not exist", path.display());
}
- let mut contents = String::new();
- t!(t!(File::open(path)).read_to_string(&mut contents));
+ let contents = t!(fs::read_to_string(&path));
let mut found_license = false;
for line in contents.lines() {
// ! Check for external package sources. Allow only vendorable packages.
-use std::fs::File;
-use std::io::Read;
+use std::fs;
use std::path::Path;
/// List of whitelisted sources for packages
let path = path.join("../Cargo.lock");
// open and read the whole file
- let mut cargo_lock = String::new();
- t!(t!(File::open(path)).read_to_string(&mut cargo_lock));
+ let cargo_lock = t!(fs::read_to_string(&path));
// process each line
for line in cargo_lock.lines() {
use std::collections::HashMap;
use std::fmt;
-use std::fs::File;
+use std::fs::{self, File};
use std::io::prelude::*;
use std::path::Path;
}
pub fn collect_lang_features(base_src_path: &Path, bad: &mut bool) -> Features {
- let mut contents = String::new();
- let path = base_src_path.join("libsyntax/feature_gate.rs");
- t!(t!(File::open(path)).read_to_string(&mut contents));
+ let contents = t!(fs::read_to_string(base_src_path.join("libsyntax/feature_gate.rs")));
// we allow rustc-internal features to omit a tracking issue.
// these features must be marked with `// rustc internal` in its own group.
projects / rust.git / commitdiff