Struct ParsedPipeline 

pub struct ParsedPipeline {
    pub segments: Vec<ShellSegment>,
    pub operators: Vec<Operator>,
    pub structural_substitutions: Vec<SubstitutionSpan>,
    pub has_parse_errors: bool,
}

A fully decomposed compound command.

This is a recursive structure: segments may contain substitutions, and each substitution contains a recursively-parsed ParsedPipeline. Evaluation proceeds bottom-up (a catamorphism): inner substitutions are evaluated first, their output feeds the outer command.

Fields

segments: Vec<ShellSegment>

operators: Vec<Operator>

Operators between consecutive segments.

structural_substitutions: Vec<SubstitutionSpan>

Substitutions in non-command structural positions: for-loop iteration values (for i in $(cmd)), case subjects (case $(cmd) in).

These execute before any segment in this pipeline. Each is recursively parsed.

has_parse_errors: bool

true when tree-sitter produced error-recovery nodes in the AST.

The pipeline is still usable — tree-sitter always produces a tree — but callers should treat the result as best-effort.

Implementations

impl ParsedPipeline

pub fn empty_with_error() -> Self

An empty pipeline representing a parse failure.

pub fn find_pipeline<T>( &self, f: &impl Fn(&ParsedPipeline) -> Option<T>, ) -> Option<T>

Walk all pipelines in the tree (this one and all nested ones), depth-first. Returns the first Some(T) produced by f.

This is the lowest-level traversal primitive — it visits pipeline nodes rather than segments, enabling checks on pipeline-level properties (like has_parse_errors).

pub fn any_pipeline(&self, f: &impl Fn(&ParsedPipeline) -> bool) -> bool

Returns true if any pipeline in the tree satisfies f.

pub fn find_segment<T>( &self, f: &impl Fn(&ShellSegment) -> Option<T>, ) -> Option<T>

Walk the pipeline tree depth-first in execution order, applying f to each ShellSegment. Returns the first Some(T) produced by f, or None if every segment returns None.

Traversal order mirrors shell evaluation:

1. Structural substitutions (for-loop values, case subjects)
2. For each segment: its substitutions first, then the segment itself

This is the canonical way to inspect every command in the tree. Both “does any segment satisfy P?” and “find the first segment matching P” reduce to this.

pub fn filter_segments<T>( &self, f: &impl Fn(&ShellSegment) -> Option<T>, ) -> Vec<T>

Walk the pipeline tree depth-first, applying f to each ShellSegment and collecting every non-None result.

Same traversal order as find_segment but does not short-circuit.

pub fn has_parse_errors_recursive(&self) -> bool

Returns true if this pipeline or any nested substitution has parse errors.

When tree-sitter uses error recovery, some commands may not have been extracted. Callers enforcing a security boundary should treat a true return as “cannot safely analyze — fail closed.”

Trait Implementations

impl Clone for ParsedPipeline

fn clone(&self) -> ParsedPipeline

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParsedPipeline

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.