WIP

tools/analysis/trace-tools/src/lib/parquet.rs

@@ -556,7 +556,7 @@ struct ReadState<'scope, 'scopeenv> {
     scope: &'scope Scope<'scopeenv>,
 }
 
-type MetaEventEntry<'scope> = Result<(Rc<RefCell<TableState<'scope>>>, PrintFmtStr), Rc<MainError>>;
+type MetaEventEntry<'scope> = Rc<Result<(RefCell<TableState<'scope>>, PrintFmtStr), MainError>>;
 
 #[derive(Debug)]
 enum ReadStateVariant<'scope> {
@@ -675,17 +675,16 @@ where
         }
 
         macro_rules! bprint_meta_iter {
-            ($table_state:expr, $visitor:expr, $print_fmt:expr, $buf_fmt:expr) => {{
+            ($meta_event_entry:expr, $visitor:expr, $buf_fmt:expr) => {{
                 let visitor = $visitor;
-                let print_fmt = $print_fmt;
                 let buf_fmt = $buf_fmt;
 
                 let buf = visitor.field_by_fmt(buf_fmt)?;
 
                 match buf {
                     Value::U32Array(array) => {
-                        let table_state = $table_state;
-                        let mut table_state = RefCell::borrow_mut(table_state);
+                        let (table_state, print_fmt) = $meta_event_entry;
+                        let mut table_state: RefMut<'ret, _> = RefCell::borrow_mut(table_state);
                         let mut _table_state = table_state.deref_mut();
 
                         let res = visitor
@@ -697,15 +696,16 @@ where
                         .collect::<Result<(), MainError>>();
                         match res {
                             Ok(_) => Ok(DerefMutWrapper::RcRefMut(table_state)),
-                            Err(err) => Err(err)
+                            Err(err) => Err(err),
                         }
                     }
                     _ => Err(MainError::EvalError(EvalError::IllegalType)),
                 }
             }};
         }
 
-        match &mut self.variant {
+        let variant: &'ret mut _ = &mut self.variant;
+        match variant {
             ReadStateVariant::Generic(state) => generic_iter!(state, visitor),
             ReadStateVariant::BPrint {
                 generic,
@@ -724,9 +724,9 @@ where
 
                 macro_rules! handle {
                     ($res:expr) => {{
-                        match $res {
-                            Ok((state, print_fmt)) => {
-                                bprint_meta_iter!(state, visitor, print_fmt, buf_fmt)
+                        match Rc::as_ref($res) {
+                            Ok(entry) => {
+                                bprint_meta_iter!(entry, visitor, buf_fmt)
                             }
                             Err(_) => generic_iter!(generic, visitor),
                         }
@@ -755,7 +755,7 @@ where
                             Ok(traceevent::print::parse_print_fmt(header, print_fmt.as_bytes())?)
                         };
 
-                        let make_schema = |print_fmt: PrintFmtStr| -> Result<_, Rc<MainError>> {
+                        let make_schema = |print_fmt: PrintFmtStr| {
                             let (meta_event_name, full_schema, fields_schema) =
                                 Self::make_print_fmt_schemas(header, &print_fmt)?;
 
@@ -765,8 +765,8 @@ where
                                 self.options,
                                 &format!("trace_printk@{meta_event_name}"),
                                 self.scope,
-                            ).map_err(Rc::new)?;
-                            Ok((Rc::new(RefCell::new(state)), print_fmt))
+                            )?;
+                            Ok((RefCell::new(state), print_fmt))
                         };
 
                         let entry = match parse_print_fmt() {
@@ -776,13 +776,13 @@ where
                                 match meta_events_by_fmt.get(&print_fmt) {
                                     Some(res) => res.clone(),
                                     None => {
-                                        let entry = make_schema(print_fmt.clone());
+                                        let entry = Rc::new(make_schema(print_fmt.clone()));
                                         meta_events_by_fmt.insert(print_fmt, entry.clone());
                                         entry
                                     },
                                 }
                             }
-                            Err(_) => Err(Rc::new(MainError::NotAMetaEvent)),
+                            Err(_) => Rc::new(Err(MainError::NotAMetaEvent)),
                         };
 
                         meta_events_by_addr.insert(addr, entry);
@@ -811,7 +811,11 @@ where
                 Box::new(
                     [generic].into_iter().chain(
                         std::iter::from_fn(move || meta_events_by_fmt.pop_first())
-                            .filter_map(|(_k, v)| v.map(|(state, _)| Rc::into_inner(state).unwrap().into_inner()).ok()),
+                            .filter_map(|(_, entry)| {
+                                let (table_state, _) = Rc::into_inner(entry).unwrap().ok()?;
+                                let table_state = RefCell::into_inner(table_state);
+                                Some(table_state)
+                            })
                     ),
                 ) as Box<dyn Iterator<Item = _>>
             }