fix: cargo build warnings

Author: jnoortheen

Cargo.lock

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["xonsh_tokenizer", "rs-ply"]
 
 [workspace.dependencies]
-pyo3 = { version = "0.23.*", features = [
+pyo3 = { version = "0.27.*", features = [
     "extension-module",
     "experimental-inspect",
 ] }

Cargo.toml

@@ -587,11 +587,8 @@ def load_parser(parser_table: Path | str, module: ParserProtocol) -> Union[LRPar
         parser_table = str(parser_table)
 
     if HAS_RS_PLY and parser_table.endswith(".jsonl"):
-        try:
-            fsm = RustStateMachine.new_from_file(parser_table)
-            return RustLRParser(fsm, module, errorf=getattr(module, "p_error", None))
-        except Exception:
-            pass
+        fsm = RustStateMachine.new_from_file(parser_table)
+        return RustLRParser(fsm, module, errorf=getattr(module, "p_error", None))
 
     fsm = StateMachine(parser_table)
     return LRParser(fsm, errorf=getattr(module, "p_error", None), module=module)

ply_parser/ply/lrparser.py

@@ -8,8 +8,8 @@ use pyo3::prelude::*;
 #[derive(Debug)]
 pub struct LRParser {
     pub fsm: Py<StateMachine>,
-    pub errorf: Option<PyObject>,
-    pub module: PyObject,
+    pub errorf: Option<Py<PyAny>>,
+    pub module: Py<PyAny>,
     pub errorok: bool,
     pub state: u16,
 }
@@ -18,7 +18,7 @@ pub struct LRParser {
 impl LRParser {
     #[new]
     #[pyo3(signature = (fsm, module, errorf=None))]
-    fn new(fsm: Py<StateMachine>, module: PyObject, errorf: Option<PyObject>) -> Self {
+    fn new(fsm: Py<StateMachine>, module: Py<PyAny>, errorf: Option<Py<PyAny>>) -> Self {
         LRParser {
             fsm,
             errorf,
@@ -36,7 +36,7 @@ impl LRParser {
         lexer: Option<Bound<'py, PyAny>>,
         debug: u8,
         tracking: bool,
-    ) -> PyResult<PyObject> {
+    ) -> PyResult<Py<PyAny>> {
         let lexer = lexer
             .ok_or_else(|| PyErr::new::<pyo3::exceptions::PyValueError, _>("Lexer is required"))?;
 
@@ -105,7 +105,7 @@ impl LRParser {
                             lookahead = Some(end_sym);
                         } else {
                             let r#type: String = tok.getattr("type")?.extract()?;
-                            let value: PyObject = tok.getattr("value")?.extract()?;
+                            let value: Py<PyAny> = tok.getattr("value")?.extract()?;
                             let lineno: Option<usize> =
                                 tok.getattr("lineno").ok().and_then(|a| a.extract().ok());
                             let lexpos: Option<usize> =

rs-ply/src/lrparser.rs

@@ -7,7 +7,7 @@ use pyo3::prelude::*;
 #[derive(Debug)]
 pub struct YaccSymbol {
     pub r#type: String,
-    pub value: Option<PyObject>,
+    pub value: Option<Py<PyAny>>,
     pub lineno: Option<usize>,
     pub lexpos: Option<usize>,
     pub endlineno: Option<usize>,
@@ -20,7 +20,7 @@ impl YaccSymbol {
     #[pyo3(signature = (r#type, value=None, lineno=None, lexpos=None, endlineno=None, endlexpos=None))]
     pub fn new(
         r#type: String,
-        value: Option<PyObject>,
+        value: Option<Py<PyAny>>,
         lineno: Option<usize>,
         lexpos: Option<usize>,
         endlineno: Option<usize>,
@@ -48,9 +48,9 @@ impl YaccSymbol {
 #[pyclass(get_all, set_all)]
 pub struct YaccProduction {
     // The lexer that produced the token stream
-    pub lexer: PyObject,
+    pub lexer: Py<PyAny>,
     // The parser that is running this production
-    pub parser: PyObject,
+    pub parser: Py<PyAny>,
     // The slice of the input stream that is covered by this production
     pub slice: Vec<Py<YaccSymbol>>,
     pub stack: Vec<Py<YaccSymbol>>,
@@ -59,7 +59,7 @@ pub struct YaccProduction {
 #[pymethods]
 impl YaccProduction {
     #[new]
-    pub fn new(lexer: PyObject, parser: PyObject) -> Self {
+    pub fn new(lexer: Py<PyAny>, parser: Py<PyAny>) -> Self {
         YaccProduction {
             lexer,
             parser,
@@ -68,7 +68,7 @@ impl YaccProduction {
         }
     }
 
-    fn __getitem__<'py>(&self, py: Python<'py>, n: Bound<'py, PyAny>) -> PyResult<PyObject> {
+    fn __getitem__<'py>(&self, py: Python<'py>, n: Bound<'py, PyAny>) -> PyResult<Py<PyAny>> {
         if let Ok(index) = n.extract::<isize>() {
             let sym_py = if index >= 0 {
                 self.slice.get(index as usize).ok_or_else(|| {
@@ -94,7 +94,7 @@ impl YaccProduction {
                 .unwrap_or_else(|| py.None()));
         }
 
-        if let Ok(sl) = n.downcast::<pyo3::types::PySlice>() {
+        if let Ok(sl) = n.cast::<pyo3::types::PySlice>() {
             let indices = sl.indices(self.slice.len() as isize)?;
             let mut result = Vec::new();
             let mut cur = indices.start;
@@ -111,7 +111,7 @@ impl YaccProduction {
                 );
                 cur += indices.step;
             }
-            return Ok(result.into_py(py));
+            return Ok(result.into_pyobject(py)?.unbind());
         }
 
         Err(pyo3::exceptions::PyTypeError::new_err(
@@ -123,7 +123,7 @@ impl YaccProduction {
         &mut self,
         py: Python<'py>,
         index: usize,
-        value: Option<PyObject>,
+        value: Option<Py<PyAny>>,
     ) -> PyResult<()> {
         let sym_py = self.slice.get_mut(index).ok_or_else(|| {
             PyIndexError::new_err(format!("Index out of range in production slice: {}", index))

rs-ply/src/yacc_types.rs

@@ -40,17 +40,18 @@ impl PyTokInfo {
         ))
     }
 
-    fn __getattr__<'py>(slf: PyRef<'py, Self>, py: Python<'py>, name: &str) -> PyResult<PyObject> {
+    fn __getattr__<'py>(slf: PyRef<'py, Self>, py: Python<'py>, name: &str) -> PyResult<Py<PyAny>> {
         let obj = match name {
             "type" => format!("{:?}", slf.inner.typ)
                 .to_shouty_snake_case()
-                .into_py(py),
-            "start" => slf.inner.start.clone().into_py(py),
-            "end" => slf.inner.end.clone().into_py(py),
-            "span" => slf.inner.span.clone().into_py(py),
+                .into_pyobject(py)?
+                .into_any(),
+            "start" => slf.inner.start.clone().into_pyobject(py)?.into_any(),
+            "end" => slf.inner.end.clone().into_pyobject(py)?.into_any(),
+            "span" => slf.inner.span.clone().into_pyobject(py)?.into_any(),
             _ => return Err(PyTypeError::new_err(format!("Unknown attribute: {}", name))),
         };
-        Ok(obj)
+        Ok(obj.into())
     }
 
     fn is_exact_type(&self, typ: &str) -> bool {