Skip to content

Commit 8f8bee4

Browse files
borsbors
committed
Auto merge of rust-lang#131581 - tgross35:rollup-vul4kol, r=tgross35
Rollup of 7 pull requests Successful merges: - rust-lang#124874 (intrinsics fmuladdf{32,64}: expose llvm.fmuladd.* semantics) - rust-lang#130962 (Migrate lib's `&Option<T>` into `Option<&T>`) - rust-lang#131289 (stabilize duration_consts_float) - rust-lang#131310 (Support clobber_abi in MSP430 inline assembly) - rust-lang#131546 (Make unused_parens's suggestion considering expr's attributes.) - rust-lang#131565 (Remove deprecation note in the `non_local_definitions` lint) - rust-lang#131576 (Flatten redundant test module `run_make_support::diff::tests::tests`) r? `@ghost` `@rustbot` modify labels: rollup
2 parents fb20e4d + 5e477c9 commit 8f8bee4

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

41 files changed

+395
-119
lines changed

Diff for: ‎compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

+4-1
Original file line numberDiff line numberDiff line change
@@ -328,6 +328,9 @@ fn codegen_float_intrinsic_call<'tcx>(
328328
sym::fabsf64 => ("fabs", 1, fx.tcx.types.f64, types::F64),
329329
sym::fmaf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32),
330330
sym::fmaf64 => ("fma", 3, fx.tcx.types.f64, types::F64),
331+
// FIXME: calling `fma` from libc without FMA target feature uses expensive sofware emulation
332+
sym::fmuladdf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f32
333+
sym::fmuladdf64 => ("fma", 3, fx.tcx.types.f64, types::F64), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f64
331334
sym::copysignf32 => ("copysignf", 2, fx.tcx.types.f32, types::F32),
332335
sym::copysignf64 => ("copysign", 2, fx.tcx.types.f64, types::F64),
333336
sym::floorf32 => ("floorf", 1, fx.tcx.types.f32, types::F32),
@@ -381,7 +384,7 @@ fn codegen_float_intrinsic_call<'tcx>(
381384

