fix: replace deprecated MoonBit try? usage

- Add a private fzip_result helper that captures FzipError-raising calls with try/catch/noraise.
- Replace deprecated try? captures in ZIP fallback logic and white-box tests while preserving Result-based assertions.
- Keep ZIP64 classic fallback behavior unchanged by using the helper only where a Result value is intentionally inspected.
- Validate the migration with moon check --target all, moon test --target all, moon info, and git diff --check.

Author: hustcer

src/error.mbt

@@ -46,7 +46,7 @@ pub(all) enum FzipErrorCode {
 
 ///|
 /// Write the symbolic error-code name, such as `"InvalidHeader"`.
-pub impl Show for FzipErrorCode with output(self, logger) {
+pub impl Show for FzipErrorCode with fn output(self, logger) {
   match self {
     UnexpectedEOF => logger.write_string("UnexpectedEOF")
     InvalidBlockType => logger.write_string("InvalidBlockType")
@@ -117,3 +117,12 @@ fn fzip_err(code : FzipErrorCode, msg? : String = "") -> FzipError {
   }
   FzipError(code~, message~)
 }
+
+///|
+fn[T] fzip_result(f : () -> T raise FzipError) -> Result[T, FzipError] {
+  try f() catch {
+    err => Err(err)
+  } noraise {
+    value => Ok(value)
+  }
+}

src/gzip_wbtest.mbt

@@ -95,16 +95,15 @@ test "gunzip - rejects ISIZE above max_output_size before allocation" {
   let data : FixedArray[Byte] = [b'H', b'i']
   let compressed = gzip_sync(data)
   w4(compressed, compressed.length() - 4, 1000U)
-  let result : Result[FixedArray[Byte], FzipError] = try? gunzip_sync(
-    compressed,
-    opts={
+  let result : Result[FixedArray[Byte], FzipError] = fzip_result(() => {
+    gunzip_sync(compressed, opts={
       out: None,
       dictionary: None,
       max_output_size: 16,
       max_input_size: default_max_input_size,
       verify_checksum: true,
-    },
-  )
+    })
+  })
   guard result is Err(FzipError(code~, message~)) else {
     fail("expected error")
   }
@@ -117,9 +116,9 @@ test "gunzip - rejects ISIZE mismatch after successful inflate" {
   let data : FixedArray[Byte] = [b'H', b'e', b'l', b'l', b'o']
   let compressed = gzip_sync(data)
   w4(compressed, compressed.length() - 4, 8U)
-  let result : Result[FixedArray[Byte], FzipError] = try? gunzip_sync(
-    compressed,
-  )
+  let result : Result[FixedArray[Byte], FzipError] = fzip_result(() => {
+    gunzip_sync(compressed)
+  })
   guard result is Err(FzipError(code~, message~)) else {
     fail("expected error")
   }
@@ -252,6 +251,6 @@ test "gunzip - invalid CRC-32 checksum" {
   // Corrupt the CRC-32 (last 8 bytes contain CRC-32 and size)
   let corrupted = slc(compressed, 0, e=compressed.length())
   corrupted[corrupted.length() - 8] = b'\xFF'
-  let result = try? gunzip_sync(corrupted)
+  let result = fzip_result(() => gunzip_sync(corrupted))
   assert_true(result is Err(_))
 }

src/inflate_wbtest.mbt

@@ -337,14 +337,16 @@ test "inflt/tuple_return/too_small_buf_returns_error" {
   let data = FixedArray::make(512, b'A')
   let compressed = deflate_sync(data)
   let out = FixedArray::make(8, b'\x00')
-  let result : Result[(FixedArray[Byte], Int), FzipError] = try? inflt(
-    compressed,
-    InflateState::new(2),
-    Some(out),
-    None,
-    default_max_input_size,
-    default_max_input_size,
-  )
+  let result : Result[(FixedArray[Byte], Int), FzipError] = fzip_result(() => {
+    inflt(
+      compressed,
+      InflateState::new(2),
+      Some(out),
+      None,
+      default_max_input_size,
+      default_max_input_size,
+    )
+  })
   guard result is Err(FzipError(code~, message~)) else {
     fail("expected error")
   }
@@ -356,7 +358,7 @@ test "inflt/tuple_return/too_small_buf_returns_error" {
 test "inflate - corrupted data error" {
   // Test error handling with corrupted data
   let corrupted = FixedArray::make(10, b'\xff')
-  let result = try? inflate_sync(corrupted)
+  let result = fzip_result(() => inflate_sync(corrupted))
   assert_true(result is Err(_))
 }
 
@@ -367,16 +369,16 @@ test "inflate - truncated data error" {
   let compressed = deflate_sync(data)
   // Take only first half of compressed data
   let truncated = slc(compressed, 0, e=compressed.length() / 2)
-  let result = try? inflate_sync(truncated)
+  let result = fzip_result(() => inflate_sync(truncated))
   assert_true(result is Err(_))
 }
 
 ///|
 test "inflate - rejects code length repeat 16 at start" {
   let malformed : FixedArray[Byte] = [b'\x05', b'\x00', b'\x02', b'\x00']
-  let result : Result[FixedArray[Byte], FzipError] = try? inflate_sync(
-    malformed,
-  )
+  let result : Result[FixedArray[Byte], FzipError] = fzip_result(() => {
+    inflate_sync(malformed)
+  })
   guard result is Err(FzipError(code~, ..)) else { fail("expected error") }
   assert_eq(code, InvalidLengthLiteral)
 }
@@ -386,9 +388,9 @@ test "inflate - rejects code length repeat overflow" {
   let malformed : FixedArray[Byte] = [
     b'\x05', b'\x00', b'\x80', b'\xC0', b'\xDF', b'\x1F',
   ]
-  let result : Result[FixedArray[Byte], FzipError] = try? inflate_sync(
-    malformed,
-  )
+  let result : Result[FixedArray[Byte], FzipError] = fzip_result(() => {
+    inflate_sync(malformed)
+  })
   guard result is Err(FzipError(code~, ..)) else { fail("expected error") }
   assert_eq(code, InvalidLengthLiteral)
 }
@@ -399,11 +401,13 @@ test "inflate - custom max_output_size limit" {
   let data = FixedArray::make(1000, b'A')
   let compressed = deflate_sync(data)
   // Set max_output_size to 500 bytes (less than actual output)
-  let result = try? inflate_sync(compressed, opts={
-    out: None,
-    dictionary: None,
-    max_output_size: 500,
-    max_input_size: default_max_input_size,
+  let result = fzip_result(() => {
+    inflate_sync(compressed, opts={
+      out: None,
+      dictionary: None,
+      max_output_size: 500,
+      max_input_size: default_max_input_size,
+    })
   })
   assert_true(result is Err(_))
 }
@@ -418,11 +422,13 @@ test "inflate - custom max_input_size limit" {
   }
   let compressed = deflate_sync(data)
   // Set max_input_size smaller than compressed size
-  let result = try? inflate_sync(compressed, opts={
-    out: None,
-    dictionary: None,
-    max_output_size: default_max_output_size,
-    max_input_size: 100,
+  let result = fzip_result(() => {
+    inflate_sync(compressed, opts={
+      out: None,
+      dictionary: None,
+      max_output_size: default_max_output_size,
+      max_input_size: 100,
+    })
   })
   assert_true(result is Err(_))
 }
@@ -821,7 +827,7 @@ test "inflt/backref/dict_overlap_then_doubling" {
 ///   byte 2 = 0x00 (must be present so the 14-bit header refill can complete)
 test "inflt/dynamic_huffman/hlit_too_large_f_inf_002" {
   let payload : FixedArray[Byte] = [b'\xF5', b'\x00', b'\x00']
-  let result = try? inflate_sync(payload)
+  let result = fzip_result(() => inflate_sync(payload))
   guard result is Err(FzipError(code~, ..)) else {
     fail("expected FzipError for HLIT > 286")
   }
@@ -849,7 +855,7 @@ test "inflt/dynamic_huffman/hlit_too_large_f_inf_002" {
 ///   byte 2 = 0x00
 test "inflt/dynamic_huffman/hdist_too_large_f_inf_003" {
   let payload : FixedArray[Byte] = [b'\x05', b'\x1E', b'\x00']
-  let result = try? inflate_sync(payload)
+  let result = fzip_result(() => inflate_sync(payload))
   guard result is Err(FzipError(code~, ..)) else {
     fail("expected FzipError for HDIST > 30")
   }

src/security_wbtest.mbt

@@ -1,14 +1,14 @@
 ///|
 test "security/gzip - empty input" {
   let empty : FixedArray[Byte] = []
-  let result = try? gunzip_sync(empty)
+  let result = fzip_result(() => gunzip_sync(empty))
   assert_true(result is Err(_))
 }
 
 ///|
 test "security/gzip - too short input" {
   let short : FixedArray[Byte] = [b'\x1F', b'\x8B']
-  let result = try? gunzip_sync(short)
+  let result = fzip_result(() => gunzip_sync(short))
   assert_true(result is Err(_))
 }
 
@@ -17,7 +17,7 @@ test "security/gzip - 9 bytes input" {
   let short : FixedArray[Byte] = [
     b'\x1F', b'\x8B', b'\x08', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00',
   ]
-  let result = try? gunzip_sync(short)
+  let result = fzip_result(() => gunzip_sync(short))
   assert_true(result is Err(_))
 }
 
@@ -28,7 +28,7 @@ test "security/gzip - FNAME flag but truncated" {
     b'\x1F', b'\x8B', b'\x08', b'\x08', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00',
     b'\x03',
   ]
-  let result = try? gunzip_sync(truncated)
+  let result = fzip_result(() => gunzip_sync(truncated))
   assert_true(result is Err(_))
 }
 
@@ -38,7 +38,7 @@ test "security/gzip - FEXTRA flag but truncated length" {
     b'\x1F', b'\x8B', b'\x08', b'\x04', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00',
     b'\x03',
   ]
-  let result = try? gunzip_sync(truncated)
+  let result = fzip_result(() => gunzip_sync(truncated))
   assert_true(result is Err(_))
 }
 
@@ -48,7 +48,7 @@ test "security/gzip - FEXTRA length exceeds input" {
     b'\x1F', b'\x8B', b'\x08', b'\x04', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00',
     b'\x03', b'\x10', b'\x00',
   ]
-  let result = try? gunzip_sync(truncated)
+  let result = fzip_result(() => gunzip_sync(truncated))
   assert_true(result is Err(_))
 }
 
@@ -58,50 +58,50 @@ test "security/gzip - reserved flags rejected" {
     b'\x1F', b'\x8B', b'\x08', b'\xE0', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00',
     b'\x03', b'\x03', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00', b'\x00',
   ]
-  let result = try? gunzip_sync(invalid)
+  let result = fzip_result(() => gunzip_sync(invalid))
   assert_true(result is Err(_))
 }
 
 ///|
 test "security/zlib - empty input" {
   let empty : FixedArray[Byte] = []
-  let result = try? unzlib_sync(empty)
+  let result = fzip_result(() => unzlib_sync(empty))
   assert_true(result is Err(_))
 }
 
 ///|
 test "security/zlib - 1 byte input" {
   let short : FixedArray[Byte] = [b'\x78']
-  let result = try? unzlib_sync(short)
+  let result = fzip_result(() => unzlib_sync(short))
   assert_true(result is Err(_))
 }
 
 ///|
 test "security/zlib - header only (no compressed data)" {
   // Valid zlib header (0x78 0x9C) but no compressed data or checksum
   let short : FixedArray[Byte] = [b'\x78', b'\x9C']
-  let result = try? unzlib_sync(short)
+  let result = fzip_result(() => unzlib_sync(short))
   assert_true(result is Err(_))
 }
 
 ///|
 test "security/zip - empty input" {
   let empty : FixedArray[Byte] = []
-  let result = try? unzip_sync(empty)
+  let result = fzip_result(() => unzip_sync(empty))
   assert_true(result is Err(_))
 }
 
 ///|
 test "security/zip - too short input" {
   let short : FixedArray[Byte] = [b'\x50', b'\x4B', b'\x05', b'\x06']
-  let result = try? unzip_sync(short)
+  let result = fzip_result(() => unzip_sync(short))
   assert_true(result is Err(_))
 }
 
 ///|
 test "security/zip - unzip_list empty input" {
   let empty : FixedArray[Byte] = []
-  let result = try? unzip_list(empty)
+  let result = fzip_result(() => unzip_list(empty))
   assert_true(result is Err(_))
 }
 
@@ -132,21 +132,21 @@ test "security/decompress - 2 byte input no crash" {
   // decompress_sync with exactly 2 bytes should not crash
   // (previously accessed data[2] with only length >= 2 check)
   let data : FixedArray[Byte] = [b'\x00', b'\x00']
-  let result = try? decompress_sync(data)
+  let result = fzip_result(() => decompress_sync(data))
   // It's OK if this errors, just shouldn't crash with out-of-bounds
   let _ = result
 }
 
 ///|
 test "security/decompress - 1 byte input" {
   let data : FixedArray[Byte] = [b'\x00']
-  let result = try? decompress_sync(data)
+  let result = fzip_result(() => decompress_sync(data))
   let _ = result
 }
 
 ///|
 test "security/decompress - empty input" {
   let data : FixedArray[Byte] = []
-  let result = try? decompress_sync(data)
+  let result = fzip_result(() => decompress_sync(data))
   let _ = result
 }

src/string_wbtest.mbt

@@ -134,7 +134,7 @@ test "str_to_u8/str_from_u8 roundtrip - mixed byte lengths" {
 
 ///|
 fn assert_invalid_utf8(data : FixedArray[Byte]) -> Unit raise {
-  let result = try? str_from_u8(data)
+  let result = fzip_result(() => str_from_u8(data))
   guard result is Err(FzipError(code~, ..)) else {
     fail("expected InvalidUTF8 for byte sequence")
   }

src/zip.mbt

@@ -1357,9 +1357,9 @@ fn read_central_directory_info(
       msg="ZIP64 sentinel set but no valid ZIP64 locator",
     )
   }
-  let z64_result : Result[ZipCdInfo, FzipError] = try? read_zip64_cd_info(
-    data, eocd,
-  )
+  let z64_result : Result[ZipCdInfo, FzipError] = fzip_result(() => {
+    read_zip64_cd_info(data, eocd)
+  })
   match z64_result {
     Ok(info) => {
       validate_zip64_cd_matches_classic(