Make parser no_std compatible

Author: coolreader18

Cargo.lock

@@ -8,17 +8,22 @@ repository = "https://github.com/RustPython/RustPython"
 license = "MIT"
 edition = "2018"
 
+[features]
+std = []
+default = ["std", "lalrpop-util/std", "num-bigint/std"]
+
 [build-dependencies]
-lalrpop = "0.19"
+lalrpop = "0.19.4"
 
 [dependencies]
 rustpython-ast = { path = "../ast" }
-lalrpop-util = "0.19.1"
+lalrpop-util = { version = "0.19.4", default-features = false }
 log = "0.4.1"
-num-bigint = "0.3"
-num-traits = "0.2"
+num-bigint = { version = "0.3", default-features = false }
+num-traits = { version = "0.2", default-features = false }
 unic-emoji-char = "0.9"
 unic-ucd-ident  = "0.9"
 unicode_names2 = "0.4"
 phf = { version = "0.8", features = ["macros"] }
 ahash = "0.6"
+hashbrown = "0.9"

parser/Cargo.toml

@@ -5,8 +5,10 @@ use lalrpop_util::ParseError as LalrpopError;
 use crate::ast::Location;
 use crate::token::Tok;
 
+use alloc::{boxed::Box, string::String};
+use core::fmt;
+#[cfg(feature = "std")]
 use std::error::Error;
-use std::fmt;
 
 /// Represents an error during lexical scanning.
 #[derive(Debug, PartialEq)]
@@ -70,6 +72,16 @@ impl fmt::Display for LexicalErrorType {
     }
 }
 
+#[cfg(feature = "std")]
+impl Error for LexicalErrorType {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            LexicalErrorType::FStringError(e) => Some(e),
+            _ => None,
+        }
+    }
+}
+
 // TODO: consolidate these with ParseError
 #[derive(Debug, PartialEq)]
 pub struct FStringError {
@@ -119,6 +131,16 @@ impl From<FStringError> for LalrpopError<Location, Tok, LexicalError> {
     }
 }
 
+#[cfg(feature = "std")]
+impl Error for FStringErrorType {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            FStringErrorType::InvalidExpression(e) => Some(e.as_ref()),
+            _ => None,
+        }
+    }
+}
+
 /// Represents an error during parsing
 #[derive(Debug, PartialEq)]
 pub struct ParseError {
@@ -204,14 +226,22 @@ impl fmt::Display for ParseErrorType {
     }
 }
 
-impl Error for ParseErrorType {}
+#[cfg(feature = "std")]
+impl Error for ParseErrorType {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            ParseErrorType::Lexical(e) => Some(e),
+            _ => None,
+        }
+    }
+}
 
 impl ParseErrorType {
     pub fn is_indentation_error(&self) -> bool {
         match self {
             ParseErrorType::Lexical(LexicalErrorType::IndentationError) => true,
             ParseErrorType::UnrecognizedToken(token, expected) => {
-                *token == Tok::Indent || expected.clone() == Some("Indent".to_owned())
+                *token == Tok::Indent || expected.as_ref().map_or(false, |s| s == "Indent")
             }
             _ => false,
         }
@@ -225,15 +255,16 @@ impl ParseErrorType {
     }
 }
 
-impl std::ops::Deref for ParseError {
+impl core::ops::Deref for ParseError {
     type Target = ParseErrorType;
     fn deref(&self) -> &Self::Target {
         &self.error
     }
 }
 
+#[cfg(feature = "std")]
 impl Error for ParseError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
-        None
+        self.error.source()
     }
 }

parser/src/error.rs

@@ -1,6 +1,5 @@
-use std::iter;
-use std::mem;
-use std::str;
+use alloc::{borrow::ToOwned, boxed::Box, format, string::String, vec, vec::Vec};
+use core::{iter, mem, str};
 
 use crate::ast::{ConversionFlag, Expression, Location, StringGroup};
 use crate::error::{FStringError, FStringErrorType, ParseError};
@@ -81,7 +80,7 @@ impl<'a> FStringParser<'a> {
                 // match a python 3.8 self documenting expression
                 // format '{' PYTHON_EXPRESSION '=' FORMAT_SPECIFIER? '}'
                 '=' if self.chars.peek() != Some(&'=') && delims.is_empty() => {
-                    pred_expression_text = expression.to_string(); // safe expression before = to print it
+                    pred_expression_text = expression.to_owned(); // safe expression before = to print it
                 }
 
                 ':' if delims.is_empty() => {

parser/src/fstring.rs

@@ -1,5 +1,5 @@
-use ahash::RandomState;
-use std::collections::HashSet;
+use alloc::{string::String, vec, vec::Vec};
+use hashbrown::HashSet;
 
 use crate::ast;
 use crate::error::{LexicalError, LexicalErrorType};
@@ -46,7 +46,8 @@ pub fn parse_args(func_args: Vec<FunctionArgument>) -> Result<ast::ArgumentList,
     let mut args = vec![];
     let mut keywords = vec![];
 
-    let mut keyword_names = HashSet::with_capacity_and_hasher(func_args.len(), RandomState::new());
+    let mut keyword_names =
+        HashSet::with_capacity_and_hasher(func_args.len(), ahash::RandomState::default());
     for (name, value) in func_args {
         match name {
             Some(n) => {

parser/src/function.rs

@@ -5,12 +5,19 @@
 pub use super::token::Tok;
 use crate::ast::Location;
 use crate::error::{LexicalError, LexicalErrorType};
+use alloc::{
+    borrow::ToOwned,
+    format,
+    string::{String, ToString},
+    vec,
+    vec::Vec,
+};
+use core::char;
+use core::cmp::Ordering;
+use core::str::FromStr;
 use num_bigint::BigInt;
 use num_traits::identities::Zero;
 use num_traits::Num;
-use std::char;
-use std::cmp::Ordering;
-use std::str::FromStr;
 use unic_emoji_char::is_emoji_presentation;
 use unic_ucd_ident::{is_xid_continue, is_xid_start};
 
@@ -436,8 +443,8 @@ where
             }
         }
         match p {
-            0xD800..=0xDFFF => Ok(std::char::REPLACEMENT_CHARACTER),
-            _ => std::char::from_u32(p).ok_or(unicode_error),
+            0xD800..=0xDFFF => Ok(char::REPLACEMENT_CHARACTER),
+            _ => char::from_u32(p).ok_or(unicode_error),
         }
     }
 

parser/src/lexer.rs

@@ -17,6 +17,13 @@
 
 #![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/master/logo.png")]
 #![doc(html_root_url = "https://docs.rs/rustpython-parser/")]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+// hack to get around lalrpop hardcoding ::std::* paths
+#[cfg(not(feature = "std"))]
+extern crate self as std;
 
 #[macro_use]
 extern crate log;

parser/src/lib.rs

@@ -1,10 +1,12 @@
+use core::fmt;
+
 #[derive(Clone, Copy)]
 pub enum Mode {
     Program,
     Statement,
 }
 
-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 {
@@ -20,8 +22,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""#)
     }
 }