Method repr

crates/vm/src/stdlib/_io.rs:4010–4054

(zelf: &Py<Self>, vm: &VirtualMachine)

    impl Representable for TextIOWrapper {
        #[inline]
        fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
            let type_name = zelf.class().slot_name();
            let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) else {
                return Err(
                    vm.new_runtime_error(format!("reentrant call inside {type_name}.__repr__"))
                );
            };
            let Some(data) = zelf.data.lock() else {
                // Reentrant call
                return Ok(vm.ctx.new_str(Wtf8Buf::from(format!("<{type_name}>"))));
            };
            let Some(data) = data.as_ref() else {
                return Err(vm.new_value_error("I/O operation on uninitialized object"));
            };

            let mut result = Wtf8Buf::from(format!("<{type_name}"));

            // Add name if present
            if let Ok(Some(name)) = vm.get_attribute_opt(data.buffer.clone(), "name") {
                let name_repr = name.repr(vm)?;
                result.push_wtf8(" name=".as_ref());
                result.push_wtf8(name_repr.as_wtf8());
            }

            // Add mode if present (prefer the wrapper's attribute)
            let mode_obj = match vm.get_attribute_opt(zelf.as_object().to_owned(), "mode") {
                Ok(Some(mode)) => Some(mode),
                Ok(None) | Err(_) => match vm.get_attribute_opt(data.buffer.clone(), "mode") {
                    Ok(Some(mode)) => Some(mode),
                    _ => None,
                },
            };
            if let Some(mode) = mode_obj {
                let mode_repr = mode.repr(vm)?;
                result.push_wtf8(" mode=".as_ref());
                result.push_wtf8(mode_repr.as_wtf8());
            }

            // Add encoding (always valid UTF-8)
            result.push_wtf8(" encoding='".as_ref());
            result.push_wtf8(data.encoding.as_str().as_ref());
            result.push_wtf8("'>".as_ref());

            Ok(vm.ctx.new_str(result))
        }

        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
            unreachable!("repr() is overridden directly")