Struct PlannedHeredoc 

#[non_exhaustive]
pub struct PlannedHeredoc {
    pub index: usize,
    pub delimiter: String,
    pub literal: bool,
    pub strip_tabs: bool,
    pub body: PlannedValue,
    pub body_offset: usize,
    pub free_variables: Vec<String>,
}

One heredoc a PlannedCommand reads on stdin — the body a command is fed, published as data.

Agents hand whole programs to interpreters this way (python3 <<'PY', sqlite3 <<SQL), and the shell framing is the part that has to come off before anything can look at the program. It comes off here: the command name is on the PlannedCommand, the language hint is delimiter, and the program is body with no quoting or escaping applied.

literal decides what the body is worth. A quoted delimiter (<<'PY') means the body reaches the command exactly as published; an unquoted one means the shell expands ${…} and $(…) first, so the published text is what was asked for and not what runs.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

index: usize

The heredoc’s position among every heredoc in its statement, counted in source order across every command the statement contains. This is the heredoc half of a FragmentAddr.

delimiter: String

The delimiter word as written, quotes removed: PY for both <<PY and <<'PY'. Authors often pick it for the language they are about to write, but roughly half the time it says nothing — a bare EOF outnumbers every self-describing word combined in real agent traffic. A weak hint worth keeping, never a classification.

literal: bool

Whether the delimiter was quoted (<<'PY', <<"PY"). True means no expansion runs and body is exactly what the command reads.

strip_tabs: bool

Whether the <<- form was used. True means leading tabs come off each body line before the command sees it; the published body keeps them.

body: PlannedValue

The body as written, verbatim: no tab stripping, no expansion, no quoting, no kernel-internal rewriting. A generated program arrives whole and unescaped, ready to hand to whatever reads that language.

body_offset: usize

Byte offset of the body’s first character in the source that was planned, for a caller attributing a finding back to a location.

free_variables: Vec<String>

Session variables this body reads — sorted, deduplicated root names, and always empty when literal is true. These are the values that plug into the body, and the ones an expansion needs supplied.

Implementations

impl PlannedHeredoc

pub fn new( index: usize, delimiter: impl Into<String>, literal: bool, strip_tabs: bool, body: PlannedValue, body_offset: usize, ) -> PlannedHeredoc

Assemble one planned heredoc. The only constructor for this #[non_exhaustive] type.

pub fn with_free_variables(self, free: Vec<String>) -> PlannedHeredoc

Attach the body’s variable analysis (sorted, deduplicated).

Trait Implementations

impl Clone for PlannedHeredoc

fn clone(&self) -> PlannedHeredoc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlannedHeredoc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlannedHeredoc

fn deserialize<__D>( __deserializer: __D, ) -> Result<PlannedHeredoc, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for PlannedHeredoc

impl PartialEq for PlannedHeredoc

fn eq(&self, other: &PlannedHeredoc) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for PlannedHeredoc

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PlannedHeredoc