pub fn could_throw(&self) -> bool {
        let f_content = self.content.as_ref().unwrap();

        for (_, block) in f_content.blocks.iter() {
            let block_content = block.content.as_ref().unwrap();

            for inst in block_content.body.iter() {
                match inst.v {
                    TreeNode_::Instruction(ref inst) => {
                        if inst.is_potentially_throwing() {
                            // TODO: Do some smarter checking
                            // (e.g. if this is a CALL to a function where !could_throw,
                            // or a division where the divisor can't possibly be zero..)
                            return true;
                        }
                    }
                    _ => unreachable!()
                }
            }
        }

        false
    }
// TODO: It may be more efficient to compute this when the instructions
// are added to the function version and store the result in a field
It may be more efficient to compute this when the instructions
are added to the function version and store the result in a field
It may be more efficient to compute this when the instructions are added to the function version and store the result in a field
pub fn could_throw(&self) -> bool {
        let f_content = self.content.as_ref().unwrap();
        for (_, block) in f_content.blocks.iter() {
            let block_content = block.content.as_ref().unwrap();
            for inst in block_content.body.iter() {
                match inst.v {
                    TreeNode_::Instruction(ref inst) => {
                        if inst.is_potentially_throwing() {
                            // TODO: Do some smarter checking
                            // (e.g. if this is a CALL to a function where !could_throw,
                            // or a division where the divisor can't possibly be zero..)
                            return true;
                        }
                    }
                    _ => unreachable!()
                }
            }
        }
        false
    }
pub fn could_throw ( & self ) -> bool { let f_content = self . content . as_ref ( ) . unwrap ( ) ; for ( _ , block ) in f_content . blocks . iter ( ) { let block_content = block . content . as_ref ( ) . unwrap ( ) ; for inst in block_content . body . iter ( ) { match inst . v { TreeNode_ :: Instruction ( ref inst ) => { if inst . is_potentially_throwing ( ) { // TODO: Do some smarter checking // (e.g. if this is a CALL to a function where !could_throw, // or a division where the divisor can't possibly be zero..) return true ; } } _ => unreachable ! ( ) } } } false }
TODO: It may be more efficient to compute this when the instructions
are added to the function version and store the result in a field
TODO : It may be more efficient to compute this when the instructions are added to the function version and store the result in a field
&self
&self