382385
let layout = fx.layout_of(ty);
383386
let res = match intrinsic {
384-
sym::fmaf32 | sym::fmaf64 => {
387+
sym::fmaf32 | sym::fmaf64 | sym::fmuladdf32 | sym::fmuladdf64 => {
385388
CValue::by_val(fx.bcx.ins().fma(args[0], args[1], args[2]), layout)
386389
}
387390
sym::copysignf32 | sym::copysignf64 => {

Diff for: ‎compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

+3
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,9 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
6666
sym::log2f64 => "log2",
6767
sym::fmaf32 => "fmaf",
6868
sym::fmaf64 => "fma",
69+
// FIXME: calling `fma` from libc without FMA target feature uses expensive sofware emulation
70+
sym::fmuladdf32 => "fmaf", // TODO: use gcc intrinsic analogous to llvm.fmuladd.f32
71+
sym::fmuladdf64 => "fma", // TODO: use gcc intrinsic analogous to llvm.fmuladd.f64
6972
sym::fabsf32 => "fabsf",
7073
sym::fabsf64 => "fabs",
7174
sym::minnumf32 => "fminf",

Diff for: ‎compiler/rustc_codegen_llvm/src/context.rs

+5
Original file line numberDiff line numberDiff line change
@@ -884,6 +884,11 @@ impl<'ll> CodegenCx<'ll, '_> {
884884
ifn!("llvm.fma.f64", fn(t_f64, t_f64, t_f64) -> t_f64);
885885
ifn!("llvm.fma.f128", fn(t_f128, t_f128, t_f128) -> t_f128);
886886

887+
ifn!("llvm.fmuladd.f16", fn(t_f16, t_f16, t_f16) -> t_f16);
888+
ifn!("llvm.fmuladd.f32", fn(t_f32, t_f32, t_f32) -> t_f32);
889+
ifn!("llvm.fmuladd.f64", fn(t_f64, t_f64, t_f64) -> t_f64);
890+
ifn!("llvm.fmuladd.f128", fn(t_f128, t_f128, t_f128) -> t_f128);
891+
887892
ifn!("llvm.fabs.f16", fn(t_f16) -> t_f16);
888893
ifn!("llvm.fabs.f32", fn(t_f32) -> t_f32);
889894
ifn!("llvm.fabs.f64", fn(t_f64) -> t_f64);

Diff for: ‎compiler/rustc_codegen_llvm/src/intrinsic.rs

+5
Original file line numberDiff line numberDiff line change
@@ -86,6 +86,11 @@ fn get_simple_intrinsic<'ll>(
8686
sym::fmaf64 => "llvm.fma.f64",
8787
sym::fmaf128 => "llvm.fma.f128",
8888

89+
sym::fmuladdf16 => "llvm.fmuladd.f16",
90+
sym::fmuladdf32 => "llvm.fmuladd.f32",
91+
sym::fmuladdf64 => "llvm.fmuladd.f64",
92+
sym::fmuladdf128 => "llvm.fmuladd.f128",
93+
8994
sym::fabsf16 => "llvm.fabs.f16",
9095
sym::fabsf32 => "llvm.fabs.f32",
9196
sym::fabsf64 => "llvm.fabs.f64",

Diff for: ‎compiler/rustc_hir_analysis/src/check/intrinsic.rs

+13
Original file line numberDiff line numberDiff line change
@@ -357,6 +357,19 @@ pub fn check_intrinsic_type(
357357
(0, 0, vec![tcx.types.f128, tcx.types.f128, tcx.types.f128], tcx.types.f128)
358358
}
359359

360+
sym::fmuladdf16 => {
361+
(0, 0, vec![tcx.types.f16, tcx.types.f16, tcx.types.f16], tcx.types.f16)
362+
}
363+
sym::fmuladdf32 => {
364+
(0, 0, vec![tcx.types.f32, tcx.types.f32, tcx.types.f32], tcx.types.f32)
365+
}
366+
sym::fmuladdf64 => {
367+
(0, 0, vec![tcx.types.f64, tcx.types.f64, tcx.types.f64], tcx.types.f64)
368+
}
369+
sym::fmuladdf128 => {
370+
(0, 0, vec![tcx.types.f128, tcx.types.f128, tcx.types.f128], tcx.types.f128)
371+
}
372+
360373
sym::fabsf16 => (0, 0, vec![tcx.types.f16], tcx.types.f16),
361374
sym::fabsf32 => (0, 0, vec![tcx.types.f32], tcx.types.f32),
362375
sym::fabsf64 => (0, 0, vec![tcx.types.f64], tcx.types.f64),

Diff for: ‎compiler/rustc_lint/messages.ftl

-2
Original file line numberDiff line numberDiff line change
@@ -581,8 +581,6 @@ lint_non_glob_import_type_ir_inherent = non-glob import of `rustc_type_ir::inher
581581
582582
lint_non_local_definitions_cargo_update = the {$macro_kind} `{$macro_name}` may come from an old version of the `{$crate_name}` crate, try updating your dependency with `cargo update -p {$crate_name}`
583583
584-
lint_non_local_definitions_deprecation = this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
585-
586584
lint_non_local_definitions_impl = non-local `impl` definition, `impl` blocks should be written at the same level as their item
587585
.non_local = an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
588586
.doctest = make this doc-test a standalone test with its own `fn main() {"{"} ... {"}"}`

Diff for: ‎compiler/rustc_lint/src/lints.rs

-3
Original file line numberDiff line numberDiff line change
@@ -1430,8 +1430,6 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
14301430
);
14311431
}
14321432
}
1433-
1434-
diag.note(fluent::lint_non_local_definitions_deprecation);
14351433
}
14361434
NonLocalDefinitionsDiag::MacroRules {
14371435
depth,
@@ -1452,7 +1450,6 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
14521450
}
14531451

14541452
diag.note(fluent::lint_non_local);
1455-
diag.note(fluent::lint_non_local_definitions_deprecation);
14561453

14571454
if let Some(cargo_update) = cargo_update {
14581455
diag.subdiagnostic(cargo_update);

Diff for: ‎compiler/rustc_lint/src/unused.rs

+9-1
Original file line numberDiff line numberDiff line change
@@ -804,7 +804,15 @@ trait UnusedDelimLint {
804804
.find_ancestor_inside(value.span)
805805
.map(|span| (value.span.with_hi(span.lo()), value.span.with_lo(span.hi()))),
806806
ast::ExprKind::Paren(ref expr) => {
807-
expr.span.find_ancestor_inside(value.span).map(|expr_span| {
807+
// For the expr with attributes, like `let _ = (#[inline] || println!("Hello!"));`,
808+
// the span should contains the attributes, or the suggestion will remove them.
809+
let expr_span_with_attrs =
810+
if let Some(attr_lo) = expr.attrs.iter().map(|attr| attr.span.lo()).min() {
811+
expr.span.with_lo(attr_lo)
812+
} else {
813+
expr.span
814+
};
815+
expr_span_with_attrs.find_ancestor_inside(value.span).map(|expr_span| {
808816
(value.span.with_hi(expr_span.lo()), value.span.with_lo(expr_span.hi()))
809817
})
810818
}

Diff for: ‎compiler/rustc_span/src/symbol.rs

+4
Original file line numberDiff line numberDiff line change
@@ -914,6 +914,10 @@ symbols! {
914914
fmt_debug,
915915
fmul_algebraic,
916916
fmul_fast,
917+
fmuladdf128,
918+
fmuladdf16,
919+
fmuladdf32,
920+
fmuladdf64,
917921
fn_align,
918922
fn_delegation,
919923
fn_must_use,

Diff for: ‎compiler/rustc_target/src/asm/mod.rs

+10
Original file line numberDiff line numberDiff line change
@@ -893,6 +893,7 @@ pub enum InlineAsmClobberAbi {
893893
RiscV,
894894
LoongArch,
895895
S390x,
896+
Msp430,
896897
}
897898

898899
impl InlineAsmClobberAbi {
@@ -946,6 +947,10 @@ impl InlineAsmClobberAbi {
946947
"C" | "system" => Ok(InlineAsmClobberAbi::S390x),
947948
_ => Err(&["C", "system"]),
948949
},
950+
InlineAsmArch::Msp430 => match name {
951+
"C" | "system" => Ok(InlineAsmClobberAbi::Msp430),
952+
_ => Err(&["C", "system"]),
953+
},
949954
_ => Err(&[]),
950955
}
951956
}
@@ -1125,6 +1130,11 @@ impl InlineAsmClobberAbi {
11251130
a8, a9, a10, a11, a12, a13, a14, a15,
11261131
}
11271132
},
1133+
InlineAsmClobberAbi::Msp430 => clobbered_regs! {
1134+
Msp430 Msp430InlineAsmReg {
1135+
r11, r12, r13, r14, r15,
1136+
}
1137+
},
11281138
}
11291139
}
11301140
}

