pub fn path(&self) -> Vec<TraceStep> {
        let mut path = Vec::new();
        self.with_spans(|metadata, _| {
            if metadata.target() == "r1cs" {
                let n = metadata.name();
                let step = metadata
                    .module_path()
                    .map(|m| (n, m))
                    .and_then(|(n, m)| metadata.file().map(|f| (n, m, f)))
                    .and_then(|(n, m, f)| metadata.line().map(|l| (n, m, f, l)));
                if let Some((name, module_path, file, line)) = step {
                    let step = TraceStep {
                        name,
                        module_path,
                        file,
                        line,
                    };
                    path.push(step);
                } else {
                    return false;
                }
            }
            true
        });
        path.reverse(); // root first
        path
    }
/// Compute a `Vec` of `TraceStep`s, one for each `Span` on the path from
/// the root `Span`.
///
/// The output starts from the root of the span tree.


The output starts from the root of the span tree.
The output starts from the root of the span tree .
pub fn path(&self) -> Vec<TraceStep> {
        let mut path = Vec::new();
        self.with_spans(|metadata, _| {
            if metadata.target() == "r1cs" {
                let n = metadata.name();
                let step = metadata
                    .module_path()
                    .map(|m| (n, m))
                    .and_then(|(n, m)| metadata.file().map(|f| (n, m, f)))
                    .and_then(|(n, m, f)| metadata.line().map(|l| (n, m, f, l)));
                if let Some((name, module_path, file, line)) = step {
                    let step = TraceStep {
                        name,
                        module_path,
                        file,
                        line,
                    };
                    path.push(step);
                } else {
                    return false;
                }
            }
            true
        });
        path.reverse(); // root first
        path
    }
pub fn path ( & self ) -> Vec < TraceStep > { let mut path = Vec :: new ( ) ; self . with_spans ( | metadata , _ | { if metadata . target ( ) == " " { let n = metadata . name ( ) ; let step = metadata . module_path ( ) . map ( | m | ( n , m ) ) . and_then ( | ( n , m ) | metadata . file ( ) . map ( | f | ( n , m , f ) ) ) . and_then ( | ( n , m , f ) | metadata . line ( ) . map ( | l | ( n , m , f , l ) ) ) ; if let Some ( ( name , module_path , file , line ) ) = step { let step = TraceStep { name , module_path , file , line , } ; path . push ( step ) ; } else { return false ; } } true } ) ; path . reverse ( ) ; // root first path }
Compute a `Vec` of `TraceStep`s, one for each `Span` on the path from
the root `Span`.
Compute a ` Vec ` of ` TraceStep ` s one for each ` Span ` on the path from the root ` Span ` .
&self
&self