Method print_ty

crates/rust/src/interface.rs:1789–1855

(&mut self, ty: &Type, mode: TypeMode)

    }

    fn print_ty(&mut self, ty: &Type, mode: TypeMode) {
        // If we have a typedef of a string, list, or map, the typedef is an
        // alias for `String`, `Vec<T>`, or `Map<K, V>`. If this is a borrow,
        // instead of borrowing them as `&String` or `&Vec<T>`, use `&str` or
        // `&[T]` so that callers don't need to create owned copies. Maps are
        // borrowed as `&Map<K, V>`.
        if let Type::Id(id) = ty {
            let id = dealias(self.resolve, *id);
            let typedef = &self.resolve.types[id];
            match &typedef.kind {
                TypeDefKind::Type(Type::String) => {
                    if let Some(lt) = mode.lifetime {
                        self.print_borrowed_str(lt);
                        return;
                    }
                }
                TypeDefKind::List(element) => {
                    if mode.lifetime.is_some() {
                        self.print_list(element, mode);
                        return;
                    }
                }
                TypeDefKind::Map(key, value) => {
                    if mode.lifetime.is_some() {
                        self.print_map(key, value, mode);
                        return;
                    }
                }
                _ => {}
            }
        }

        match ty {
            Type::Id(t) => self.print_tyid(*t, mode),
            Type::Bool => self.push_str("bool"),
            Type::U8 => self.push_str("u8"),
            Type::U16 => self.push_str("u16"),
            Type::U32 => self.push_str("u32"),
            Type::U64 => self.push_str("u64"),
            Type::S8 => self.push_str("i8"),
            Type::S16 => self.push_str("i16"),
            Type::S32 => self.push_str("i32"),
            Type::S64 => self.push_str("i64"),
            Type::F32 => self.push_str("f32"),
            Type::F64 => self.push_str("f64"),
            Type::Char => self.push_str("char"),
            Type::String => {
                assert_eq!(mode.lists_borrowed, mode.lifetime.is_some());
                match mode.lifetime {
                    Some(lt) => self.print_borrowed_str(lt),
                    None => {
                        if self.r#gen.opts.raw_strings {
                            self.push_vec_name();
                            self.push_str("::<u8>");
                        } else {
                            self.push_string_name();
                        }
                    }