Diff for: ‎library/core/src/intrinsics.rs

+53
Original file line numberDiff line numberDiff line change
@@ -1795,6 +1795,59 @@ extern "rust-intrinsic" {
17951795
#[rustc_nounwind]
17961796
pub fn fmaf128(a: f128, b: f128, c: f128) -> f128;
17971797

1798+
/// Returns `a * b + c` for `f16` values, non-deterministically executing
1799+
/// either a fused multiply-add or two operations with rounding of the
1800+
/// intermediate result.
1801+
///
1802+
/// The operation is fused if the code generator determines that target
1803+
/// instruction set has support for a fused operation, and that the fused
1804+
/// operation is more efficient than the equivalent, separate pair of mul
1805+
/// and add instructions. It is unspecified whether or not a fused operation
1806+
/// is selected, and that may depend on optimization level and context, for
1807+
/// example.
1808+
#[rustc_nounwind]
1809+
#[cfg(not(bootstrap))]
1810+
pub fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
1811+
/// Returns `a * b + c` for `f32` values, non-deterministically executing
1812+
/// either a fused multiply-add or two operations with rounding of the
1813+
/// intermediate result.
1814+
///
1815+
/// The operation is fused if the code generator determines that target
1816+
/// instruction set has support for a fused operation, and that the fused
1817+
/// operation is more efficient than the equivalent, separate pair of mul
1818+
/// and add instructions. It is unspecified whether or not a fused operation
1819+
/// is selected, and that may depend on optimization level and context, for
1820+
/// example.
1821+
#[rustc_nounwind]
1822+
#[cfg(not(bootstrap))]
1823+
pub fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
1824+
/// Returns `a * b + c` for `f64` values, non-deterministically executing
1825+
/// either a fused multiply-add or two operations with rounding of the
1826+
/// intermediate result.
1827+
///
1828+
/// The operation is fused if the code generator determines that target
1829+
/// instruction set has support for a fused operation, and that the fused
1830+
/// operation is more efficient than the equivalent, separate pair of mul
1831+
/// and add instructions. It is unspecified whether or not a fused operation
1832+
/// is selected, and that may depend on optimization level and context, for
1833+
/// example.
1834+
#[rustc_nounwind]
1835+
#[cfg(not(bootstrap))]
1836+
pub fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
1837+
/// Returns `a * b + c` for `f128` values, non-deterministically executing
1838+
/// either a fused multiply-add or two operations with rounding of the
1839+
/// intermediate result.
1840+
///
1841+
/// The operation is fused if the code generator determines that target
1842+
/// instruction set has support for a fused operation, and that the fused
1843+
/// operation is more efficient than the equivalent, separate pair of mul
1844+
/// and add instructions. It is unspecified whether or not a fused operation
1845+
/// is selected, and that may depend on optimization level and context, for
1846+
/// example.
1847+
#[rustc_nounwind]
1848+
#[cfg(not(bootstrap))]
1849+
pub fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
1850+
17981851
/// Returns the absolute value of an `f16`.
17991852
///
18001853
/// The stabilized version of this intrinsic is

Diff for: ‎library/core/src/lib.rs

-1
Original file line numberDiff line numberDiff line change
@@ -153,7 +153,6 @@
153153
#![feature(const_unicode_case_lookup)]
154154
#![feature(coverage_attribute)]
155155
#![feature(do_not_recommend)]
156-
#![feature(duration_consts_float)]
157156
#![feature(internal_impls_macro)]
158157
#![feature(ip)]
159158
#![feature(is_ascii_octdigit)]

Diff for: ‎library/core/src/time.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -847,7 +847,7 @@ impl Duration {
847847
#[stable(feature = "duration_float", since = "1.38.0")]
848848
#[must_use]
849849
#[inline]
850-
#[rustc_const_unstable(feature = "duration_consts_float", issue = "72440")]
850+
#[rustc_const_stable(feature = "duration_consts_float", since = "CURRENT_RUSTC_VERSION")]
851851
pub const fn as_secs_f64(&self) -> f64 {
852852
(self.secs as f64) + (self.nanos.0 as f64) / (NANOS_PER_SEC as f64)
853853
}
@@ -866,7 +866,7 @@ impl Duration {
866866
#[stable(feature = "duration_float", since = "1.38.0")]
867867
#[must_use]
868868
#[inline]
869-
#[rustc_const_unstable(feature = "duration_consts_float", issue = "72440")]
869+
#[rustc_const_stable(feature = "duration_consts_float", since = "CURRENT_RUSTC_VERSION")]
870870
pub const fn as_secs_f32(&self) -> f32 {
871871
(self.secs as f32) + (self.nanos.0 as f32) / (NANOS_PER_SEC as f32)
872872
}
@@ -886,7 +886,7 @@ impl Duration {
886886
#[unstable(feature = "duration_millis_float", issue = "122451")]
887887
#[must_use]
888888
#[inline]
889-
#[rustc_const_unstable(feature = "duration_consts_float", issue = "72440")]
889+
#[rustc_const_unstable(feature = "duration_millis_float", issue = "122451")]
890890
pub const fn as_millis_f64(&self) -> f64 {
891891
(self.secs as f64) * (MILLIS_PER_SEC as f64)
892892
+ (self.nanos.0 as f64) / (NANOS_PER_MILLI as f64)
@@ -907,7 +907,7 @@ impl Duration {
907907
#[unstable(feature = "duration_millis_float", issue = "122451")]
908908
#[must_use]
909909
#[inline]
910-
#[rustc_const_unstable(feature = "duration_consts_float", issue = "72440")]
910+
#[rustc_const_unstable(feature = "duration_millis_float", issue = "122451")]
911911
pub const fn as_millis_f32(&self) -> f32 {
912912
(self.secs as f32) * (MILLIS_PER_SEC as f32)
913913
+ (self.nanos.0 as f32) / (NANOS_PER_MILLI as f32)
@@ -1087,7 +1087,7 @@ impl Duration {
10871087
#[must_use = "this returns the result of the operation, \
10881088
without modifying the original"]
10891089
#[inline]
1090-
#[rustc_const_unstable(feature = "duration_consts_float", issue = "72440")]
1090+
#[rustc_const_stable(feature = "duration_consts_float", since = "CURRENT_RUSTC_VERSION")]
10911091
pub const fn div_duration_f64(self, rhs: Duration) -> f64 {
10921092
let self_nanos = (self.secs as f64) * (NANOS_PER_SEC as f64) + (self.nanos.0 as f64);
10931093
let rhs_nanos = (rhs.secs as f64) * (NANOS_PER_SEC as f64) + (rhs.nanos.0 as f64);
@@ -1108,7 +1108,7 @@ impl Duration {
11081108
#[must_use = "this returns the result of the operation, \
11091109
without modifying the original"]
11101110
#[inline]
1111-
#[rustc_const_unstable(feature = "duration_consts_float", issue = "72440")]
1111+
#[rustc_const_stable(feature = "duration_consts_float", since = "CURRENT_RUSTC_VERSION")]
11121112
pub const fn div_duration_f32(self, rhs: Duration) -> f32 {
11131113
let self_nanos = (self.secs as f32) * (NANOS_PER_SEC as f32) + (self.nanos.0 as f32);
11141114
let rhs_nanos = (rhs.secs as f32) * (NANOS_PER_SEC as f32) + (rhs.nanos.0 as f32);

Diff for: ‎library/core/tests/lib.rs

-1
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,6 @@
3838
#![feature(dec2flt)]
3939
#![feature(duration_constants)]
4040
#![feature(duration_constructors)]
41-
#![feature(duration_consts_float)]
4241
#![feature(error_generic_member_access)]
4342
#![feature(exact_size_is_empty)]
4443
#![feature(extern_types)]

Diff for: ‎library/std/src/sys/pal/sgx/net.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -78,9 +78,8 @@ fn io_err_to_addr(result: io::Result<&SocketAddr>) -> io::Result<String> {
7878
}
7979
}
8080

81-
fn addr_to_sockaddr(addr: &Option<String>) -> io::Result<SocketAddr> {
82-
addr.as_ref()
83-
.ok_or(io::ErrorKind::AddrNotAvailable)?
81+
fn addr_to_sockaddr(addr: Option<&str>) -> io::Result<SocketAddr> {
82+
addr.ok_or(io::ErrorKind::AddrNotAvailable)?
8483
.to_socket_addrs()
8584
// unwrap OK: if an iterator is returned, we're guaranteed to get exactly one entry
8685
.map(|mut it| it.next().unwrap())
@@ -161,11 +160,11 @@ impl TcpStream {
161160
}
162161

163162
pub fn peer_addr(&self) -> io::Result<SocketAddr> {
164-
addr_to_sockaddr(&self.peer_addr)
163+
addr_to_sockaddr(self.peer_addr.as_deref())
165164
}
166165

167166
pub fn socket_addr(&self) -> io::Result<SocketAddr> {
168-
addr_to_sockaddr(&self.inner.local_addr)
167+
addr_to_sockaddr(self.inner.local_addr.as_deref())
169168
}
170169

171170
pub fn shutdown(&self, _: Shutdown) -> io::Result<()> {
@@ -255,13 +254,14 @@ impl TcpListener {
255254
}
256255

257256
pub fn socket_addr(&self) -> io::Result<SocketAddr> {
258-
addr_to_sockaddr(&self.inner.local_addr)
257+
addr_to_sockaddr(self.inner.local_addr.as_deref())
259258
}
260259

261260
pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
262261
let (fd, local_addr, peer_addr) = usercalls::accept_stream(self.inner.inner.raw())?;
263262
let peer_addr = Some(peer_addr);
264-
let ret_peer = addr_to_sockaddr(&peer_addr).unwrap_or_else(|_| ([0; 4], 0).into());
263+
let ret_peer =
264+
addr_to_sockaddr(peer_addr.as_deref()).unwrap_or_else(|_| ([0; 4], 0).into());
265265
Ok((TcpStream { inner: Socket::new(fd, local_addr), peer_addr }, ret_peer))
266266
}
267267

Diff for: ‎library/std/src/sys/pal/unix/process/process_common.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -312,8 +312,8 @@ impl Command {
312312
}
313313

314314
#[allow(dead_code)]
315-
pub fn get_cwd(&self) -> &Option<CString> {
316-
&self.cwd
315+
pub fn get_cwd(&self) -> Option<&CStr> {
316+
self.cwd.as_deref()
317317
}
318318
#[allow(dead_code)]
319319
pub fn get_uid(&self) -> Option<uid_t> {

Diff for: ‎library/std/src/sys/pal/unix/process/process_unix.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -335,7 +335,7 @@ impl Command {
335335
cvt(libc::setuid(u as uid_t))?;
336336
}
337337
}
338-
if let Some(ref cwd) = *self.get_cwd() {
338+
if let Some(cwd) = self.get_cwd() {
339339
cvt(libc::chdir(cwd.as_ptr()))?;
340340
}
341341

Diff for: ‎library/std/src/sys/pal/unix/process/process_vxworks.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ impl Command {
5757
t!(cvt_r(|| libc::dup2(fd, libc::STDERR_FILENO)));
5858
}
5959

60-
if let Some(ref cwd) = *self.get_cwd() {
60+
if let Some(cwd) = self.get_cwd() {
6161
t!(cvt(libc::chdir(cwd.as_ptr())));
6262
}
6363

Diff for: ‎library/test/src/lib.rs

+6-5
Original file line numberDiff line numberDiff line change
@@ -650,8 +650,8 @@ fn run_test_in_process(
650650
io::set_output_capture(None);
651651

652652
let test_result = match result {
653-
Ok(()) => calc_result(&desc, Ok(()), &time_opts, &exec_time),
654-
Err(e) => calc_result(&desc, Err(e.as_ref()), &time_opts, &exec_time),
653+
Ok(()) => calc_result(&desc, Ok(()), time_opts.as_ref(), exec_time.as_ref()),
654+
Err(e) => calc_result(&desc, Err(e.as_ref()), time_opts.as_ref(), exec_time.as_ref()),
655655
};
656656
let stdout = data.lock().unwrap_or_else(|e| e.into_inner()).to_vec();
657657
let message = CompletedTest::new(id, desc, test_result, exec_time, stdout);
@@ -712,7 +712,8 @@ fn spawn_test_subprocess(
712712
formatters::write_stderr_delimiter(&mut test_output, &desc.name);
713713
test_output.extend_from_slice(&stderr);
714714

715-
let result = get_result_from_exit_code(&desc, status, &time_opts, &exec_time);
715+
let result =
716+
get_result_from_exit_code(&desc, status, time_opts.as_ref(), exec_time.as_ref());
716717
(result, test_output, exec_time)
717718
})();
718719

@@ -724,8 +725,8 @@ fn run_test_in_spawned_subprocess(desc: TestDesc, runnable_test: RunnableTest) -
724725
let builtin_panic_hook = panic::take_hook();
725726
let record_result = Arc::new(move |panic_info: Option<&'_ PanicHookInfo<'_>>| {
726727
let test_result = match panic_info {
727-
Some(info) => calc_result(&desc, Err(info.payload()), &None, &None),
728-
None => calc_result(&desc, Ok(()), &None, &None),
728+
Some(info) => calc_result(&desc, Err(info.payload()), None, None),
729+
None => calc_result(&desc, Ok(()), None, None),
729730
};
730731

731732
// We don't support serializing TrFailedMsg, so just

0 commit comments

Comments
 (0)