Method resolve_missing_ntrs

plugins/pdb-ng/src/parser.rs:358–454

(
        &mut self,
        symbols: &Vec<ParsedSymbol>,
        progress: Box<dyn Fn(usize, usize) -> Result<()> + '_>,
    )

    }

    fn resolve_missing_ntrs(
        &mut self,
        symbols: &Vec<ParsedSymbol>,
        progress: Box<dyn Fn(usize, usize) -> Result<()> + '_>,
    ) -> Result<()> {
        let mut unknown_names = HashMap::new();
        let mut known_names = self
            .bv
            .types()
            .iter()
            .map(|qnat| qnat.name)
            .collect::<HashSet<_>>();

        for ty in &self.named_types {
            known_names.insert(ty.0.clone());
        }

        let count = symbols.len();
        for (i, sym) in symbols.iter().enumerate() {
            match sym {
                ParsedSymbol::Data(ParsedDataSymbol {
                    type_: Some(type_), ..
                }) => {
                    self.collect_names(type_.contents.as_ref(), &mut unknown_names);
                }
                ParsedSymbol::Procedure(ParsedProcedure {
                    type_: Some(type_),
                    locals,
                    ..
                }) => {
                    self.collect_names(type_.contents.as_ref(), &mut unknown_names);
                    for l in locals {
                        if let Some(ltype) = &l.type_ {
                            self.collect_names(ltype.contents.as_ref(), &mut unknown_names);
                        }
                    }
                }
                _ => {}
            }
            progress(i, count)?;
        }

        for (name, class) in unknown_names.into_iter() {
            if known_names.contains(&name) {
                self.log(|| format!("Found referenced name and ignoring: {}", &name));
                continue;
            }
            self.log(|| format!("Adding referenced but unknown type {} (likely due to demangled name and stripped type)", &name));
            match class {
                NamedTypeReferenceClass::UnknownNamedTypeClass
                | NamedTypeReferenceClass::TypedefNamedTypeClass => {
                    self.debug_info.add_type(&name, Type::void().as_ref(), &[]);
                    // TODO : Components
                }
                NamedTypeReferenceClass::ClassNamedTypeClass
                | NamedTypeReferenceClass::StructNamedTypeClass
                | NamedTypeReferenceClass::UnionNamedTypeClass => {
                    let mut structure = StructureBuilder::new();