feat: support pyo3 v0.25

Author: mtshiba

Cargo.lock

@@ -23,7 +23,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.6.53-nightly.5"
+version = "0.6.53"
 authors = ["erg-lang team <[email protected]>"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
@@ -75,13 +75,13 @@ log-level-error = ["erg_common/log-level-error", "erg_parser/log-level-error", "
 parallel = ["erg_common/parallel", "erg_parser/parallel", "erg_compiler/parallel", "erg_linter/parallel"]
 
 [workspace.dependencies]
-erg_common = { version = "0.6.53-nightly.5", path = "./crates/erg_common" }
-erg_parser = { version = "0.6.53-nightly.5", path = "./crates/erg_parser" }
-erg_compiler = { version = "0.6.53-nightly.5", path = "./crates/erg_compiler" }
-erg_linter = { version = "0.6.53-nightly.5", path = "./crates/erg_linter" }
-els = { version = "0.1.65-nightly.5", path = "./crates/els" }
-erg_proc_macros = { version = "0.6.53-nightly.5", path = "./crates/erg_proc_macros" }
-pyo3 = { version = "0.21", features = ["extension-module"] }
+erg_common = { version = "0.6.53", path = "./crates/erg_common" }
+erg_parser = { version = "0.6.53", path = "./crates/erg_parser" }
+erg_compiler = { version = "0.6.53", path = "./crates/erg_compiler" }
+erg_linter = { version = "0.6.53", path = "./crates/erg_linter" }
+els = { version = "0.1.65", path = "./crates/els" }
+erg_proc_macros = { version = "0.6.53", path = "./crates/erg_proc_macros" }
+pyo3 = { version = "0.25", features = ["extension-module"] }
 
 [dependencies]
 erg_common = { workspace = true }

Cargo.toml

@@ -2,7 +2,7 @@
 name = "els"
 description = "An Erg compiler frontend for IDEs, implements LSP."
 documentation = "http://docs.rs/els"
-version = "0.1.65-nightly.5"
+version = "0.1.65"
 authors.workspace = true
 license.workspace = true
 edition.workspace = true

crates/els/Cargo.toml

@@ -308,18 +308,21 @@ impl FromPyObject<'_> for Location {
 }
 
 #[cfg(feature = "pylib")]
-impl IntoPy<PyObject> for Location {
-    fn into_py(self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for Location {
+    type Target = pyo3::types::PyTuple;
+    type Output = Bound<'py, Self::Target>;
+    type Error = pyo3::PyErr;
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         match self {
-            Self::Line(l) => (l, py.None(), l, py.None()).into_py(py),
-            Self::LineRange(lb, le) => (lb, py.None(), le, py.None()).into_py(py),
+            Self::Line(l) => (l, py.None(), l, py.None()).into_pyobject(py),
+            Self::LineRange(lb, le) => (lb, py.None(), le, py.None()).into_pyobject(py),
             Self::Range {
                 ln_begin,
                 col_begin,
                 ln_end,
                 col_end,
-            } => (ln_begin, col_begin, ln_end, col_end).into_py(py),
-            Self::Unknown => (py.None(), py.None(), py.None(), py.None()).into_py(py),
+            } => (ln_begin, col_begin, ln_end, col_end).into_pyobject(py),
+            Self::Unknown => (py.None(), py.None(), py.None(), py.None()).into_pyobject(py),
         }
     }
 }

crates/erg_common/error.rs

@@ -11,7 +11,7 @@ use crate::{debug_fmt_iter, fmt_iter, get_hash};
 #[cfg(feature = "pylib")]
 use pyo3::prelude::PyAnyMethods;
 #[cfg(feature = "pylib")]
-use pyo3::{FromPyObject, IntoPy, PyAny, PyObject, Python};
+use pyo3::{Bound, FromPyObject, IntoPyObject, PyAny, Python};
 
 #[macro_export]
 macro_rules! set {
@@ -29,9 +29,12 @@ pub struct Set<T> {
 }
 
 #[cfg(feature = "pylib")]
-impl<T: Hash + Eq + IntoPy<PyObject>> IntoPy<PyObject> for Set<T> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.elems.into_py(py)
+impl<'py, T: Hash + Eq + IntoPyObject<'py>> IntoPyObject<'py> for Set<T> {
+    type Target = pyo3::types::PySet;
+    type Output = Bound<'py, Self::Target>;
+    type Error = pyo3::PyErr;
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        self.elems.into_pyobject(py)
     }
 }
 

