uefi: Rename into_with* to to_result_with*

Slightly more verbose, but easier to read. Also fits better with a `to_result`
function (in the next commit).

Author: nicholasbishop

uefi/src/mem.rs

@@ -146,7 +146,7 @@ mod tests {
 
         if buf.len() < required_size {
             // We can use an zero-length buffer to find the required size.
-            return Status::BUFFER_TOO_SMALL.into_with(|| panic!(), |_| Some(required_size));
+            return Status::BUFFER_TOO_SMALL.to_result_with(|| panic!(), |_| Some(required_size));
         };
 
         // assert alignment

uefi/src/proto/console/gop.rs

@@ -94,7 +94,7 @@ impl GraphicsOutput {
         let mut info_sz = 0;
         let mut info = ptr::null();
 
-        (self.query_mode)(self, index, &mut info_sz, &mut info).into_with_val(|| {
+        (self.query_mode)(self, index, &mut info_sz, &mut info).to_result_with_val(|| {
             let info = unsafe { *info };
             Mode {
                 index,

uefi/src/proto/console/pointer/mod.rs

@@ -40,7 +40,7 @@ impl Pointer {
 
         match (self.get_state)(self, pointer_state.as_mut_ptr()) {
             Status::NOT_READY => Ok(None),
-            other => other.into_with_val(|| unsafe { Some(pointer_state.assume_init()) }),
+            other => other.to_result_with_val(|| unsafe { Some(pointer_state.assume_init()) }),
         }
     }
 

uefi/src/proto/console/serial.rs

@@ -77,7 +77,7 @@ impl Serial {
     /// Retrieve the device's current control bits.
     pub fn get_control_bits(&self) -> Result<ControlBits> {
         let mut bits = ControlBits::empty();
-        (self.get_control_bits)(self, &mut bits).into_with_val(|| bits)
+        (self.get_control_bits)(self, &mut bits).to_result_with_val(|| bits)
     }
 
     /// Sets the device's new control bits.
@@ -95,7 +95,7 @@ impl Serial {
     /// bytes were actually read from the device.
     pub fn read(&mut self, data: &mut [u8]) -> Result<(), usize> {
         let mut buffer_size = data.len();
-        unsafe { (self.read)(self, &mut buffer_size, data.as_mut_ptr()) }.into_with(
+        unsafe { (self.read)(self, &mut buffer_size, data.as_mut_ptr()) }.to_result_with(
             || debug_assert_eq!(buffer_size, data.len()),
             |_| buffer_size,
         )
@@ -108,7 +108,7 @@ impl Serial {
     /// were actually written to the device.
     pub fn write(&mut self, data: &[u8]) -> Result<(), usize> {
         let mut buffer_size = data.len();
-        unsafe { (self.write)(self, &mut buffer_size, data.as_ptr()) }.into_with(
+        unsafe { (self.write)(self, &mut buffer_size, data.as_ptr()) }.to_result_with(
             || debug_assert_eq!(buffer_size, data.len()),
             |_| buffer_size,
         )

uefi/src/proto/console/text/input.rs

@@ -77,7 +77,7 @@ impl Input {
 
         match (self.read_key_stroke)(self, key.as_mut_ptr()) {
             Status::NOT_READY => Ok(None),
-            other => other.into_with_val(|| Some(unsafe { key.assume_init() }.into())),
+            other => other.to_result_with_val(|| Some(unsafe { key.assume_init() }.into())),
         }
     }
 

uefi/src/proto/console/text/output.rs

@@ -79,7 +79,7 @@ impl Output {
     pub fn test_string(&mut self, string: &CStr16) -> Result<bool> {
         match unsafe { (self.test_string)(self, string.as_ptr()) } {
             Status::UNSUPPORTED => Ok(false),
-            other => other.into_with_val(|| true),
+            other => other.to_result_with_val(|| true),
         }
     }
 
@@ -106,7 +106,8 @@ impl Output {
     /// alternative to this method.
     fn query_mode(&self, index: usize) -> Result<(usize, usize)> {
         let (mut columns, mut rows) = (0, 0);
-        (self.query_mode)(self, index, &mut columns, &mut rows).into_with_val(|| (columns, rows))
+        (self.query_mode)(self, index, &mut columns, &mut rows)
+            .to_result_with_val(|| (columns, rows))
     }
 
     /// Returns the current text mode.

uefi/src/proto/debug/mod.rs

@@ -210,7 +210,7 @@ impl DebugPort {
             &mut buffer_size,
             data.as_ptr().cast::<c_void>(),
         )
-        .into_with(
+        .to_result_with(
             || debug_assert_eq!(buffer_size, data.len()),
             |_| buffer_size,
         )
@@ -228,7 +228,7 @@ impl DebugPort {
             &mut buffer_size,
             data.as_mut_ptr().cast::<c_void>(),
         )
-        .into_with(
+        .to_result_with(
             || debug_assert_eq!(buffer_size, data.len()),
             |_| buffer_size,
         )

uefi/src/proto/driver/component_name.rs

@@ -62,7 +62,7 @@ impl ComponentName1 {
         let language = language_to_cstr(language)?;
         let mut driver_name = ptr::null();
         unsafe { (self.get_driver_name)(self, language.as_ptr(), &mut driver_name) }
-            .into_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
+            .to_result_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
     }
 
     /// Get the human-readable name of a controller in the given language.
@@ -87,7 +87,7 @@ impl ComponentName1 {
                 &mut driver_name,
             )
         }
-        .into_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
+        .to_result_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
     }
 }
 
@@ -142,7 +142,7 @@ impl ComponentName2 {
         let language = language_to_cstr(language)?;
         let mut driver_name = ptr::null();
         unsafe { (self.get_driver_name)(self, language.as_ptr(), &mut driver_name) }
-            .into_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
+            .to_result_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
     }
 
     /// Get the human-readable name of a controller in the given language.
@@ -167,7 +167,7 @@ impl ComponentName2 {
                 &mut driver_name,
             )
         }
-        .into_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
+        .to_result_with_val(|| unsafe { CStr16::from_ptr(driver_name.cast()) })
     }
 }
 

uefi/src/proto/media/file/mod.rs

@@ -76,7 +76,7 @@ pub trait File: Sized {
                 attributes,
             )
         }
-        .into_with_val(|| unsafe { FileHandle::new(ptr) })
+        .to_result_with_val(|| unsafe { FileHandle::new(ptr) })
     }
 
     /// Close this file handle. Same as dropping this structure.
@@ -128,7 +128,7 @@ pub trait File: Sized {
                 buffer.as_mut_ptr(),
             )
         }
-        .into_with(
+        .to_result_with(
             || unsafe { Info::from_uefi(buffer.as_mut_ptr().cast::<c_void>()) },
             |s| {
                 if s == Status::BUFFER_TOO_SMALL {

uefi/src/proto/media/file/regular.rs

@@ -44,7 +44,7 @@ impl RegularFile {
         let status =
             unsafe { (self.imp().read)(self.imp(), &mut buffer_size, buffer.as_mut_ptr()) };
 
-        status.into_with(
+        status.to_result_with(
             || buffer_size,
             |s| {
                 if s == Status::BUFFER_TOO_SMALL {
@@ -81,7 +81,7 @@ impl RegularFile {
     pub fn write(&mut self, buffer: &[u8]) -> Result<(), usize> {
         let mut buffer_size = buffer.len();
         unsafe { (self.imp().write)(self.imp(), &mut buffer_size, buffer.as_ptr()) }
-            .into_with_err(|_| buffer_size)
+            .to_result_with_err(|_| buffer_size)
     }
 
     /// Get the file's current position
@@ -93,7 +93,7 @@ impl RegularFile {
     /// * [`uefi::Status::DEVICE_ERROR`]
     pub fn get_position(&mut self) -> Result<u64> {
         let mut pos = 0u64;
-        (self.imp().get_position)(self.imp(), &mut pos).into_with_val(|| pos)
+        (self.imp().get_position)(self.imp(), &mut pos).to_result_with_val(|| pos)
     }
 
     /// Sets the file's current position

uefi/src/proto/media/fs.rs

@@ -49,6 +49,6 @@ impl SimpleFileSystem {
     pub fn open_volume(&mut self) -> Result<Directory> {
         let mut ptr = ptr::null_mut();
         (self.open_volume)(self, &mut ptr)
-            .into_with_val(|| unsafe { Directory::new(FileHandle::new(ptr)) })
+            .to_result_with_val(|| unsafe { Directory::new(FileHandle::new(ptr)) })
     }
 }

uefi/src/proto/network/pxe.rs

@@ -160,7 +160,7 @@ impl BaseCode {
                 false,
             )
         };
-        status.into_with_val(|| buffer_size)
+        status.to_result_with_val(|| buffer_size)
     }
 
     /// Reads a file located on a TFTP server.
@@ -191,7 +191,7 @@ impl BaseCode {
                 dont_use_buffer,
             )
         };
-        status.into_with_val(|| buffer_size)
+        status.to_result_with_val(|| buffer_size)
     }
 
     /// Writes to a file located on a TFTP server.
@@ -320,7 +320,7 @@ impl BaseCode {
                 false,
             )
         };
-        status.into_with_val(|| buffer_size)
+        status.to_result_with_val(|| buffer_size)
     }
 
     /// Reads a file located on a MTFTP server.
@@ -352,7 +352,7 @@ impl BaseCode {
                 dont_use_buffer,
             )
         };
-        status.into_with_val(|| buffer_size)
+        status.to_result_with_val(|| buffer_size)
     }
 
     /// Reads a directory listing of a directory on a MTFTP server.
@@ -522,7 +522,7 @@ impl BaseCode {
                 (&mut buffer[0] as *mut u8).cast(),
             )
         };
-        status.into_with_val(|| buffer_size)
+        status.to_result_with_val(|| buffer_size)
     }
 
     /// Updates the IP receive filters of a network device and enables software

uefi/src/proto/network/snp.rs

@@ -152,14 +152,14 @@ impl SimpleNetwork {
         let mut stats_table: NetworkStats = Default::default();
         let mut stats_size = core::mem::size_of::<NetworkStats>();
         let status = (self.statistics)(self, false, Some(&mut stats_size), Some(&mut stats_table));
-        status.into_with_val(|| stats_table)
+        status.to_result_with_val(|| stats_table)
     }
 
     /// Convert a multicast IP address to a multicast HW MAC Address.
     pub fn mcast_ip_to_mac(&self, ipv6: bool, ip: IpAddress) -> Result<MacAddress> {
         let mut mac_address = MacAddress([0; 32]);
         let status = (self.mcast_ip_to_mac)(self, ipv6, &ip, &mut mac_address);
-        status.into_with_val(|| mac_address)
+        status.to_result_with_val(|| mac_address)
     }
 
     /// Perform read operations on the NVRAM device attached to
@@ -192,15 +192,15 @@ impl SimpleNetwork {
     pub fn get_interrupt_status(&self) -> Result<InterruptStatus> {
         let mut interrupt_status = InterruptStatus::empty();
         let status = (self.get_status)(self, Some(&mut interrupt_status), None);
-        status.into_with_val(|| interrupt_status)
+        status.to_result_with_val(|| interrupt_status)
     }
 
     /// Read the current recycled transmit buffer status from a
     /// network interface.
     pub fn get_recycled_transmit_buffer_status(&self) -> Result<Option<NonNull<u8>>> {
         let mut tx_buf: *mut c_void = ptr::null_mut();
         let status = (self.get_status)(self, None, Some(&mut tx_buf));
-        status.into_with_val(|| NonNull::new(tx_buf.cast()))
+        status.to_result_with_val(|| NonNull::new(tx_buf.cast()))
     }
 
     /// Place a packet in the transmit queue of a network interface.
@@ -245,7 +245,7 @@ impl SimpleNetwork {
             dest_addr,
             protocol,
         );
-        status.into_with_val(|| buffer_size)
+        status.to_result_with_val(|| buffer_size)
     }
 
     /// Event that fires once a packet is available to be received.

uefi/src/proto/pi/mp.rs

@@ -144,13 +144,13 @@ impl MpServices {
         let mut total: usize = 0;
         let mut enabled: usize = 0;
         (self.get_number_of_processors)(self, &mut total, &mut enabled)
-            .into_with_val(|| ProcessorCount { total, enabled })
+            .to_result_with_val(|| ProcessorCount { total, enabled })
     }
 
     /// Gets detailed information on the requested processor at the instant this call is made.
     pub fn get_processor_info(&self, processor_number: usize) -> Result<ProcessorInformation> {
         let mut pi: ProcessorInformation = Default::default();
-        (self.get_processor_info)(self, processor_number, &mut pi).into_with_val(|| pi)
+        (self.get_processor_info)(self, processor_number, &mut pi).to_result_with_val(|| pi)
     }
 
     /// Executes provided function on all APs in blocking mode.
@@ -233,6 +233,6 @@ impl MpServices {
     /// Gets the handle number of the caller processor.
     pub fn who_am_i(&self) -> Result<usize> {
         let mut processor_number: usize = 0;
-        (self.who_am_i)(self, &mut processor_number).into_with_val(|| processor_number)
+        (self.who_am_i)(self, &mut processor_number).to_result_with_val(|| processor_number)
     }
 }

uefi/src/proto/rng.rs

@@ -61,19 +61,20 @@ impl Rng {
         let mut algorithm_list_size = algorithm_list.len() * mem::size_of::<RngAlgorithmType>();
 
         unsafe {
-            (self.get_info)(self, &mut algorithm_list_size, algorithm_list.as_mut_ptr()).into_with(
-                || {
-                    let len = algorithm_list_size / mem::size_of::<RngAlgorithmType>();
-                    &algorithm_list[..len]
-                },
-                |status| {
-                    if status == Status::BUFFER_TOO_SMALL {
-                        Some(algorithm_list_size)
-                    } else {
-                        None
-                    }
-                },
-            )
+            (self.get_info)(self, &mut algorithm_list_size, algorithm_list.as_mut_ptr())
+                .to_result_with(
+                    || {
+                        let len = algorithm_list_size / mem::size_of::<RngAlgorithmType>();
+                        &algorithm_list[..len]
+                    },
+                    |status| {
+                        if status == Status::BUFFER_TOO_SMALL {
+                            Some(algorithm_list_size)
+                        } else {
+                            None
+                        }
+                    },
+                )
         }
     }
 

uefi/src/proto/security/memory_protection.rs

@@ -56,7 +56,7 @@ impl MemoryProtection {
         let (base_address, length) = range_to_base_and_len(byte_region);
         unsafe {
             (self.get_memory_attributes)(self, base_address, length, &mut attributes)
-                .into_with_val(|| attributes)
+                .to_result_with_val(|| attributes)
         }
     }
 

uefi/src/proto/tcg/v2.rs

@@ -614,7 +614,7 @@ impl Tcg {
     /// Get information about the protocol and TPM device.
     pub fn get_capability(&mut self) -> Result<BootServiceCapability> {
         let mut capability = BootServiceCapability::default();
-        unsafe { (self.get_capability)(self, &mut capability).into_with_val(|| capability) }
+        unsafe { (self.get_capability)(self, &mut capability).to_result_with_val(|| capability) }
     }
 
     /// Get the V1 event log. This provides events in the same format as a V1
@@ -739,7 +739,7 @@ impl Tcg {
 
         let status = unsafe { (self.get_active_pcr_banks)(self, &mut active_pcr_banks) };
 
-        status.into_with_val(|| active_pcr_banks)
+        status.to_result_with_val(|| active_pcr_banks)
     }
 
     /// Set the active PCR banks. Each bank corresponds to a hash
@@ -766,7 +766,7 @@ impl Tcg {
             (self.get_result_of_set_active_pcr_banks)(self, &mut operation_present, &mut response)
         };
 
-        status.into_with_val(|| {
+        status.to_result_with_val(|| {
             if operation_present == 0 {
                 None
             } else {