fn error_at(&self, mut i: usize) -> Vec<O> {
        let mut error_stack = self.scratch.replace(vec![]);
        let mut trace = vec![];

        loop {
            let node = &self.nodes[i];
            node.state.set(NodeState::Error);
            trace.push(node.obligation.clone());
            error_stack.extend(node.dependents.iter().map(|index| index.index()));

            // Loop to the parent.
            match node.parent {
                Some(parent_index) => i = parent_index.index(),
                None => break
            }
        }

        while let Some(i) = error_stack.pop() {
            let node = &self.nodes[i];
            match node.state.get() {
                NodeState::Error => continue,
                _ => node.state.set(NodeState::Error),
            }

            error_stack.extend(
                node.parent.iter().chain(node.dependents.iter()).map(|index| index.index())
            );
        }

        self.scratch.replace(error_stack);
        trace
    }
/// Returns a vector of obligations for `p` and all of its
/// ancestors, putting them into the error state in the process.
Returns a vector of obligations for `p` and all of its
ancestors, putting them into the error state in the process.
Returns a vector of obligations for ` p ` and all of its ancestors putting them into the error state in the process .
fn error_at(&self, mut i: usize) -> Vec<O> {
        let mut error_stack = self.scratch.replace(vec![]);
        let mut trace = vec![];
        loop {
            let node = &self.nodes[i];
            node.state.set(NodeState::Error);
            trace.push(node.obligation.clone());
            error_stack.extend(node.dependents.iter().map(|index| index.index()));
            // Loop to the parent.
            match node.parent {
                Some(parent_index) => i = parent_index.index(),
                None => break
            }
        }
        while let Some(i) = error_stack.pop() {
            let node = &self.nodes[i];
            match node.state.get() {
                NodeState::Error => continue,
                _ => node.state.set(NodeState::Error),
            }
            error_stack.extend(
                node.parent.iter().chain(node.dependents.iter()).map(|index| index.index())
            );
        }
        self.scratch.replace(error_stack);
        trace
    }
fn error_at ( & self , mut i : usize ) -> Vec < O > { let mut error_stack = self . scratch . replace ( vec ! [ ] ) ; let mut trace = vec ! [ ] ; loop { let node = & self . nodes [ i ] ; node . state . set ( NodeState :: Error ) ; trace . push ( node . obligation . clone ( ) ) ; error_stack . extend ( node . dependents . iter ( ) . map ( | index | index . index ( ) ) ) ; // Loop to the parent. match node . parent { Some ( parent_index ) => i = parent_index . index ( ) , None => break } } while let Some ( i ) = error_stack . pop ( ) { let node = & self . nodes [ i ] ; match node . state . get ( ) { NodeState :: Error => continue , _ => node . state . set ( NodeState :: Error ) , } error_stack . extend ( node . parent . iter ( ) . chain ( node . dependents . iter ( ) ) . map ( | index | index . index ( ) ) ) ; } self . scratch . replace ( error_stack ) ; trace }
Returns a vector of obligations for `p` and all of its
ancestors, putting them into the error state in the process.
Returns a vector of obligations for ` p ` and all of its ancestors putting them into the error state in the process .
&self
i
usize