auto merge of #17781 : P1start/rust/bitflags-lints, r=alexcrichton
Closes #17773.
This commit is contained in:
bors
commit
0e2f0acf22
|
|
@ -1196,7 +1196,7 @@ fn compose_and_run_compiler(
|
|||
|
||||
fn ensure_dir(path: &Path) {
|
||||
if path.is_dir() { return; }
|
||||
fs::mkdir(path, io::UserRWX).unwrap();
|
||||
fs::mkdir(path, io::USER_RWX).unwrap();
|
||||
}
|
||||
|
||||
fn compose_and_run(config: &Config, testfile: &Path,
|
||||
|
|
|
|||
|
|
@ -466,7 +466,7 @@ pub fn invalid_output_for_target(sess: &Session,
|
|||
fn is_writeable(p: &Path) -> bool {
|
||||
match p.stat() {
|
||||
Err(..) => true,
|
||||
Ok(m) => m.perm & io::UserWrite == io::UserWrite
|
||||
Ok(m) => m.perm & io::USER_WRITE == io::USER_WRITE
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1322,7 +1322,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
|
|||
// Fix up permissions of the copy, as fs::copy() preserves
|
||||
// permissions, but the original file may have been installed
|
||||
// by a package manager and may be read-only.
|
||||
match fs::chmod(&dst, io::UserRead | io::UserWrite) {
|
||||
match fs::chmod(&dst, io::USER_READ | io::USER_WRITE) {
|
||||
Ok(..) => {}
|
||||
Err(e) => {
|
||||
sess.err(format!("failed to chmod {} when preparing \
|
||||
|
|
|
|||
|
|
@ -1467,7 +1467,7 @@ pub fn process_crate(sess: &Session,
|
|||
},
|
||||
};
|
||||
|
||||
match fs::mkdir_recursive(&root_path, io::UserRWX) {
|
||||
match fs::mkdir_recursive(&root_path, io::USER_RWX) {
|
||||
Err(e) => sess.err(format!("Could not create directory {}: {}",
|
||||
root_path.display(), e).as_slice()),
|
||||
_ => (),
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ mod test {
|
|||
let linkdir = tmpdir.join("test3");
|
||||
|
||||
File::create(&file).unwrap();
|
||||
mkdir(&dir, io::UserRWX).unwrap();
|
||||
mkdir(&dir, io::USER_RWX).unwrap();
|
||||
symlink(&file, &link).unwrap();
|
||||
symlink(&dir, &linkdir).unwrap();
|
||||
|
||||
|
|
@ -91,8 +91,8 @@ mod test {
|
|||
let e = d.join("e");
|
||||
let f = a.join("f");
|
||||
|
||||
mkdir_recursive(&b, io::UserRWX).unwrap();
|
||||
mkdir_recursive(&d, io::UserRWX).unwrap();
|
||||
mkdir_recursive(&b, io::USER_RWX).unwrap();
|
||||
mkdir_recursive(&d, io::USER_RWX).unwrap();
|
||||
File::create(&f).unwrap();
|
||||
symlink(&Path::new("../d/e"), &c).unwrap();
|
||||
symlink(&Path::new("../f"), &e).unwrap();
|
||||
|
|
|
|||
|
|
@ -618,7 +618,7 @@ fn write(dst: Path, contents: &[u8]) -> io::IoResult<()> {
|
|||
/// skipping if the directory already exists.
|
||||
fn mkdir(path: &Path) -> io::IoResult<()> {
|
||||
if !path.exists() {
|
||||
fs::mkdir(path, io::UserRWX)
|
||||
fs::mkdir(path, io::USER_RWX)
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,22 +24,22 @@
|
|||
/// ```{.rust}
|
||||
/// bitflags! {
|
||||
/// flags Flags: u32 {
|
||||
/// static FlagA = 0x00000001,
|
||||
/// static FlagB = 0x00000010,
|
||||
/// static FlagC = 0x00000100,
|
||||
/// static FlagABC = FlagA.bits
|
||||
/// | FlagB.bits
|
||||
/// | FlagC.bits,
|
||||
/// static FLAG_A = 0x00000001,
|
||||
/// static FLAG_B = 0x00000010,
|
||||
/// static FLAG_C = 0x00000100,
|
||||
/// static FLAG_ABC = FLAG_A.bits
|
||||
/// | FLAG_B.bits
|
||||
/// | FLAG_C.bits,
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let e1 = FlagA | FlagC;
|
||||
/// let e2 = FlagB | FlagC;
|
||||
/// assert!((e1 | e2) == FlagABC); // union
|
||||
/// assert!((e1 & e2) == FlagC); // intersection
|
||||
/// assert!((e1 - e2) == FlagA); // set difference
|
||||
/// assert!(!e2 == FlagA); // set complement
|
||||
/// let e1 = FLAG_A | FLAG_C;
|
||||
/// let e2 = FLAG_B | FLAG_C;
|
||||
/// assert!((e1 | e2) == FLAG_ABC); // union
|
||||
/// assert!((e1 & e2) == FLAG_C); // intersection
|
||||
/// assert!((e1 - e2) == FLAG_A); // set difference
|
||||
/// assert!(!e2 == FLAG_A); // set complement
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
|
|
@ -50,8 +50,8 @@
|
|||
///
|
||||
/// bitflags! {
|
||||
/// flags Flags: u32 {
|
||||
/// static FlagA = 0x00000001,
|
||||
/// static FlagB = 0x00000010,
|
||||
/// static FLAG_A = 0x00000001,
|
||||
/// static FLAG_B = 0x00000010,
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
|
|
@ -69,7 +69,7 @@
|
|||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let mut flags = FlagA | FlagB;
|
||||
/// let mut flags = FLAG_A | FLAG_B;
|
||||
/// flags.clear();
|
||||
/// assert!(flags.is_empty());
|
||||
/// assert_eq!(format!("{}", flags).as_slice(), "hi!");
|
||||
|
|
@ -123,10 +123,7 @@ macro_rules! bitflags {
|
|||
bits: $T,
|
||||
}
|
||||
|
||||
$(
|
||||
#[allow(non_uppercase_statics)]
|
||||
$(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };
|
||||
)+
|
||||
$($(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };)+
|
||||
|
||||
impl $BitFlags {
|
||||
/// Returns an empty set of flags.
|
||||
|
|
@ -243,16 +240,14 @@ macro_rules! bitflags {
|
|||
bitflags! {
|
||||
$(#[$attr])*
|
||||
flags $BitFlags: $T {
|
||||
$(
|
||||
#[allow(non_uppercase_statics)]
|
||||
$(#[$Flag_attr])* static $Flag = $value
|
||||
),+
|
||||
$($(#[$Flag_attr])* static $Flag = $value),+
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[allow(non_uppercase_statics)]
|
||||
mod tests {
|
||||
use hash;
|
||||
use option::{Some, None};
|
||||
|
|
|
|||
|
|
@ -295,9 +295,9 @@ pub fn unlink(path: &Path) -> IoResult<()> {
|
|||
Ok(stat) => stat,
|
||||
Err(..) => return Err(e),
|
||||
};
|
||||
if stat.perm.intersects(io::UserWrite) { return Err(e) }
|
||||
if stat.perm.intersects(io::USER_WRITE) { return Err(e) }
|
||||
|
||||
match chmod(path, stat.perm | io::UserWrite) {
|
||||
match chmod(path, stat.perm | io::USER_WRITE) {
|
||||
Ok(()) => do_unlink(path),
|
||||
Err(..) => {
|
||||
// Try to put it back as we found it
|
||||
|
|
@ -501,10 +501,10 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
|
|||
/// use std::io;
|
||||
/// use std::io::fs;
|
||||
///
|
||||
/// fs::chmod(&Path::new("file.txt"), io::UserFile);
|
||||
/// fs::chmod(&Path::new("file.txt"), io::UserRead | io::UserWrite);
|
||||
/// fs::chmod(&Path::new("dir"), io::UserDir);
|
||||
/// fs::chmod(&Path::new("file.exe"), io::UserExec);
|
||||
/// fs::chmod(&Path::new("file.txt"), io::USER_FILE);
|
||||
/// fs::chmod(&Path::new("file.txt"), io::USER_READ | io::USER_WRITE);
|
||||
/// fs::chmod(&Path::new("dir"), io::USER_DIR);
|
||||
/// fs::chmod(&Path::new("file.exe"), io::USER_EXEC);
|
||||
/// ```
|
||||
///
|
||||
/// # Error
|
||||
|
|
@ -578,7 +578,7 @@ pub fn readlink(path: &Path) -> IoResult<Path> {
|
|||
/// use std::io::fs;
|
||||
///
|
||||
/// let p = Path::new("/some/dir");
|
||||
/// fs::mkdir(&p, io::UserRWX);
|
||||
/// fs::mkdir(&p, io::USER_RWX);
|
||||
/// ```
|
||||
///
|
||||
/// # Error
|
||||
|
|
@ -996,7 +996,7 @@ mod test {
|
|||
use os;
|
||||
use rand;
|
||||
let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
|
||||
check!(io::fs::mkdir(&ret, io::UserRWX));
|
||||
check!(io::fs::mkdir(&ret, io::USER_RWX));
|
||||
TempDir(ret)
|
||||
}
|
||||
|
||||
|
|
@ -1180,7 +1180,7 @@ mod test {
|
|||
fn file_test_stat_is_correct_on_is_dir() {
|
||||
let tmpdir = tmpdir();
|
||||
let filename = &tmpdir.join("file_stat_correct_on_is_dir");
|
||||
check!(mkdir(filename, io::UserRWX));
|
||||
check!(mkdir(filename, io::USER_RWX));
|
||||
let stat_res_fn = check!(stat(filename));
|
||||
assert!(stat_res_fn.kind == io::TypeDirectory);
|
||||
let stat_res_meth = check!(filename.stat());
|
||||
|
|
@ -1192,7 +1192,7 @@ mod test {
|
|||
fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
|
||||
let tmpdir = tmpdir();
|
||||
let dir = &tmpdir.join("fileinfo_false_on_dir");
|
||||
check!(mkdir(dir, io::UserRWX));
|
||||
check!(mkdir(dir, io::USER_RWX));
|
||||
assert!(dir.is_file() == false);
|
||||
check!(rmdir(dir));
|
||||
}
|
||||
|
|
@ -1212,7 +1212,7 @@ mod test {
|
|||
let tmpdir = tmpdir();
|
||||
let dir = &tmpdir.join("before_and_after_dir");
|
||||
assert!(!dir.exists());
|
||||
check!(mkdir(dir, io::UserRWX));
|
||||
check!(mkdir(dir, io::USER_RWX));
|
||||
assert!(dir.exists());
|
||||
assert!(dir.is_dir());
|
||||
check!(rmdir(dir));
|
||||
|
|
@ -1224,7 +1224,7 @@ mod test {
|
|||
use str;
|
||||
let tmpdir = tmpdir();
|
||||
let dir = &tmpdir.join("di_readdir");
|
||||
check!(mkdir(dir, io::UserRWX));
|
||||
check!(mkdir(dir, io::USER_RWX));
|
||||
let prefix = "foo";
|
||||
for n in range(0i,3) {
|
||||
let f = dir.join(format!("{}.txt", n));
|
||||
|
|
@ -1255,14 +1255,14 @@ mod test {
|
|||
fn file_test_walk_dir() {
|
||||
let tmpdir = tmpdir();
|
||||
let dir = &tmpdir.join("walk_dir");
|
||||
check!(mkdir(dir, io::UserRWX));
|
||||
check!(mkdir(dir, io::USER_RWX));
|
||||
|
||||
let dir1 = &dir.join("01/02/03");
|
||||
check!(mkdir_recursive(dir1, io::UserRWX));
|
||||
check!(mkdir_recursive(dir1, io::USER_RWX));
|
||||
check!(File::create(&dir1.join("04")));
|
||||
|
||||
let dir2 = &dir.join("11/12/13");
|
||||
check!(mkdir_recursive(dir2, io::UserRWX));
|
||||
check!(mkdir_recursive(dir2, io::USER_RWX));
|
||||
check!(File::create(&dir2.join("14")));
|
||||
|
||||
let mut files = check!(walk_dir(dir));
|
||||
|
|
@ -1282,7 +1282,7 @@ mod test {
|
|||
fn recursive_mkdir() {
|
||||
let tmpdir = tmpdir();
|
||||
let dir = tmpdir.join("d1/d2");
|
||||
check!(mkdir_recursive(&dir, io::UserRWX));
|
||||
check!(mkdir_recursive(&dir, io::USER_RWX));
|
||||
assert!(dir.is_dir())
|
||||
}
|
||||
|
||||
|
|
@ -1292,10 +1292,10 @@ mod test {
|
|||
let dir = tmpdir.join("d1");
|
||||
let file = dir.join("f1");
|
||||
|
||||
check!(mkdir_recursive(&dir, io::UserRWX));
|
||||
check!(mkdir_recursive(&dir, io::USER_RWX));
|
||||
check!(File::create(&file));
|
||||
|
||||
let result = mkdir_recursive(&file, io::UserRWX);
|
||||
let result = mkdir_recursive(&file, io::USER_RWX);
|
||||
|
||||
error!(result, "couldn't recursively mkdir");
|
||||
error!(result, "couldn't create directory");
|
||||
|
|
@ -1305,7 +1305,7 @@ mod test {
|
|||
|
||||
#[test]
|
||||
fn recursive_mkdir_slash() {
|
||||
check!(mkdir_recursive(&Path::new("/"), io::UserRWX));
|
||||
check!(mkdir_recursive(&Path::new("/"), io::USER_RWX));
|
||||
}
|
||||
|
||||
// FIXME(#12795) depends on lstat to work on windows
|
||||
|
|
@ -1318,8 +1318,8 @@ mod test {
|
|||
let dtt = dt.join("t");
|
||||
let d2 = tmpdir.join("d2");
|
||||
let canary = d2.join("do_not_delete");
|
||||
check!(mkdir_recursive(&dtt, io::UserRWX));
|
||||
check!(mkdir_recursive(&d2, io::UserRWX));
|
||||
check!(mkdir_recursive(&dtt, io::USER_RWX));
|
||||
check!(mkdir_recursive(&d2, io::USER_RWX));
|
||||
check!(File::create(&canary).write(b"foo"));
|
||||
check!(symlink(&d2, &dt.join("d2")));
|
||||
check!(rmdir_recursive(&d1));
|
||||
|
|
@ -1337,7 +1337,7 @@ mod test {
|
|||
|
||||
let mut dirpath = tmpdir.path().clone();
|
||||
dirpath.push(format!("test-가一ー你好"));
|
||||
check!(mkdir(&dirpath, io::UserRWX));
|
||||
check!(mkdir(&dirpath, io::USER_RWX));
|
||||
assert!(dirpath.is_dir());
|
||||
|
||||
let mut filepath = dirpath;
|
||||
|
|
@ -1355,7 +1355,7 @@ mod test {
|
|||
let tmpdir = tmpdir();
|
||||
let unicode = tmpdir.path();
|
||||
let unicode = unicode.join(format!("test-각丁ー再见"));
|
||||
check!(mkdir(&unicode, io::UserRWX));
|
||||
check!(mkdir(&unicode, io::USER_RWX));
|
||||
assert!(unicode.exists());
|
||||
assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
|
||||
}
|
||||
|
|
@ -1436,12 +1436,12 @@ mod test {
|
|||
let out = tmpdir.join("out.txt");
|
||||
|
||||
check!(File::create(&input));
|
||||
check!(chmod(&input, io::UserRead));
|
||||
check!(chmod(&input, io::USER_READ));
|
||||
check!(copy(&input, &out));
|
||||
assert!(!check!(out.stat()).perm.intersects(io::UserWrite));
|
||||
assert!(!check!(out.stat()).perm.intersects(io::USER_WRITE));
|
||||
|
||||
check!(chmod(&input, io::UserFile));
|
||||
check!(chmod(&out, io::UserFile));
|
||||
check!(chmod(&input, io::USER_FILE));
|
||||
check!(chmod(&out, io::USER_FILE));
|
||||
}
|
||||
|
||||
#[cfg(not(windows))] // FIXME(#10264) operation not permitted?
|
||||
|
|
@ -1517,16 +1517,16 @@ mod test {
|
|||
let file = tmpdir.join("in.txt");
|
||||
|
||||
check!(File::create(&file));
|
||||
assert!(check!(stat(&file)).perm.contains(io::UserWrite));
|
||||
check!(chmod(&file, io::UserRead));
|
||||
assert!(!check!(stat(&file)).perm.contains(io::UserWrite));
|
||||
assert!(check!(stat(&file)).perm.contains(io::USER_WRITE));
|
||||
check!(chmod(&file, io::USER_READ));
|
||||
assert!(!check!(stat(&file)).perm.contains(io::USER_WRITE));
|
||||
|
||||
match chmod(&tmpdir.join("foo"), io::UserRWX) {
|
||||
match chmod(&tmpdir.join("foo"), io::USER_RWX) {
|
||||
Ok(..) => fail!("wanted a failure"),
|
||||
Err(..) => {}
|
||||
}
|
||||
|
||||
check!(chmod(&file, io::UserFile));
|
||||
check!(chmod(&file, io::USER_FILE));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1677,7 +1677,7 @@ mod test {
|
|||
let tmpdir = tmpdir();
|
||||
let path = tmpdir.join("file");
|
||||
check!(File::create(&path));
|
||||
check!(chmod(&path, io::UserRead));
|
||||
check!(chmod(&path, io::USER_READ));
|
||||
check!(unlink(&path));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1803,35 +1803,93 @@ bitflags! {
|
|||
#[doc = "A set of permissions for a file or directory is represented"]
|
||||
#[doc = "by a set of flags which are or'd together."]
|
||||
flags FilePermission: u32 {
|
||||
static UserRead = 0o400,
|
||||
static UserWrite = 0o200,
|
||||
static UserExecute = 0o100,
|
||||
static GroupRead = 0o040,
|
||||
static GroupWrite = 0o020,
|
||||
static GroupExecute = 0o010,
|
||||
static OtherRead = 0o004,
|
||||
static OtherWrite = 0o002,
|
||||
static OtherExecute = 0o001,
|
||||
static USER_READ = 0o400,
|
||||
static USER_WRITE = 0o200,
|
||||
static USER_EXECUTE = 0o100,
|
||||
static GROUP_READ = 0o040,
|
||||
static GROUP_WRITE = 0o020,
|
||||
static GROUP_EXECUTE = 0o010,
|
||||
static OTHER_READ = 0o004,
|
||||
static OTHER_WRITE = 0o002,
|
||||
static OTHER_EXECUTE = 0o001,
|
||||
|
||||
static UserRWX = UserRead.bits | UserWrite.bits | UserExecute.bits,
|
||||
static GroupRWX = GroupRead.bits | GroupWrite.bits | GroupExecute.bits,
|
||||
static OtherRWX = OtherRead.bits | OtherWrite.bits | OtherExecute.bits,
|
||||
static USER_RWX = USER_READ.bits | USER_WRITE.bits | USER_EXECUTE.bits,
|
||||
static GROUP_RWX = GROUP_READ.bits | GROUP_WRITE.bits | GROUP_EXECUTE.bits,
|
||||
static OTHER_RWX = OTHER_READ.bits | OTHER_WRITE.bits | OTHER_EXECUTE.bits,
|
||||
|
||||
#[doc = "Permissions for user owned files, equivalent to 0644 on"]
|
||||
#[doc = "unix-like systems."]
|
||||
static UserFile = UserRead.bits | UserWrite.bits | GroupRead.bits | OtherRead.bits,
|
||||
static USER_FILE = USER_READ.bits | USER_WRITE.bits | GROUP_READ.bits | OTHER_READ.bits,
|
||||
|
||||
#[doc = "Permissions for user owned directories, equivalent to 0755 on"]
|
||||
#[doc = "unix-like systems."]
|
||||
static UserDir = UserRWX.bits | GroupRead.bits | GroupExecute.bits |
|
||||
OtherRead.bits | OtherExecute.bits,
|
||||
static USER_DIR = USER_RWX.bits | GROUP_READ.bits | GROUP_EXECUTE.bits |
|
||||
OTHER_READ.bits | OTHER_EXECUTE.bits,
|
||||
|
||||
#[doc = "Permissions for user owned executables, equivalent to 0755"]
|
||||
#[doc = "on unix-like systems."]
|
||||
static UserExec = UserDir.bits,
|
||||
static USER_EXEC = USER_DIR.bits,
|
||||
|
||||
#[doc = "All possible permissions enabled."]
|
||||
static AllPermissions = UserRWX.bits | GroupRWX.bits | OtherRWX.bits,
|
||||
static ALL_PERMISSIONS = USER_RWX.bits | GROUP_RWX.bits | OTHER_RWX.bits,
|
||||
|
||||
// Deprecated names
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use USER_READ instead"]
|
||||
static UserRead = USER_READ.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use USER_WRITE instead"]
|
||||
static UserWrite = USER_WRITE.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use USER_EXECUTE instead"]
|
||||
static UserExecute = USER_EXECUTE.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use GROUP_READ instead"]
|
||||
static GroupRead = GROUP_READ.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use GROUP_WRITE instead"]
|
||||
static GroupWrite = GROUP_WRITE.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use GROUP_EXECUTE instead"]
|
||||
static GroupExecute = GROUP_EXECUTE.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use OTHER_READ instead"]
|
||||
static OtherRead = OTHER_READ.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use OTHER_WRITE instead"]
|
||||
static OtherWrite = OTHER_WRITE.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use OTHER_EXECUTE instead"]
|
||||
static OtherExecute = OTHER_EXECUTE.bits,
|
||||
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use USER_RWX instead"]
|
||||
static UserRWX = USER_RWX.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use GROUP_RWX instead"]
|
||||
static GroupRWX = GROUP_RWX.bits,
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use OTHER_RWX instead"]
|
||||
static OtherRWX = OTHER_RWX.bits,
|
||||
|
||||
#[doc = "Deprecated: use `USER_FILE` instead."]
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use USER_FILE instead"]
|
||||
static UserFile = USER_FILE.bits,
|
||||
|
||||
#[doc = "Deprecated: use `USER_DIR` instead."]
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use USER_DIR instead"]
|
||||
static UserDir = USER_DIR.bits,
|
||||
#[doc = "Deprecated: use `USER_EXEC` instead."]
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use USER_EXEC instead"]
|
||||
static UserExec = USER_EXEC.bits,
|
||||
|
||||
#[doc = "Deprecated: use `ALL_PERMISSIONS` instead"]
|
||||
#[allow(non_uppercase_statics)]
|
||||
#[deprecated = "use ALL_PERMISSIONS instead"]
|
||||
static AllPermissions = ALL_PERMISSIONS.bits,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1954,13 +2012,13 @@ mod tests {
|
|||
fn test_show() {
|
||||
use super::*;
|
||||
|
||||
assert_eq!(format!("{}", UserRead), "0400".to_string());
|
||||
assert_eq!(format!("{}", UserFile), "0644".to_string());
|
||||
assert_eq!(format!("{}", UserExec), "0755".to_string());
|
||||
assert_eq!(format!("{}", UserRWX), "0700".to_string());
|
||||
assert_eq!(format!("{}", GroupRWX), "0070".to_string());
|
||||
assert_eq!(format!("{}", OtherRWX), "0007".to_string());
|
||||
assert_eq!(format!("{}", AllPermissions), "0777".to_string());
|
||||
assert_eq!(format!("{}", UserRead | UserWrite | OtherWrite), "0602".to_string());
|
||||
assert_eq!(format!("{}", USER_READ), "0400".to_string());
|
||||
assert_eq!(format!("{}", USER_FILE), "0644".to_string());
|
||||
assert_eq!(format!("{}", USER_EXEC), "0755".to_string());
|
||||
assert_eq!(format!("{}", USER_RWX), "0700".to_string());
|
||||
assert_eq!(format!("{}", GROUP_RWX), "0070".to_string());
|
||||
assert_eq!(format!("{}", OTHER_RWX), "0007".to_string());
|
||||
assert_eq!(format!("{}", ALL_PERMISSIONS), "0777".to_string());
|
||||
assert_eq!(format!("{}", USER_READ | USER_WRITE | OTHER_WRITE), "0602".to_string());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ impl TempDir {
|
|||
unsafe { CNT.fetch_add(1, atomic::SeqCst) },
|
||||
suffix);
|
||||
let p = tmpdir.join(filename);
|
||||
match fs::mkdir(&p, io::UserRWX) {
|
||||
match fs::mkdir(&p, io::USER_RWX) {
|
||||
Err(error) => {
|
||||
if attempts >= 1000 {
|
||||
return Err(error)
|
||||
|
|
|
|||
|
|
@ -91,10 +91,10 @@ use std::iter;
|
|||
|
||||
bitflags! {
|
||||
flags Restrictions: u8 {
|
||||
static Unrestricted = 0b0000,
|
||||
static RestrictionStmtExpr = 0b0001,
|
||||
static RestrictionNoBarOp = 0b0010,
|
||||
static RestrictionNoStructLiteral = 0b0100
|
||||
static UNRESTRICTED = 0b0000,
|
||||
static RESTRICTION_STMT_EXPR = 0b0001,
|
||||
static RESTRICTION_NO_BAR_OP = 0b0010,
|
||||
static RESTRICTION_NO_STRUCT_LITERAL = 0b0100
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -383,7 +383,7 @@ impl<'a> Parser<'a> {
|
|||
buffer_start: 0,
|
||||
buffer_end: 0,
|
||||
tokens_consumed: 0,
|
||||
restrictions: Unrestricted,
|
||||
restrictions: UNRESTRICTED,
|
||||
quote_depth: 0,
|
||||
obsolete_set: HashSet::new(),
|
||||
mod_path_stack: Vec::new(),
|
||||
|
|
@ -2242,7 +2242,7 @@ impl<'a> Parser<'a> {
|
|||
if self.token == token::LBRACE {
|
||||
// This is a struct literal, unless we're prohibited
|
||||
// from parsing struct literals here.
|
||||
if !self.restrictions.contains(RestrictionNoStructLiteral) {
|
||||
if !self.restrictions.contains(RESTRICTION_NO_STRUCT_LITERAL) {
|
||||
// It's a struct literal.
|
||||
self.bump();
|
||||
let mut fields = Vec::new();
|
||||
|
|
@ -2771,7 +2771,7 @@ impl<'a> Parser<'a> {
|
|||
// Prevent dynamic borrow errors later on by limiting the
|
||||
// scope of the borrows.
|
||||
if self.token == token::BINOP(token::OR) &&
|
||||
self.restrictions.contains(RestrictionNoBarOp) {
|
||||
self.restrictions.contains(RESTRICTION_NO_BAR_OP) {
|
||||
return lhs;
|
||||
}
|
||||
|
||||
|
|
@ -2812,7 +2812,7 @@ impl<'a> Parser<'a> {
|
|||
pub fn parse_assign_expr(&mut self) -> P<Expr> {
|
||||
let lo = self.span.lo;
|
||||
let lhs = self.parse_binops();
|
||||
let restrictions = self.restrictions & RestrictionNoStructLiteral;
|
||||
let restrictions = self.restrictions & RESTRICTION_NO_STRUCT_LITERAL;
|
||||
match self.token {
|
||||
token::EQ => {
|
||||
self.bump();
|
||||
|
|
@ -2850,7 +2850,7 @@ impl<'a> Parser<'a> {
|
|||
return self.parse_if_let_expr();
|
||||
}
|
||||
let lo = self.last_span.lo;
|
||||
let cond = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let cond = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let thn = self.parse_block();
|
||||
let mut els: Option<P<Expr>> = None;
|
||||
let mut hi = thn.span.hi;
|
||||
|
|
@ -2868,7 +2868,7 @@ impl<'a> Parser<'a> {
|
|||
self.expect_keyword(keywords::Let);
|
||||
let pat = self.parse_pat();
|
||||
self.expect(&token::EQ);
|
||||
let expr = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let expr = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let thn = self.parse_block();
|
||||
let (hi, els) = if self.eat_keyword(keywords::Else) {
|
||||
let expr = self.parse_else_expr();
|
||||
|
|
@ -2928,7 +2928,7 @@ impl<'a> Parser<'a> {
|
|||
let lo = self.last_span.lo;
|
||||
let pat = self.parse_pat();
|
||||
self.expect_keyword(keywords::In);
|
||||
let expr = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let expr = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let loop_block = self.parse_block();
|
||||
let hi = self.span.hi;
|
||||
|
||||
|
|
@ -2937,7 +2937,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
pub fn parse_while_expr(&mut self, opt_ident: Option<ast::Ident>) -> P<Expr> {
|
||||
let lo = self.last_span.lo;
|
||||
let cond = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let cond = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
let body = self.parse_block();
|
||||
let hi = body.span.hi;
|
||||
return self.mk_expr(lo, hi, ExprWhile(cond, body, opt_ident));
|
||||
|
|
@ -2952,7 +2952,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
fn parse_match_expr(&mut self) -> P<Expr> {
|
||||
let lo = self.last_span.lo;
|
||||
let discriminant = self.parse_expr_res(RestrictionNoStructLiteral);
|
||||
let discriminant = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL);
|
||||
self.commit_expr_expecting(&*discriminant, token::LBRACE);
|
||||
let mut arms: Vec<Arm> = Vec::new();
|
||||
while self.token != token::RBRACE {
|
||||
|
|
@ -2971,7 +2971,7 @@ impl<'a> Parser<'a> {
|
|||
guard = Some(self.parse_expr());
|
||||
}
|
||||
self.expect(&token::FAT_ARROW);
|
||||
let expr = self.parse_expr_res(RestrictionStmtExpr);
|
||||
let expr = self.parse_expr_res(RESTRICTION_STMT_EXPR);
|
||||
|
||||
let require_comma =
|
||||
!classify::expr_is_simple_block(&*expr)
|
||||
|
|
@ -2993,7 +2993,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
/// Parse an expression
|
||||
pub fn parse_expr(&mut self) -> P<Expr> {
|
||||
return self.parse_expr_res(Unrestricted);
|
||||
return self.parse_expr_res(UNRESTRICTED);
|
||||
}
|
||||
|
||||
/// Parse an expression, subject to the given restrictions
|
||||
|
|
@ -3290,9 +3290,9 @@ impl<'a> Parser<'a> {
|
|||
self.look_ahead(2, |t| {
|
||||
*t != token::COMMA && *t != token::RBRACKET
|
||||
}) {
|
||||
let start = self.parse_expr_res(RestrictionNoBarOp);
|
||||
let start = self.parse_expr_res(RESTRICTION_NO_BAR_OP);
|
||||
self.eat(&token::DOTDOTDOT);
|
||||
let end = self.parse_expr_res(RestrictionNoBarOp);
|
||||
let end = self.parse_expr_res(RESTRICTION_NO_BAR_OP);
|
||||
pat = PatRange(start, end);
|
||||
} else if is_plain_ident(&self.token) && !can_be_enum_or_struct {
|
||||
let id = self.parse_ident();
|
||||
|
|
@ -3593,7 +3593,7 @@ impl<'a> Parser<'a> {
|
|||
}
|
||||
|
||||
// Remainder are line-expr stmts.
|
||||
let e = self.parse_expr_res(RestrictionStmtExpr);
|
||||
let e = self.parse_expr_res(RESTRICTION_STMT_EXPR);
|
||||
P(spanned(lo, e.span.hi, StmtExpr(e, ast::DUMMY_NODE_ID)))
|
||||
}
|
||||
}
|
||||
|
|
@ -3602,7 +3602,7 @@ impl<'a> Parser<'a> {
|
|||
|
||||
/// Is this expression a successfully-parsed statement?
|
||||
fn expr_is_complete(&mut self, e: &Expr) -> bool {
|
||||
self.restrictions.contains(RestrictionStmtExpr) &&
|
||||
self.restrictions.contains(RESTRICTION_STMT_EXPR) &&
|
||||
!classify::expr_requires_semi_to_be_stmt(e)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ fn main() {
|
|||
let child_path = cwd.join(child_filename.clone());
|
||||
|
||||
// make a separate directory for the child
|
||||
drop(fs::mkdir(&cwd, io::UserRWX).is_ok());
|
||||
drop(fs::mkdir(&cwd, io::USER_RWX).is_ok());
|
||||
assert!(fs::copy(&my_path, &child_path).is_ok());
|
||||
|
||||
// run child
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ fn rename_directory() {
|
|||
let tmpdir = TempDir::new("rename_directory").ok().expect("rename_directory failed");
|
||||
let tmpdir = tmpdir.path();
|
||||
let old_path = tmpdir.join_many(["foo", "bar", "baz"]);
|
||||
fs::mkdir_recursive(&old_path, io::UserRWX);
|
||||
fs::mkdir_recursive(&old_path, io::USER_RWX);
|
||||
let test_file = &old_path.join("temp.txt");
|
||||
|
||||
/* Write the temp input file */
|
||||
|
|
@ -47,7 +47,7 @@ fn rename_directory() {
|
|||
assert_eq!(libc::fclose(ostream), (0u as libc::c_int));
|
||||
|
||||
let new_path = tmpdir.join_many(["quux", "blat"]);
|
||||
fs::mkdir_recursive(&new_path, io::UserRWX);
|
||||
fs::mkdir_recursive(&new_path, io::USER_RWX);
|
||||
fs::rename(&old_path, &new_path.join("newdir"));
|
||||
assert!(new_path.join("newdir").is_dir());
|
||||
assert!(new_path.join_many(["newdir", "temp.txt"]).exists());
|
||||
|
|
|
|||
|
|
@ -128,17 +128,17 @@ fn recursive_mkdir_rel() {
|
|||
let cwd = os::getcwd();
|
||||
println!("recursive_mkdir_rel: Making: {} in cwd {} [{:?}]", path.display(),
|
||||
cwd.display(), path.exists());
|
||||
fs::mkdir_recursive(&path, io::UserRWX);
|
||||
fs::mkdir_recursive(&path, io::USER_RWX);
|
||||
assert!(path.is_dir());
|
||||
fs::mkdir_recursive(&path, io::UserRWX);
|
||||
fs::mkdir_recursive(&path, io::USER_RWX);
|
||||
assert!(path.is_dir());
|
||||
}
|
||||
|
||||
fn recursive_mkdir_dot() {
|
||||
let dot = Path::new(".");
|
||||
fs::mkdir_recursive(&dot, io::UserRWX);
|
||||
fs::mkdir_recursive(&dot, io::USER_RWX);
|
||||
let dotdot = Path::new("..");
|
||||
fs::mkdir_recursive(&dotdot, io::UserRWX);
|
||||
fs::mkdir_recursive(&dotdot, io::USER_RWX);
|
||||
}
|
||||
|
||||
fn recursive_mkdir_rel_2() {
|
||||
|
|
@ -146,20 +146,20 @@ fn recursive_mkdir_rel_2() {
|
|||
let cwd = os::getcwd();
|
||||
println!("recursive_mkdir_rel_2: Making: {} in cwd {} [{:?}]", path.display(),
|
||||
cwd.display(), path.exists());
|
||||
fs::mkdir_recursive(&path, io::UserRWX);
|
||||
fs::mkdir_recursive(&path, io::USER_RWX);
|
||||
assert!(path.is_dir());
|
||||
assert!(path.dir_path().is_dir());
|
||||
let path2 = Path::new("quux/blat");
|
||||
println!("recursive_mkdir_rel_2: Making: {} in cwd {}", path2.display(),
|
||||
cwd.display());
|
||||
fs::mkdir_recursive(&path2, io::UserRWX);
|
||||
fs::mkdir_recursive(&path2, io::USER_RWX);
|
||||
assert!(path2.is_dir());
|
||||
assert!(path2.dir_path().is_dir());
|
||||
}
|
||||
|
||||
// Ideally this would be in core, but needs TempFile
|
||||
pub fn test_rmdir_recursive_ok() {
|
||||
let rwx = io::UserRWX;
|
||||
let rwx = io::USER_RWX;
|
||||
|
||||
let tmpdir = TempDir::new("test").ok().expect("test_rmdir_recursive_ok: \
|
||||
couldn't create temp dir");
|
||||
|
|
|
|||
Loading…
Reference in New Issue