crates/erg_common/set.rs

@@ -6,7 +6,7 @@ use std::ops::{Add, Deref};
 #[cfg(feature = "pylib")]
 use pyo3::prelude::PyAnyMethods;
 #[cfg(feature = "pylib")]
-use pyo3::{FromPyObject, IntoPy, PyAny, PyObject, Python};
+use pyo3::{FromPyObject, IntoPyObject, PyAny};
 
 pub type ArcStr = std::sync::Arc<str>;
 
@@ -28,9 +28,12 @@ impl FromPyObject<'_> for Str {
 }
 
 #[cfg(feature = "pylib")]
-impl IntoPy<PyObject> for Str {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        (&self[..]).into_py(py)
+impl<'py> IntoPyObject<'py> for Str {
+    type Target = pyo3::types::PyString;
+    type Output = pyo3::Bound<'py, Self::Target>;
+    type Error = std::convert::Infallible;
+    fn into_pyobject(self, py: pyo3::Python<'py>) -> Result<Self::Output, Self::Error> {
+        (&self[..]).into_pyobject(py)
     }
 }
 

crates/erg_common/str.rs

@@ -11,7 +11,7 @@ The overall structure is described in detail in [architecture.md(English)](../..
 ```python
 import erg_compiler
 
-module = erg_compiler.exec_module(".i = 1")
+module = erg_compiler.exec(".i = 1", None)
 # foo.er:
 # .bar = 1
 foo = erg_compiler.__import__("foo")
@@ -37,6 +37,7 @@ assert j == 1
 ### Debug install (using venv)
 
 ```python
+# cd crates/erg_compiler
 python -m venv .venv
 source .venv/bin/activate
 maturin develop --features pylib_compiler
@@ -45,6 +46,7 @@ maturin develop --features pylib_compiler
 ### Release install
 
 ```python
+# cd crates/erg_compiler
 maturin build -i python --release --features pylib_compiler
 pip install <output wheel>
 ```

crates/erg_compiler/README.md

@@ -91,11 +91,11 @@ impl _Compiler {
             .map(|art| art.object)
             .map_err(|iart| iart.errors)?;
         let bytes = code.into_bytes(py.version().parse().unwrap());
-        let dict = [("bytes", PyBytes::new_bound(py, &bytes))].into_py_dict_bound(py);
-        py.run_bound("import marshal", None, None).unwrap();
-        let code = py
-            .eval_bound("marshal.loads(bytes)", None, Some(&dict))
+        let dict = [("bytes", PyBytes::new(py, &bytes))]
+            .into_py_dict(py)
             .unwrap();
+        py.run(c"import marshal", None, None).unwrap();
+        let code = py.eval(c"marshal.loads(bytes)", None, Some(&dict)).unwrap();
         Ok(code.into())
     }
 
@@ -131,10 +131,12 @@ impl _Compiler {
             .map(|art| art.object)
             .map_err(|iart| iart.errors)?;
         let bytes = code.into_bytes(py.version().parse().unwrap());
-        let dict = [("bytes", PyBytes::new_bound(py, &bytes))].into_py_dict_bound(py);
-        py.run_bound("import marshal", None, None).unwrap();
+        let dict = [("bytes", PyBytes::new(py, &bytes))]
+            .into_py_dict(py)
+            .unwrap();
+        py.run(c"import marshal", None, None).unwrap();
         Ok(py
-            .eval_bound("marshal.loads(bytes)", None, Some(&dict))
+            .eval(c"marshal.loads(bytes)", None, Some(&dict))
             .unwrap()
             .into())
     }
@@ -250,9 +252,11 @@ fn _exec_with_dependencies(
     path: Option<String>,
 ) -> Result<PyObject, error::CompileErrors> {
     let code = _compile_with_dependencies(py, code, "exec", pkgs, path)?;
-    let module = pyo3::types::PyModule::new_bound(py, "<erg>").unwrap();
-    let dic = [("code", code), ("dict", PyObject::from(module.dict()))].into_py_dict_bound(py);
-    py.run_bound("exec(code, dict)", None, Some(&dic)).unwrap();
+    let module = pyo3::types::PyModule::new(py, "<erg>").unwrap();
+    let dic = [("code", code), ("dict", PyObject::from(module.dict()))]
+        .into_py_dict(py)
+        .unwrap();
+    py.run(c"exec(code, dict)", None, Some(&dic)).unwrap();
     Ok(module.into())
 }
 
@@ -312,9 +316,11 @@ fn _exec_ast_with_dependencies(
     path: Option<String>,
 ) -> Result<PyObject, error::CompileErrors> {
     let code = _compile_ast_with_dependencies(py, ast, "exec", pkgs, path)?;
-    let module = pyo3::types::PyModule::new_bound(py, "<erg>").unwrap();
-    let dic = [("code", code), ("dict", PyObject::from(module.dict()))].into_py_dict_bound(py);
-    py.run_bound("exec(code, dict)", None, Some(&dic)).unwrap();
+    let module = pyo3::types::PyModule::new(py, "<erg>").unwrap();
+    let dic = [("code", code), ("dict", PyObject::from(module.dict()))]
+        .into_py_dict(py)
+        .unwrap();
+    py.run(c"exec(code, dict)", None, Some(&dic)).unwrap();
     Ok(module.into())
 }
 
@@ -366,12 +372,12 @@ fn erg_compiler(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(_import, m)?)?;
 
     use crate::erg_parser::erg_parser;
-    let parser = PyModule::new_bound(py, "erg_parser")?;
+    let parser = PyModule::new(py, "erg_parser")?;
     erg_parser(py, &parser)?;
     m.add_submodule(&parser)?;
 
-    py.run_bound(
-        "\
+    py.run(
+        c"\
 import sys
 sys.modules['erg_compiler.erg_parser'] = erg_parser
 sys.modules['erg_compiler.erg_parser.ast'] = erg_parser.ast

crates/erg_compiler/lib.rs

@@ -32,10 +32,15 @@ use pyo3::prelude::*;
 macro_rules! impl_into_py_for_enum {
     ($Enum: ident; $($Variant: ident $(,)?)*) => {
         #[cfg(feature = "pylib")]
-        impl IntoPy<PyObject> for $Enum {
-            fn into_py(self, py: Python<'_>) -> PyObject {
+        impl<'py> IntoPyObject<'py> for $Enum {
+            type Target = pyo3::PyAny;
+            type Output = pyo3::Bound<'py, Self::Target>;
+            type Error = pyo3::PyErr;
+            fn into_pyobject(self, py: pyo3::Python<'py>) -> Result<Self::Output, Self::Error> {
+                use pyo3::IntoPyObjectExt;
+
                 match self {
-                    $(Self::$Variant(v) => v.into_py(py),)*
+                    $(Self::$Variant(v) => Ok(v.into_py_any(py)?.into_bound(py)),)*
                 }
             }
         }
@@ -46,7 +51,7 @@ macro_rules! impl_from_py_for_enum {
     ($Ty: ty; $($Variant: ident ($inner: ident) $(,)*)*) => {
         #[cfg(feature = "pylib")]
         impl FromPyObject<'_> for $Ty {
-            fn extract(ob: &PyAny) -> PyResult<Self> {
+            fn extract_bound(ob: &pyo3::Bound<'_, PyAny>) -> PyResult<Self> {
                 $(if let Ok(extracted) = ob.extract::<$inner>() {
                     return Ok(Self::$Variant(extracted));
                 } else)* {
@@ -60,7 +65,7 @@ macro_rules! impl_from_py_for_enum {
     ($Ty: ty; $($Variant: ident $(,)*)*) => {
         #[cfg(feature = "pylib")]
         impl FromPyObject<'_> for $Ty {
-            fn extract(ob: &PyAny) -> PyResult<Self> {
+            fn extract_bound(ob: &pyo3::Bound<'_, PyAny>) -> PyResult<Self> {
                 $(if let Ok(extracted) = ob.extract::<$Variant>() {
                     return Ok(Self::$Variant(extracted));
                 } else)* {
@@ -791,18 +796,23 @@ pub enum TypeAppArgsKind {
 }
 
 #[cfg(feature = "pylib")]
-impl IntoPy<PyObject> for TypeAppArgsKind {
-    fn into_py(self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for TypeAppArgsKind {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        use pyo3::IntoPyObjectExt;
+
         match self {
-            Self::SubtypeOf(ty) => ty.into_py(py),
-            Self::Args(args) => args.into_py(py),
+            Self::SubtypeOf(ty) => Ok(ty.into_py_any(py)?.into_bound(py)),
+            Self::Args(args) => Ok(args.into_py_any(py)?.into_bound(py)),
         }
     }
 }
 
 #[cfg(feature = "pylib")]
 impl FromPyObject<'_> for TypeAppArgsKind {
-    fn extract(ob: &PyAny) -> PyResult<Self> {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Ok(ty) = ob.extract::<TypeSpecWithOp>() {
             Ok(Self::SubtypeOf(Box::new(ty)))
         } else if let Ok(args) = ob.extract::<Args>() {
@@ -4146,9 +4156,12 @@ pub enum TypeSpec {
 
 // TODO:
 #[cfg(feature = "pylib")]
-impl IntoPy<PyObject> for TypeSpec {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        pyo3::types::PyNone::get_bound(py).to_object(py)
+impl<'py> IntoPyObject<'py> for TypeSpec {
+    type Target = pyo3::types::PyNone;
+    type Output = Borrowed<'py, 'py, Self::Target>;
+    type Error = std::convert::Infallible;
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        pyo3::types::PyNone::get(py).into_pyobject(py)
     }
 }
 
@@ -4620,14 +4633,19 @@ impl Hash for VisModifierSpec {
 }
 
 #[cfg(feature = "pylib")]
-impl IntoPy<PyObject> for VisModifierSpec {
-    fn into_py(self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for VisModifierSpec {
+    type Target = PyAny;
+    type Output = Bound<'py, PyAny>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
+        use pyo3::IntoPyObjectExt;
+
         match self {
-            Self::Private => py.None(),
-            Self::Auto => py.None(),
-            Self::Public(token) => token.into_py(py),
-            Self::ExplicitPrivate(token) => token.into_py(py),
-            Self::Restricted(rest) => rest.into_py(py),
+            Self::Private | Self::Auto => py.None().into_bound_py_any(py),
+            Self::Public(token) => token.into_bound_py_any(py),
+            Self::ExplicitPrivate(token) => token.into_bound_py_any(py),
+            Self::Restricted(rest) => rest.into_bound_py_any(py),
         }
     }
 }

crates/erg_parser/ast.rs

@@ -38,7 +38,7 @@ fn _parse(code: String) -> Result<ast::Module, error::ParseErrors> {
 #[cfg_attr(feature = "pylib_parser", pymodule)]
 pub fn erg_parser(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(_parse, m)?)?;
-    let expr = PyModule::new_bound(py, "expr")?;
+    let expr = PyModule::new(py, "expr")?;
     expr.add_class::<ast::Literal>()?;
     expr.add_class::<ast::NormalList>()?;
     expr.add_class::<ast::NormalTuple>()?;
@@ -61,7 +61,7 @@ pub fn erg_parser(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
     expr.add_class::<ast::Dummy>()?;
     m.add_submodule(&expr)?;
 
-    let ast = PyModule::new_bound(py, "ast")?;
+    let ast = PyModule::new(py, "ast")?;
     ast.add_class::<token::Token>()?;
     ast.add_class::<token::TokenKind>()?;
     ast.add_class::<ast::Literal>()?;
@@ -98,8 +98,8 @@ pub fn erg_parser(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
     ast.add_class::<ast::AST>()?;
     m.add_submodule(&ast)?;
 
-    py.run_bound(
-        "\
+    py.run(
+        c"\
 import sys
 sys.modules['erg_parser.ast'] = ast
 sys.modules['erg_parser.expr'] = expr