Method collect

crates/rustc_codegen_spirv/src/custom_decorations.rs:233–314

(module: Either<&'a Module, &'a spirt::Module>)

impl<'a> SpvDebugInfo<'a> {
    fn collect(module: Either<&'a Module, &'a spirt::Module>) -> Self {
        let mut this = Self::default();

        let module = match module {
            Either::Left(module) => module,

            // HACK(eddyb) the SPIR-T codepath is simpler, and kind of silly,
            // but we need the `SpvDebugFile`'s `regenerated_rustc_source_file`
            // caching, so for now it reuses `SpvDebugInfo` overall.
            Either::Right(module) => {
                let cx = module.cx_ref();
                match &module.debug_info {
                    spirt::ModuleDebugInfo::Spv(debug_info) => {
                        for sources in debug_info.source_languages.values() {
                            for (&file_name, src) in &sources.file_contents {
                                // FIXME(eddyb) what if the file is already present,
                                // should it be considered ambiguous overall?
                                this.files
                                    .entry(&cx[file_name])
                                    .or_default()
                                    .op_source_parts = [&src[..]].into_iter().collect();
                            }
                        }
                    }
                }
                return this;
            }
        };

        // FIXME(eddyb) avoid repeating this across different passes/helpers.
        this.custom_ext_inst_set_import = module
            .ext_inst_imports
            .iter()
            .find(|inst| {
                assert_eq!(inst.class.opcode, Op::ExtInstImport);
                inst.operands[0].unwrap_literal_string() == &custom_insts::CUSTOM_EXT_INST_SET[..]
            })
            .map(|inst| inst.result_id.unwrap());

        this.id_to_op_constant_operand.extend(
            module
                .types_global_values
                .iter()
                .filter(|inst| inst.class.opcode == Op::Constant)
                .map(|inst| (inst.result_id.unwrap(), &inst.operands[0])),
        );

        let mut insts = module.debug_string_source.iter().peekable();
        while let Some(inst) = insts.next() {
            match inst.class.opcode {
                Op::String => {
                    this.id_to_op_string.insert(
                        inst.result_id.unwrap(),
                        inst.operands[0].unwrap_literal_string(),
                    );
                }
                Op::Source if inst.operands.len() == 4 => {
                    let file_name_id = inst.operands[2].unwrap_id_ref();