Method import_interface

crates/csharp/src/world_generator.rs:176–223

(
        &mut self,
        resolve: &Resolve,
        key: &WorldKey,
        id: InterfaceId,
        _files: &mut Files,
    )

    }

    fn import_interface(
        &mut self,
        resolve: &Resolve,
        key: &WorldKey,
        id: InterfaceId,
        _files: &mut Files,
    ) -> anyhow::Result<()> {
        let name = interface_name(self, resolve, key, Direction::Import);
        self.interface_names.insert(id, name.clone());
        let mut r#gen = self.interface(resolve, &name, Direction::Import, false);

        let mut old_resources = mem::take(&mut r#gen.csharp_gen.all_resources);
        r#gen.types(id);
        let new_resources = mem::take(&mut r#gen.csharp_gen.all_resources);
        old_resources.extend(new_resources.clone());
        r#gen.csharp_gen.all_resources = old_resources;
        let import_module_name = &resolve.name_world_key(key);
        for (resource, funcs) in by_resource(
            resolve.interfaces[id]
                .functions
                .iter()
                .map(|(k, v)| (k.as_str(), v)),
            new_resources.keys().copied(),
        ) {
            if let Some(resource) = resource {
                r#gen.start_resource(resource, Some(key));
            }

            for func in funcs {
                r#gen.import(import_module_name, func);
            }

            if resource.is_some() {
                r#gen.end_resource();
            }
        }

        // for anonymous types
        r#gen.define_interface_types(id);

        r#gen.add_futures_or_streams(import_module_name, false, true);

        r#gen.add_futures_or_streams(import_module_name, false, false);

        r#gen.add_interface_fragment(false);

        Ok(())
    }

    fn import_funcs(
        &mut self,