Enum PolicyIncomplete 

pub enum PolicyIncomplete {
    NotUtf8 {
        path: Vec<u8>,
    },
    ManifestSyntax {
        path: Vec<u8>,
        detail: String,
    },
    ManifestShape {
        path: Vec<u8>,
        problem: String,
    },
    DuplicateName {
        name: String,
        first: Vec<u8>,
        second: Vec<u8>,
    },
}

What: Why the planner’s own machinery could not finish although its input was read. Why: The engine reports each of these as policy-incomplete. ManifestShape carries the incumbent’s ManifestShapeError text exactly, so both implementations can be compared message for message.

In TS you’d write (pseudocode):

type PolicyIncomplete = { kind: 'not-utf8'; path } | { kind: 'manifest-syntax'; path; detail } | { kind: 'manifest-shape'; path; problem } | { kind: 'duplicate-name'; name; first; second };

Variants

NotUtf8

A manifest or the registry configuration is not valid UTF-8.

Fields

path: Vec<u8>

The file that failed to decode.

ManifestSyntax

A manifest is not JSON.

Fields

path: Vec<u8>

The manifest.

detail: String

The parser’s explanation.

ManifestShape

A manifest is JSON but lacks a fact the plan needs, or its version cannot be rewritten in place.

Fields

path: Vec<u8>

The manifest.

problem: String

The incumbent’s message, which names the manifest.

DuplicateName

Two workspace manifests declare the same package name, so the dependency graph is ambiguous.

Fields

name: String

The shared name.

first: Vec<u8>

The earlier manifest in tracked order.

second: Vec<u8>

The later manifest.

Trait Implementations

impl Clone for PolicyIncomplete

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PolicyIncomplete

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

Formats the value using the given formatter.

impl Eq for PolicyIncomplete

impl From<PolicyIncomplete> for PlanError

What: Lift a machinery failure into a planning failure. Why: Lets the planner write read_manifest_facts(...)?.

In TS you’d write (pseudocode):

const failure: PlanError = { kind: 'policy-incomplete', error };

fn from(error: PolicyIncomplete) -> PlanError

Wrap the machinery failure.

impl PartialEq for PolicyIncomplete

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PolicyIncomplete