Function parse_into

crates/wizer/src/component/parse.rs:29–199

(
    mut cx: Option<&mut ComponentContext<'a>>,
    full_wasm: &'a [u8],
    mut iter: impl Iterator<Item = wasmparser::Result<Payload<'a>>>,
)

}

fn parse_into<'a>(
    mut cx: Option<&mut ComponentContext<'a>>,
    full_wasm: &'a [u8],
    mut iter: impl Iterator<Item = wasmparser::Result<Payload<'a>>>,
) -> wasmtime::Result<()> {
    let mut stack = Vec::new();
    while let Some(payload) = iter.next() {
        let payload = payload?;

        match &payload {
            // Module sections get parsed with wizer's core wasm support.
            Payload::ModuleSection { .. } => match &mut cx {
                Some(component) => {
                    let info = crate::parse::parse_with(&full_wasm, &mut iter)?;
                    component.push_module_section(info);
                }
                None => {
                    bail!("nested components with modules not currently supported");
                }
            },

            // All other sections get pushed raw as-is into the component.
            _ => {
                if let Some((id, range)) = payload.as_section()
                    && let Some(component) = &mut cx
                {
                    component.push_raw_section(wasm_encoder::RawSection {
                        id,
                        data: &full_wasm[range],
                    });
                }
            }
        }

        // Further validation/handling of each section, mostly about maintaining
        // index spaces so we know what indices are used when the instrumented
        // component is produced.
        match payload {
            Payload::Version {
                encoding: Encoding::Module,
                ..
            } => {
                bail!("expected a component, found a core module");
            }

            Payload::ComponentSection { .. } => {
                stack.push(cx.take());
            }

            Payload::End(_) => {
                if stack.len() > 0 {
                    cx = stack.pop().unwrap();
                }
            }

            Payload::InstanceSection(reader) => {
                if let Some(component) = &mut cx {
                    for instance in reader {