refactor(update_expected): inline reconcile arg. entry

We're going to need the split-apart fields in a subsequent refactoring,
so do that now.

Author: ErichDonGubler

moz-webgpu-cts/src/main.rs

@@ -532,18 +532,12 @@ fn run(cli: Cli) -> ExitCode {
                 .chain(other_entries_by_test)
                 .filter_map(|(test_path, test_entry)| {
                     fn reconcile<Out>(
-                        entry: Entry<Out>,
+                        meta_props: &mut TestProps<Out>,
+                        reported: BTreeMap<Platform, BTreeMap<BuildProfile, Expected<Out>>>,
                         preset: ReportProcessingPreset,
-                    ) -> TestProps<Out>
-                    where
+                    ) where
                         Out: Debug + Default + EnumSetType,
                     {
-                        let Entry {
-                            meta_props,
-                            reported,
-                        } = entry;
-
-                        let mut meta_props = meta_props.unwrap_or_default();
                         let reconciled = 'resolve: {
                             let reported = |platform, build_profile| {
                                 reported
@@ -587,19 +581,22 @@ fn run(cli: Cli) -> ExitCode {
                             }
                         };
                         meta_props.expected = Some(reconciled);
-                        meta_props
                     }
 
                     let TestEntry {
-                        entry: test_entry,
+                        entry:
+                            Entry {
+                                meta_props: properties,
+                                reported: test_reported,
+                            },
                         subtests: subtest_entries,
                     } = test_entry;
 
-                    if test_entry.meta_props.is_none() {
+                    if properties.is_none() {
                         log::info!("new test entry: {test_path:?}")
                     }
 
-                    if test_entry.reported.is_empty() && using_reports {
+                    if test_reported.is_empty() && using_reports {
                         let test_path = &test_path;
                         let msg = lazy_format!("no entries found in reports for {:?}", test_path);
                         match preset {
@@ -612,7 +609,9 @@ fn run(cli: Cli) -> ExitCode {
                         }
                     }
 
-                    let properties = reconcile(test_entry, preset);
+                    let mut properties = properties.unwrap_or_default();
+
+                    reconcile(&mut properties, test_reported, preset);
 
                     let mut subtests = BTreeMap::new();
                     for (subtest_name, subtest) in subtest_entries {
@@ -622,8 +621,13 @@ fn run(cli: Cli) -> ExitCode {
                             log::error!("internal error: duplicate test path {test_path:?}");
                         }
 
-                        let mut properties = reconcile(subtest, preset);
+                        let Entry {
+                            meta_props: properties,
+                            reported: subtest_reported,
+                        } = subtest;
 
+                        let mut properties = properties.unwrap_or_default();
+                        reconcile(&mut properties, subtest_reported, preset);
                         for (_, expected) in properties.expected.as_mut().unwrap().iter_mut() {
                             taint_subtest_timeouts_by_suspicion(expected);
                         }