Consistent allocation failure handling

.github/workflows/clippy.yml

@@ -136,8 +136,6 @@ jobs:
  run: cargo clippy -p test_array
  - name: Clippy test_bcrypt
  run: cargo clippy -p test_bcrypt
- - name: Clippy test_bstr
- run: cargo clippy -p test_bstr
  - name: Clippy test_calling_convention
  run: cargo clippy -p test_calling_convention
  - name: Clippy test_cfg_generic

.github/workflows/test.yml

@@ -162,8 +162,6 @@ jobs:
  run: cargo test -p test_array --target ${{ matrix.target }} ${{ matrix.etc }}
  - name: Test test_bcrypt
  run: cargo test -p test_bcrypt --target ${{ matrix.target }} ${{ matrix.etc }}
- - name: Test test_bstr
- run: cargo test -p test_bstr --target ${{ matrix.target }} ${{ matrix.etc }}
  - name: Test test_calling_convention
  run: cargo test -p test_calling_convention --target ${{ matrix.target }} ${{ matrix.etc }}
  - name: Test test_cfg_generic
@@ -258,10 +256,10 @@ jobs:
  run: cargo test -p test_standalone --target ${{ matrix.target }} ${{ matrix.etc }}
  - name: Test test_string_param
  run: cargo test -p test_string_param --target ${{ matrix.target }} ${{ matrix.etc }}
- - name: Clean
- run: cargo clean
  - name: Test test_strings
  run: cargo test -p test_strings --target ${{ matrix.target }} ${{ matrix.etc }}
+ - name: Clean
+ run: cargo clean
  - name: Test test_structs
  run: cargo test -p test_structs --target ${{ matrix.target }} ${{ matrix.etc }}
  - name: Test test_sys

crates/libs/core/src/imp/com_bindings.rs

