Auto merge of #2607 - RalfJung:rustup, r=RalfJung

Rustup

Author: bors

bench-cargo-miri/serde2/src/main.rs

@@ -5,6 +5,7 @@ use serde::Deserialize;
 use std::thread;
 
 #[derive(Deserialize)]
+#[allow(unused)]
 struct DeriveStruct {
     buffer: Vec<i16>,
 }

rust-version

@@ -1 +1 @@
-edabf59ca4646b3fc1a961c26431215001043f6a
+b1ab3b738ac718da74cd4aa0bb7f362d0adbdf84

src/shims/windows/foreign_items.rs

@@ -343,16 +343,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // FIXME: we should set last_error, but to what?
                 this.write_null(dest)?;
             }
-            "GetConsoleMode" => {
-                // Windows "isatty" (in libtest) needs this, so we fake it.
-                let [console, mode] =
-                    this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
-                this.read_scalar(console)?.to_machine_isize(this)?;
-                this.deref_operand(mode)?;
-                // Indicate an error.
-                // FIXME: we should set last_error, but to what?
-                this.write_null(dest)?;
-            }
             "GetStdHandle" => {
                 let [which] =
                     this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
@@ -404,14 +394,14 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 let [] = this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
                 // Just fake a HANDLE
                 // It's fine to not use the Handle type here because its a stub
-                this.write_scalar(Scalar::from_machine_isize(1, this), dest)?;
+                this.write_int(1, dest)?;
             }
             "GetModuleHandleA" if this.frame_in_std() => {
                 #[allow(non_snake_case)]
                 let [_lpModuleName] =
                     this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
                 // We need to return something non-null here to make `compat_fn!` work.
-                this.write_scalar(Scalar::from_machine_isize(1, this), dest)?;
+                this.write_int(1, dest)?;
             }
             "SetConsoleTextAttribute" if this.frame_in_std() => {
                 #[allow(non_snake_case)]
@@ -420,24 +410,39 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // Pretend these does not exist / nothing happened, by returning zero.
                 this.write_null(dest)?;
             }
+            "GetConsoleMode" if this.frame_in_std() => {
+                let [console, mode] =
+                    this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
+                this.read_scalar(console)?.to_machine_isize(this)?;
+                this.deref_operand(mode)?;
+                // Indicate an error.
+                this.write_null(dest)?;
+            }
+            "GetFileInformationByHandleEx" if this.frame_in_std() => {
+                #[allow(non_snake_case)]
+                let [_hFile, _FileInformationClass, _lpFileInformation, _dwBufferSize] =
+                    this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
+                // Just make it fail.
+                this.write_null(dest)?;
+            }
             "AddVectoredExceptionHandler" if this.frame_in_std() => {
                 #[allow(non_snake_case)]
                 let [_First, _Handler] =
                     this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
                 // Any non zero value works for the stdlib. This is just used for stack overflows anyway.
-                this.write_scalar(Scalar::from_machine_usize(1, this), dest)?;
+                this.write_int(1, dest)?;
             }
             "SetThreadStackGuarantee" if this.frame_in_std() => {
                 #[allow(non_snake_case)]
                 let [_StackSizeInBytes] =
                     this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
                 // Any non zero value works for the stdlib. This is just used for stack overflows anyway.
-                this.write_scalar(Scalar::from_u32(1), dest)?;
+                this.write_int(1, dest)?;
             }
             "GetCurrentProcessId" if this.frame_in_std() => {
                 let [] = this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
                 let result = this.GetCurrentProcessId()?;
-                this.write_scalar(Scalar::from_u32(result), dest)?;
+                this.write_int(result, dest)?;
             }
             // this is only callable from std because we know that std ignores the return value
             "SwitchToThread" if this.frame_in_std() => {

tests/pass-dep/shims/fs.rs

@@ -4,7 +4,8 @@
 #![feature(io_error_more)]
 #![feature(io_error_uncategorized)]
 
-use std::ffi::CString;
+use std::collections::HashMap;
+use std::ffi::{CString, OsString};
 use std::fs::{
     create_dir, read_dir, read_link, remove_dir, remove_dir_all, remove_file, rename, File,
     OpenOptions,
@@ -394,21 +395,34 @@ fn test_directory() {
     // Creating a directory when it already exists should fail.
     assert_eq!(ErrorKind::AlreadyExists, create_dir(&dir_path).unwrap_err().kind());
 
-    // Create some files inside the directory
+    // Create some files and dirs inside the directory
     let path_1 = dir_path.join("test_file_1");
     drop(File::create(&path_1).unwrap());
     let path_2 = dir_path.join("test_file_2");
     drop(File::create(&path_2).unwrap());
-    // Test that the files are present inside the directory
-    let dir_iter = read_dir(&dir_path).unwrap();
-    let mut file_names = dir_iter.map(|e| e.unwrap().file_name()).collect::<Vec<_>>();
-    file_names.sort_unstable();
-    assert_eq!(file_names, vec!["test_file_1", "test_file_2"]);
+    let dir_1 = dir_path.join("test_dir_1");
+    create_dir(&dir_1).unwrap();
+    // Test that read_dir metadata calls succeed
+    assert_eq!(
+        HashMap::from([
+            (OsString::from("test_file_1"), true),
+            (OsString::from("test_file_2"), true),
+            (OsString::from("test_dir_1"), false)
+        ]),
+        read_dir(&dir_path)
+            .unwrap()
+            .map(|e| {
+                let e = e.unwrap();
+                (e.file_name(), e.metadata().unwrap().is_file())
+            })
+            .collect::<HashMap<_, _>>()
+    );
     // Deleting the directory should fail, since it is not empty.
     assert_eq!(ErrorKind::DirectoryNotEmpty, remove_dir(&dir_path).unwrap_err().kind());
     // Clean up the files in the directory
     remove_file(&path_1).unwrap();
     remove_file(&path_2).unwrap();
+    remove_dir(&dir_1).unwrap();
     // Now there should be nothing left in the directory.
     let dir_iter = read_dir(&dir_path).unwrap();
     let file_names = dir_iter.map(|e| e.unwrap().file_name()).collect::<Vec<_>>();