Make compiler no_std compatible

Author: coolreader18

Cargo.lock

@@ -7,15 +7,20 @@ repository = "https://github.com/RustPython/RustPython"
 license = "MIT"
 edition = "2018"
 
+[features]
+std = ["rustpython-bytecode/std", "itertools/use_std"]
+default = ["std"]
+
 [dependencies]
 indexmap = "1.0"
-itertools = "0.9"
-rustpython-bytecode = { path = "../bytecode", version = "0.1.1" }
+itertools = { version = "0.9", default-features = false }
+rustpython-bytecode = { path = "../bytecode", version = "0.1.1", default-features = false }
 rustpython-ast = { path = "../ast" }
 num-complex = { version = "0.3", features = ["serde"] }
 num-traits = "0.2"
 log = "0.4"
 ahash = "0.6"
+scopeguard = "1.1"
 
 [dev-dependencies]
 rustpython-parser = { path = "../parser" }

compiler/Cargo.toml

@@ -10,12 +10,15 @@ use crate::ir::{self, CodeInfo};
 pub use crate::mode::Mode;
 use crate::symboltable::{make_symbol_table, statements_to_symbol_table, SymbolScope, SymbolTable};
 use crate::IndexSet;
+use alloc::{borrow::ToOwned, boxed::Box, format, string::String, vec, vec::Vec};
 use itertools::Itertools;
 use num_complex::Complex64;
 use num_traits::ToPrimitive;
 use rustpython_ast as ast;
 use rustpython_bytecode::{self as bytecode, CodeObject, ConstantData, Instruction};
 
+pub use crate::mode::Mode;
+
 type CompileResult<T> = Result<T, CompileError>;
 
 enum NameUsage {

compiler/src/compile.rs

@@ -1,7 +1,9 @@
 use rustpython_ast::Location;
 
+use alloc::string::String;
+use core::fmt;
+#[cfg(feature = "std")]
 use std::error::Error;
-use std::fmt;
 
 #[derive(Debug)]
 pub struct CompileError {
@@ -78,6 +80,7 @@ impl fmt::Display for CompileErrorType {
     }
 }
 
+#[cfg(feature = "std")]
 impl Error for CompileErrorType {}
 
 impl fmt::Display for CompileError {
@@ -86,8 +89,5 @@ impl fmt::Display for CompileError {
     }
 }
 
-impl Error for CompileError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        None
-    }
-}
+#[cfg(feature = "std")]
+impl Error for CompileError {}

compiler/src/error.rs

@@ -1,6 +1,9 @@
 //! Compile a Python AST or source code into bytecode consumable by RustPython.
 #![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/master/logo.png")]
 #![doc(html_root_url = "https://docs.rs/rustpython-compiler/")]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
 
 #[macro_use]
 extern crate log;

compiler/src/lib.rs

@@ -1,11 +1,13 @@
+use core::fmt;
+
 #[derive(Clone, Copy)]
 pub enum Mode {
     Exec,
     Eval,
     Single,
 }
 
-impl std::str::FromStr for Mode {
+impl core::str::FromStr for Mode {
     type Err = ModeParseError;
     fn from_str(s: &str) -> Result<Self, ModeParseError> {
         match s {
@@ -22,8 +24,8 @@ pub struct ModeParseError {
     _priv: (),
 }
 
-impl std::fmt::Display for ModeParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl fmt::Display for ModeParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, r#"mode should be "exec", "eval", or "single""#)
     }
 }

compiler/src/mode.rs

@@ -9,8 +9,9 @@ Inspirational file: https://github.com/python/cpython/blob/master/Python/symtabl
 
 use crate::error::{CompileError, CompileErrorType};
 use crate::IndexMap;
+use alloc::{borrow::ToOwned, format, string::String, vec, vec::Vec};
+use core::fmt;
 use rustpython_ast::{self as ast, Location};
-use std::fmt;
 
 pub fn make_symbol_table(program: &ast::Program) -> Result<SymbolTable, SymbolTableError> {
     let mut builder = SymbolTableBuilder::default();
@@ -187,8 +188,8 @@ impl SymbolTable {
     }
 }
 
-impl std::fmt::Debug for SymbolTable {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl fmt::Debug for SymbolTable {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
             "SymbolTable({:?} symbols, {:?} sub scopes)",
@@ -209,8 +210,9 @@ fn analyze_symbol_table(symbol_table: &mut SymbolTable) -> SymbolTableResult {
 type SymbolMap = IndexMap<String, Symbol>;
 
 mod stack {
-    use std::panic;
-    use std::ptr::NonNull;
+    use alloc::vec::Vec;
+    use core::ptr::NonNull;
+
     pub struct StackStack<T> {
         v: Vec<NonNull<T>>,
     }
@@ -227,9 +229,10 @@ mod stack {
             F: FnOnce(&mut Self) -> R,
         {
             self.v.push(x.into());
-            let res = panic::catch_unwind(panic::AssertUnwindSafe(|| f(self)));
-            self.v.pop();
-            res.unwrap_or_else(|x| panic::resume_unwind(x))
+            let mut this = scopeguard::guard(self, |this| {
+                this.v.pop();
+            });
+            f(&mut this)
         }
 
         pub fn iter(&self) -> impl Iterator<Item = &T> + DoubleEndedIterator + '_ {
@@ -273,7 +276,7 @@ struct SymbolTableAnalyzer {
 
 impl SymbolTableAnalyzer {
     fn analyze_symbol_table(&mut self, symbol_table: &mut SymbolTable) -> SymbolTableResult {
-        let symbols = std::mem::take(&mut symbol_table.symbols);
+        let symbols = core::mem::take(&mut symbol_table.symbols);
         let sub_tables = &mut *symbol_table.sub_tables;
 
         let mut info = (symbols, symbol_table.typ);
@@ -469,7 +472,7 @@ impl SymbolTableAnalyzer {
             SymbolTableType::Class => {
                 // named expressions are forbidden in comprehensions on class scope
                 return Err(SymbolTableError {
-                    error: "assignment expression within a comprehension cannot be used in a class body".to_string(),
+                    error: "assignment expression within a comprehension cannot be used in a class body".to_owned(),
                     // TODO: accurate location info, somehow
                     location: Location::default(),
                 });
@@ -999,7 +1002,7 @@ impl SymbolTableBuilder {
                 // comprehension iterator definitions
                 if let ExpressionContext::IterDefinitionExp = context {
                     return Err(SymbolTableError {
-                        error: "assignment expression cannot be used in a comprehension iterable expression".to_string(),
+                        error: "assignment expression cannot be used in a comprehension iterable expression".to_owned(),
                         // TODO: accurate location info, somehow
                         location: Location::default(),
                     });
@@ -1218,7 +1221,7 @@ impl SymbolTableBuilder {
             return Err(SymbolTableError {
                 error:
                     "assignment expression cannot be used in a comprehension iterable expression"
-                        .to_string(),
+                        .to_owned(),
                 location,
             });
         }