@@ -43,7 +43,6 @@ pub const CO_E_NOTINITIALIZED: windows_core::HRESULT = windows_core::HRESULT(0x8
 pub const E_BOUNDS: windows_core::HRESULT = windows_core::HRESULT(0x8000000B_u32 as _);
 pub const E_INVALIDARG: windows_core::HRESULT = windows_core::HRESULT(0x80070057_u32 as _);
 pub const E_NOINTERFACE: windows_core::HRESULT = windows_core::HRESULT(0x80004002_u32 as _);
-pub const E_OUTOFMEMORY: windows_core::HRESULT = windows_core::HRESULT(0x8007000E_u32 as _);
 pub const E_POINTER: windows_core::HRESULT = windows_core::HRESULT(0x80004003_u32 as _);
 windows_core::imp::define_interface!(
  IAgileObject,

crates/libs/registry/src/key.rs

@@ -175,7 +175,7 @@ impl Key {
  return Err(invalid_data());
  }
 
- let mut value = HStringBuilder::new(len / 2)?;
+ let mut value = HStringBuilder::new(len / 2);
  unsafe { self.raw_get_bytes(name.as_raw(), value.as_bytes_mut())? };
  value.trim_end();
  Ok(value.into())

crates/libs/registry/src/value.rs

@@ -111,7 +111,7 @@ impl TryFrom<Value> for HSTRING {
  type Error = Error;
  fn try_from(from: Value) -> Result<Self> {
  match from.ty {
- Type::String | Type::ExpandString => Ok(Self::from_wide(trim(from.data.as_wide()))?),
+ Type::String | Type::ExpandString => Ok(Self::from_wide(trim(from.data.as_wide()))),
  _ => Err(invalid_data()),
  }
  }

crates/libs/strings/Cargo.toml

@@ -21,11 +21,6 @@ targets = []
 version = "0.52.6"
 path = "../targets"
 
-[dependencies.windows-result]
-version = "0.2.0"
-path = "../result"
-default-features = false
-
 [features]
 default = ["std"]
 std = []

crates/libs/strings/readme.md

@@ -21,16 +21,14 @@ use windows_strings::*;
 const A: PCSTR = s!("ansi");
 const W: PCWSTR = w!("wide");
 
-fn main() -> Result<()> {
+fn main() {
  let b = BSTR::from("bstr");
  let h = HSTRING::from("hstring");
 
  assert_eq!(b, "bstr");
  assert_eq!(h, "hstring");
 
- assert_eq!(unsafe { A.to_string()? }, "ansi");
- assert_eq!(unsafe { W.to_string()? }, "wide");
-
- Ok(())
+ assert_eq!(unsafe { A.to_string().unwrap() }, "ansi");
+ assert_eq!(unsafe { W.to_string().unwrap() }, "wide");
 }
 ```

crates/libs/strings/src/bindings.rs

@@ -13,8 +13,6 @@ windows_targets::link!("oleaut32.dll" "system" fn SysFreeString(bstrstring : BST
 windows_targets::link!("oleaut32.dll" "system" fn SysStringLen(pbstr : BSTR) -> u32);
 pub type BOOL = i32;
 pub type BSTR = *const u16;
-pub const E_OUTOFMEMORY: HRESULT = 0x8007000E_u32 as _;
 pub type HANDLE = *mut core::ffi::c_void;
 pub type HEAP_FLAGS = u32;
-pub type HRESULT = i32;
 pub type PCWSTR = *const u16;

crates/libs/strings/src/bstr.rs

@@ -43,23 +43,23 @@ impl BSTR {
  }
 
  /// Create a `BSTR` from a slice of 16 bit characters (wchars).
- pub fn from_wide(value: &[u16]) -> Result<Self> {
+ pub fn from_wide(value: &[u16]) -> Self {
  if value.is_empty() {
- return Ok(Self::new());
+ return Self::new();
  }
 
  let result = unsafe {
  Self(bindings::SysAllocStringLen(
  value.as_ptr(),
- value.len().try_into()?,
+ value.len().try_into().unwrap(),
  ))
  };
 
  if result.is_empty() {
- Err(Error::from_hresult(HRESULT(bindings::E_OUTOFMEMORY)))
- } else {
- Ok(result)
+ panic!("allocation failed");
  }
+
+ result
  }
 
  /// # Safety
@@ -77,14 +77,14 @@ impl BSTR {
 
 impl Clone for BSTR {
  fn clone(&self) -> Self {
- Self::from_wide(self.as_wide()).unwrap()
+ Self::from_wide(self.as_wide())
  }
 }
 
 impl From<&str> for BSTR {
  fn from(value: &str) -> Self {
  let value: alloc::vec::Vec<u16> = value.encode_utf16().collect();
- Self::from_wide(&value).unwrap()
+ Self::from_wide(&value)
  }
 }
 

crates/libs/strings/src/hstring.rs

@@ -44,7 +44,7 @@ impl HSTRING {
  }
 
  /// Create a `HSTRING` from a slice of 16 bit characters (wchars).
- pub fn from_wide(value: &[u16]) -> Result<Self> {
+ pub fn from_wide(value: &[u16]) -> Self {
  unsafe { Self::from_wide_iter(value.iter().copied(), value.len()) }
  }
 
@@ -61,12 +61,12 @@ impl HSTRING {
 
  /// # Safety
  /// len must not be less than the number of items in the iterator.
- unsafe fn from_wide_iter<I: Iterator<Item = u16>>(iter: I, len: usize) -> Result<Self> {
+ unsafe fn from_wide_iter<I: Iterator<Item = u16>>(iter: I, len: usize) -> Self {
  if len == 0 {
- return Ok(Self::new());
+ return Self::new();
  }
 
- let ptr = HStringHeader::alloc(len.try_into()?)?;
+ let ptr = HStringHeader::alloc(len.try_into().unwrap());
 
  // Place each utf-16 character into the buffer and
  // increase len as we go along.
@@ -79,7 +79,7 @@ impl HSTRING {
 
  // Write a 0 byte to the end of the buffer.
  (*ptr).data.offset((*ptr).len as isize).write(0);
- Ok(Self(ptr))
+ Self(ptr)
  }
 
  fn as_header(&self) -> Option<&HStringHeader> {
@@ -96,7 +96,7 @@ impl Default for HSTRING {
 impl Clone for HSTRING {
  fn clone(&self) -> Self {
  if let Some(header) = self.as_header() {
- Self(header.duplicate().unwrap())
+ Self(header.duplicate())
  } else {
  Self::new()
  }
@@ -138,7 +138,7 @@ impl core::fmt::Debug for HSTRING {
 
 impl From<&str> for HSTRING {
  fn from(value: &str) -> Self {
- unsafe { Self::from_wide_iter(value.encode_utf16(), value.len()).unwrap() }
+ unsafe { Self::from_wide_iter(value.encode_utf16(), value.len()) }
  }
 }
 
@@ -169,7 +169,6 @@ impl From<&std::ffi::OsStr> for HSTRING {
  std::os::windows::ffi::OsStrExt::encode_wide(value),
  value.len(),
  )
- .unwrap()
  }
  }
 }

crates/libs/strings/src/hstring_builder.rs

@@ -8,14 +8,14 @@ pub struct HStringBuilder(*mut HStringHeader);
 
 impl HStringBuilder {
  /// Creates a preallocated `HSTRING` value.
- pub fn new(len: usize) -> Result<Self> {
- let header = HStringHeader::alloc(len.try_into()?)?;
+ pub fn new(len: usize) -> Self {
+ let header = HStringHeader::alloc(len.try_into().unwrap());
 
  if len > 0 {
  unsafe { core::ptr::write_bytes((*header).data, 0, len) };
  }
 
- Ok(Self(header))
+ Self(header)
  }
 
  /// Shortens the string by removing any trailing 0 characters.

crates/libs/strings/src/hstring_header.rs

@@ -14,9 +14,9 @@ pub struct HStringHeader {
 }
 
 impl HStringHeader {
- pub fn alloc(len: u32) -> Result<*mut Self> {
+ pub fn alloc(len: u32) -> *mut Self {
  if len == 0 {
- return Ok(core::ptr::null_mut());
+ return core::ptr::null_mut();
  }
 
  // Allocate enough space for header and two bytes per character.
@@ -27,7 +27,7 @@ impl HStringHeader {
  unsafe { bindings::HeapAlloc(bindings::GetProcessHeap(), 0, bytes) } as *mut Self;
 
  if header.is_null() {
- return Err(Error::from_hresult(HRESULT(bindings::E_OUTOFMEMORY)));
+ panic!("allocation failed");
  }
 
  unsafe {
@@ -38,7 +38,7 @@ impl HStringHeader {
  (*header).data = &mut (*header).buffer_start;
  }
 
- Ok(header)
+ header
  }
 
  pub unsafe fn free(header: *mut Self) {
@@ -49,20 +49,20 @@ impl HStringHeader {
  bindings::HeapFree(bindings::GetProcessHeap(), 0, header as *mut _);
  }
 
- pub fn duplicate(&self) -> Result<*mut Self> {
+ pub fn duplicate(&self) -> *mut Self {
  if self.flags & HSTRING_REFERENCE_FLAG == 0 {
  // If this is not a "fast pass" string then simply increment the reference count.
  self.count.add_ref();
- Ok(self as *const Self as *mut Self)
+ self as *const Self as *mut Self
  } else {
  // Otherwise, allocate a new string and copy the value into the new string.
- let copy = Self::alloc(self.len)?;
+ let copy = Self::alloc(self.len);
  // SAFETY: since we are duplicating the string it is safe to copy all data from self to the initialized `copy`.
  // We copy `len + 1` characters since `len` does not account for the terminating null character.
  unsafe {
  core::ptr::copy_nonoverlapping(self.data, (*copy).data, self.len as usize + 1);
  }
- Ok(copy)
+ copy
  }
  }
 }

crates/libs/strings/src/lib.rs

@@ -10,9 +10,6 @@
 extern crate alloc;
 use alloc::string::String;
 
-pub use windows_result::Result;
-use windows_result::*;
-
 mod bstr;
 pub use bstr::*;
 

crates/libs/strings/src/pcwstr.rs

@@ -70,7 +70,7 @@ impl PCWSTR {
  /// # Safety
  ///
  /// See the safety information for `PCWSTR::as_wide`.
- pub unsafe fn to_hstring(&self) -> Result<HSTRING> {
+ pub unsafe fn to_hstring(&self) -> HSTRING {
  HSTRING::from_wide(self.as_wide())
  }
 

crates/libs/strings/src/pwstr.rs

@@ -67,7 +67,7 @@ impl PWSTR {
  /// # Safety
  ///
  /// See the safety information for `PWSTR::as_wide`.
- pub unsafe fn to_hstring(&self) -> Result<HSTRING> {
+ pub unsafe fn to_hstring(&self) -> HSTRING {
  HSTRING::from_wide(self.as_wide())
  }