diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index b48ccfc43742d..7dcfa1a931530 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -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, diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 0708fdc6eba1e..adae71ddad4c6 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -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 \ diff --git a/src/librustc/middle/save/mod.rs b/src/librustc/middle/save/mod.rs index c956c2d2b006b..aa230496d9423 100644 --- a/src/librustc/middle/save/mod.rs +++ b/src/librustc/middle/save/mod.rs @@ -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()), _ => (), diff --git a/src/librustc_back/fs.rs b/src/librustc_back/fs.rs index 756516d17a2ea..a062c68d998a9 100644 --- a/src/librustc_back/fs.rs +++ b/src/librustc_back/fs.rs @@ -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(); diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 8668e684c2d64..cef44c2b26261 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -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(()) } diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index 391d099de87c6..7966040ed7bc6 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -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}; diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index f777460e66a45..24cc53e784e65 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -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 { /// 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::())); - 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)); } } diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index c645e5240b886..e52a67cc32f3e 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -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 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_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 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()); } } diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs index 9d6713b25b724..1d8aedb172bae 100644 --- a/src/libstd/io/tempfile.rs +++ b/src/libstd/io/tempfile.rs @@ -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) diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 4c877c0b101e0..6ab14417265c8 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -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 { 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> = 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) -> P { 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 { 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 = 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 { - 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) } diff --git a/src/test/run-pass/process-spawn-with-unicode-params.rs b/src/test/run-pass/process-spawn-with-unicode-params.rs index de86ca179b7d7..f04bc62bf7f39 100644 --- a/src/test/run-pass/process-spawn-with-unicode-params.rs +++ b/src/test/run-pass/process-spawn-with-unicode-params.rs @@ -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 diff --git a/src/test/run-pass/rename-directory.rs b/src/test/run-pass/rename-directory.rs index e1918335a1478..43a62524717db 100644 --- a/src/test/run-pass/rename-directory.rs +++ b/src/test/run-pass/rename-directory.rs @@ -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()); diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs index 322bdc8f3bb77..64fd96bd924b9 100644 --- a/src/test/run-pass/tempfile.rs +++ b/src/test/run-pass/tempfile.rs @@ -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");