Skip to content

Commit 7d81376

Browse files
coolreader18coolreader18
committed
Move io.rs over to vm.call_method
1 parent f50f930 commit 7d81376

1 file changed

Lines changed: 39 additions & 56 deletions

File tree

‎vm/src/stdlib/io.rs‎

Lines changed: 39 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -259,7 +259,7 @@ mod _io {
259259
}
260260

261261
fn check_readable(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
262-
if pybool::boolval(vm, call_method(vm, file, "readable", ())?)? {
262+
if pybool::boolval(vm, vm.call_method(file, "readable", ())?)? {
263263
Ok(())
264264
} else {
265265
Err(new_unsupported_operation(
@@ -270,7 +270,7 @@ mod _io {
270270
}
271271

272272
fn check_writable(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
273-
if pybool::boolval(vm, call_method(vm, file, "writable", ())?)? {
273+
if pybool::boolval(vm, vm.call_method(file, "writable", ())?)? {
274274
Ok(())
275275
} else {
276276
Err(new_unsupported_operation(
@@ -281,7 +281,7 @@ mod _io {
281281
}
282282

283283
fn check_seekable(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
284-
if pybool::boolval(vm, call_method(vm, file, "seekable", ())?)? {
284+
if pybool::boolval(vm, vm.call_method(file, "seekable", ())?)? {
285285
Ok(())
286286
} else {
287287
Err(new_unsupported_operation(
@@ -308,7 +308,7 @@ mod _io {
308308
}
309309
#[pymethod]
310310
fn tell(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
311-
call_method(vm, &zelf, "seek", (0, 1))
311+
vm.call_method(&zelf, "seek", (0, 1))
312312
}
313313
#[pymethod]
314314
fn truncate(zelf: PyObjectRef, _pos: OptionalArg, vm: &VirtualMachine) -> PyResult {
@@ -328,7 +328,7 @@ mod _io {
328328

329329
#[pyslot]
330330
fn tp_del(instance: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
331-
let _ = call_method(vm, instance, "close", ());
331+
let _ = vm.call_method(instance, "close", ());
332332
Ok(())
333333
}
334334

@@ -339,7 +339,7 @@ mod _io {
339339

340340
#[pymethod(magic)]
341341
fn exit(instance: PyObjectRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
342-
call_method(vm, &instance, "close", ())?;
342+
vm.call_method(&instance, "close", ())?;
343343
Ok(())
344344
}
345345

@@ -428,7 +428,7 @@ mod _io {
428428
) -> PyResult<()> {
429429
check_closed(&instance, vm)?;
430430
for line in lines.iter(vm)? {
431-
call_method(vm, &instance, "write", (line?,))?;
431+
vm.call_method(&instance, "write", (line?,))?;
432432
}
433433
Ok(())
434434
}
@@ -461,7 +461,7 @@ mod _io {
461461
}
462462
#[pyslot]
463463
fn tp_iternext(instance: &PyObjectRef, vm: &VirtualMachine) -> PyResult {
464-
let line = call_method(vm, &instance, "readline", ())?;
464+
let line = vm.call_method(&instance, "readline", ())?;
465465
if !pybool::boolval(vm, line.clone())? {
466466
Err(vm.new_stop_iteration())
467467
} else {
@@ -476,7 +476,7 @@ mod _io {
476476

477477
pub(super) fn iobase_close(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
478478
if !file_closed(file, vm)? {
479-
let res = call_method(vm, file, "flush", ());
479+
let res = vm.call_method(file, "flush", ());
480480
vm.set_attr(file, "__closed", vm.ctx.new_bool(true))?;
481481
res?;
482482
}
@@ -496,7 +496,7 @@ mod _io {
496496
let b = PyByteArray::from(vec![0; size]).into_ref(vm);
497497
let n = <Option<usize>>::try_from_object(
498498
vm,
499-
call_method(vm, &instance, "readinto", (b.clone(),))?,
499+
vm.call_method(&instance, "readinto", (b.clone(),))?,
500500
)?;
501501
Ok(n.map(|n| {
502502
let bytes = &mut b.borrow_value_mut().elements;
@@ -505,7 +505,7 @@ mod _io {
505505
})
506506
.into_pyobject(vm))
507507
} else {
508-
call_method(vm, &instance, "readall", ())
508+
vm.call_method(&instance, "readall", ())
509509
}
510510
}
511511

@@ -514,7 +514,7 @@ mod _io {
514514
let mut chunks = Vec::new();
515515
let mut total_len = 0;
516516
loop {
517-
let data = call_method(vm, &instance, "read", (DEFAULT_BUFFER_SIZE,))?;
517+
let data = vm.call_method(&instance, "read", (DEFAULT_BUFFER_SIZE,))?;
518518
let data = <Option<PyBytesRef>>::try_from_object(vm, data)?;
519519
match data {
520520
None => {
@@ -562,7 +562,7 @@ mod _io {
562562
) -> PyResult<usize> {
563563
let b = PyRwBytesLike::new(vm, &bufobj)?;
564564
let l = b.len();
565-
let data = call_method(vm, &zelf, method, (l,))?;
565+
let data = vm.call_method(&zelf, method, (l,))?;
566566
if data.is(&bufobj) {
567567
return Ok(l);
568568
}
@@ -732,7 +732,7 @@ mod _io {
732732
}
733733

734734
fn raw_seek(&mut self, pos: Offset, whence: i32, vm: &VirtualMachine) -> PyResult<Offset> {
735-
let ret = call_method(vm, self.check_init(vm)?, "seek", (pos, whence))?;
735+
let ret = vm.call_method(self.check_init(vm)?, "seek", (pos, whence))?;
736736
let offset = get_offset(ret, vm)?;
737737
if offset < 0 {
738738
return Err(
@@ -777,7 +777,7 @@ mod _io {
777777
}
778778

779779
fn raw_tell(&mut self, vm: &VirtualMachine) -> PyResult<Offset> {
780-
let ret = call_method(vm, self.check_init(vm)?, "tell", ())?;
780+
let ret = vm.call_method(self.check_init(vm)?, "tell", ())?;
781781
let offset = get_offset(ret, vm)?;
782782
if offset < 0 {
783783
return Err(
@@ -809,7 +809,7 @@ mod _io {
809809
.into_pyobject(vm);
810810

811811
// TODO: loop if write() raises an interrupt
812-
call_method(vm, self.raw.as_ref().unwrap(), "write", (memobj,))?
812+
vm.call_method(self.raw.as_ref().unwrap(), "write", (memobj,))?
813813
} else {
814814
let options = BufferOptions {
815815
len,
@@ -827,7 +827,7 @@ mod _io {
827827
.into_ref(vm);
828828

829829
// TODO: loop if write() raises an interrupt
830-
let res = call_method(vm, self.raw.as_ref().unwrap(), "write", (memobj.clone(),));
830+
let res = vm.call_method(self.raw.as_ref().unwrap(), "write", (memobj.clone(),));
831831

832832
memobj.released.store(true);
833833
self.buffer = std::mem::take(&mut writebuf.data.lock());
@@ -1064,12 +1064,8 @@ mod _io {
10641064
.into_ref(vm);
10651065

10661066
// TODO: loop if readinto() raises an interrupt
1067-
let res = call_method(
1068-
vm,
1069-
self.raw.as_ref().unwrap(),
1070-
"readinto",
1071-
(memobj.clone(),),
1072-
);
1067+
let res =
1068+
vm.call_method(self.raw.as_ref().unwrap(), "readinto", (memobj.clone(),));
10731069

10741070
memobj.released.store(true);
10751071
std::mem::swap(v, &mut readbuf.data.lock());
@@ -1080,7 +1076,7 @@ mod _io {
10801076
let memobj =
10811077
PyMemoryView::from_buffer_range(vm.ctx.none(), buf, buf_range, vm)?;
10821078
// TODO: loop if readinto() raises an interrupt
1083-
call_method(vm, self.raw.as_ref().unwrap(), "readinto", (memobj,))?
1079+
vm.call_method(self.raw.as_ref().unwrap(), "readinto", (memobj,))?
10841080
}
10851081
};
10861082

@@ -1135,7 +1131,7 @@ mod _io {
11351131

11361132
let mut read_size = 0;
11371133
loop {
1138-
let read_data = call_method(vm, self.raw.as_ref().unwrap(), "read", ())?;
1134+
let read_data = vm.call_method(self.raw.as_ref().unwrap(), "read", ())?;
11391135
let read_data = <Option<PyBytesRef>>::try_from_object(vm, read_data)?;
11401136

11411137
match read_data {
@@ -1388,13 +1384,13 @@ mod _io {
13881384
if data.writable() {
13891385
data.flush_rewind(vm)?;
13901386
}
1391-
let res = call_method(vm, data.raw.as_ref().unwrap(), "truncate", (pos,))?;
1387+
let res = vm.call_method(data.raw.as_ref().unwrap(), "truncate", (pos,))?;
13921388
let _ = data.raw_tell(vm);
13931389
Ok(res)
13941390
}
13951391
#[pymethod]
13961392
fn detach(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
1397-
call_method(vm, zelf.as_object(), "flush", ())?;
1393+
vm.call_method(zelf.as_object(), "flush", ())?;
13981394
let mut data = zelf.lock(vm)?;
13991395
data.flags.insert(BufferedFlags::DETACHED);
14001396
data.raw
@@ -1403,7 +1399,7 @@ mod _io {
14031399
}
14041400
#[pymethod]
14051401
fn seekable(&self, vm: &VirtualMachine) -> PyResult {
1406-
call_method(vm, self.lock(vm)?.check_init(vm)?, "seekable", ())
1402+
vm.call_method(self.lock(vm)?.check_init(vm)?, "seekable", ())
14071403
}
14081404
#[pyproperty]
14091405
fn raw(&self, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
@@ -1423,11 +1419,11 @@ mod _io {
14231419
}
14241420
#[pymethod]
14251421
fn fileno(&self, vm: &VirtualMachine) -> PyResult {
1426-
call_method(vm, self.lock(vm)?.check_init(vm)?, "fileno", ())
1422+
vm.call_method(self.lock(vm)?.check_init(vm)?, "fileno", ())
14271423
}
14281424
#[pymethod]
14291425
fn isatty(&self, vm: &VirtualMachine) -> PyResult {
1430-
call_method(vm, self.lock(vm)?.check_init(vm)?, "isatty", ())
1426+
vm.call_method(self.lock(vm)?.check_init(vm)?, "isatty", ())
14311427
}
14321428

14331429
#[pymethod(magic)]
@@ -1464,7 +1460,7 @@ mod _io {
14641460
return Ok(vm.ctx.none());
14651461
}
14661462
let flush_res = data.flush(vm);
1467-
let close_res = call_method(vm, data.raw.as_ref().unwrap(), "close", ());
1463+
let close_res = vm.call_method(data.raw.as_ref().unwrap(), "close", ());
14681464
exceptions::chain(flush_res, close_res)
14691465
}
14701466

@@ -1477,10 +1473,10 @@ mod _io {
14771473
return Ok(vm.ctx.none());
14781474
}
14791475
}
1480-
let flush_res = call_method(vm, zelf.as_object(), "flush", ()).map(drop);
1476+
let flush_res = vm.call_method(zelf.as_object(), "flush", ()).map(drop);
14811477
let data = zelf.lock(vm)?;
14821478
let raw = data.raw.as_ref().unwrap();
1483-
let close_res = call_method(vm, raw, "close", ());
1479+
let close_res = vm.call_method(raw, "close", ());
14841480
exceptions::chain(flush_res, close_res)
14851481
}
14861482

@@ -1500,19 +1496,6 @@ mod _io {
15001496
}
15011497
}
15021498

1503-
// vm.call_method() only calls class attributes
1504-
// TODO: have this be the implementation of vm.call_method() once the current implementation isn't needed
1505-
// anymore because of slots
1506-
pub fn call_method(
1507-
vm: &VirtualMachine,
1508-
obj: &PyObjectRef,
1509-
name: impl crate::pyobject::TryIntoRef<PyStr>,
1510-
args: impl crate::function::IntoFuncArgs,
1511-
) -> PyResult {
1512-
let meth = vm.get_attribute(obj.clone(), name)?;
1513-
vm.invoke(&meth, args)
1514-
}
1515-
15161499
#[pyimpl]
15171500
trait BufferedReadable: PyValue {
15181501
type Reader: BufferedMixin;
@@ -1921,13 +1904,13 @@ mod _io {
19211904
"can't do nonzero end-relative seeks".to_owned(),
19221905
));
19231906
}
1924-
call_method(vm, &buffer, "seek", (offset, how))
1907+
vm.call_method(&buffer, "seek", (offset, how))
19251908
}
19261909

19271910
#[pymethod]
19281911
fn tell(&self, vm: &VirtualMachine) -> PyResult {
19291912
let buffer = self.lock(vm)?.buffer.clone();
1930-
call_method(vm, &buffer, "tell", ())
1913+
vm.call_method(&buffer, "tell", ())
19311914
}
19321915

19331916
#[pyproperty]
@@ -1947,15 +1930,15 @@ mod _io {
19471930
#[pymethod]
19481931
fn fileno(&self, vm: &VirtualMachine) -> PyResult {
19491932
let buffer = self.lock(vm)?.buffer.clone();
1950-
call_method(vm, &buffer, "fileno", ())
1933+
vm.call_method(&buffer, "fileno", ())
19511934
}
19521935

19531936
#[pymethod]
19541937
fn read(&self, size: OptionalOption<PyObjectRef>, vm: &VirtualMachine) -> PyResult<String> {
19551938
let buffer = self.lock(vm)?.buffer.clone();
19561939
check_readable(&buffer, vm)?;
19571940

1958-
let bytes = call_method(vm, &buffer, "read", (size.flatten(),))?;
1941+
let bytes = vm.call_method(&buffer, "read", (size.flatten(),))?;
19591942
let bytes = PyBytesLike::try_from_object(vm, bytes)?;
19601943
//format bytes into string
19611944
let rust_string = String::from_utf8(bytes.to_cow().into_owned()).map_err(|e| {
@@ -1976,9 +1959,9 @@ mod _io {
19761959

19771960
let bytes = obj.borrow_value().as_bytes();
19781961

1979-
let len = call_method(vm, &buffer, "write", (bytes.to_owned(),));
1962+
let len = vm.call_method(&buffer, "write", (bytes.to_owned(),));
19801963
if obj.borrow_value().contains('\n') {
1981-
let _ = call_method(vm, &buffer, "flush", ());
1964+
let _ = vm.call_method(&buffer, "flush", ());
19821965
}
19831966
let len = usize::try_from_object(vm, len?)?;
19841967

@@ -1994,14 +1977,14 @@ mod _io {
19941977
fn flush(&self, vm: &VirtualMachine) -> PyResult {
19951978
let buffer = self.lock(vm)?.buffer.clone();
19961979
check_closed(&buffer, vm)?;
1997-
call_method(vm, &buffer, "flush", ())
1980+
vm.call_method(&buffer, "flush", ())
19981981
}
19991982

20001983
#[pymethod]
20011984
fn isatty(&self, vm: &VirtualMachine) -> PyResult {
20021985
let buffer = self.lock(vm)?.buffer.clone();
20031986
check_closed(&buffer, vm)?;
2004-
call_method(vm, &buffer, "isatty", ())
1987+
vm.call_method(&buffer, "isatty", ())
20051988
}
20061989

20071990
#[pymethod]
@@ -2013,7 +1996,7 @@ mod _io {
20131996
let buffer = self.lock(vm)?.buffer.clone();
20141997
check_readable(&buffer, vm)?;
20151998

2016-
let bytes = call_method(vm, &buffer, "readline", (size.flatten(),))?;
1999+
let bytes = vm.call_method(&buffer, "readline", (size.flatten(),))?;
20172000
let bytes = PyBytesLike::try_from_object(vm, bytes)?;
20182001
//format bytes into string
20192002
let rust_string = String::from_utf8(bytes.borrow_value().to_vec()).map_err(|e| {
@@ -2028,7 +2011,7 @@ mod _io {
20282011
#[pymethod]
20292012
fn close(&self, vm: &VirtualMachine) -> PyResult {
20302013
let buffer = self.lock(vm)?.buffer.clone();
2031-
call_method(vm, &buffer, "close", ())
2014+
vm.call_method(&buffer, "close", ())
20322015
}
20332016
#[pyproperty]
20342017
fn closed(&self, vm: &VirtualMachine) -> PyResult {

0 commit comments

Comments
 (0)