Remove unstable features

examples/easy_api.rs

@@ -1,7 +1,6 @@
-#![feature(iter_intersperse)]
-
 use cairo_native::context::NativeContext;
 use cairo_native::executor::NativeExecutor;
+use itertools::Itertools;
 use serde_json::json;
 use std::{io::stdout, path::Path};
 
@@ -54,8 +53,7 @@ fn main() {
                         .param_types
                         .iter()
                         .map(ToString::to_string)
-                        .intersperse_with(|| ", ".to_string())
-                        .collect::<String>()
+                        .join(", ")
                 )
             }
             e => panic!("{:?}", e),

examples/erc20.rs

@@ -1,5 +1,3 @@
-#![feature(strict_provenance)]
-
 use cairo_felt::Felt252;
 use cairo_native::context::NativeContext;
 use cairo_native::executor::NativeExecutor;
@@ -294,7 +292,7 @@ fn main() {
         .get_metadata::<SyscallHandlerMeta>()
         .unwrap()
         .as_ptr()
-        .addr();
+        .as_ptr() as *const () as usize;
 
     let fn_id = find_function_id(
         &sierra_program,

examples/starknet.rs

@@ -1,5 +1,3 @@
-#![feature(strict_provenance)]
-
 use cairo_felt::Felt252;
 use cairo_lang_compiler::CompilerConfig;
 use cairo_native::context::NativeContext;
@@ -296,7 +294,7 @@ fn main() {
         .get_metadata::<SyscallHandlerMeta>()
         .unwrap()
         .as_ptr()
-        .addr();
+        .as_ptr() as *const () as usize;
 
     let fn_id = find_function_id(&sierra_program, "hello_starknet::hello_starknet::main");
     let required_init_gas = native_program.get_required_init_gas(fn_id);

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly"
+channel = "stable"
 components = ["rustfmt", "clippy"]
 profile = "minimal"

rustfmt.toml

@@ -1,4 +1,4 @@
 edition = "2021"
-group_imports = "One"
+# nightly: group_imports = "One"
 newline_style = "Unix"
 use_field_init_shorthand = true

src/bin/cairo-native-dump.rs

@@ -1,5 +1,3 @@
-#![feature(arc_unwrap_or_clone)]
-
 use cairo_lang_compiler::{
     compile_prepared_db, db::RootDatabase, diagnostics::DiagnosticsReporter,
     project::setup_project, CompilerConfig,
@@ -25,7 +23,6 @@ use std::{
     ffi::OsStr,
     fs,
     path::{Path, PathBuf},
-    sync::Arc,
 };
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
@@ -89,14 +86,15 @@ fn load_program<'c>(
         Some("cairo") => {
             let mut db = RootDatabase::builder().detect_corelib().build()?;
             let main_crate_ids = setup_project(&mut db, path)?;
-            let program = Arc::unwrap_or_clone(compile_prepared_db(
+            let program = (*compile_prepared_db(
                 &mut db,
                 main_crate_ids,
                 CompilerConfig {
                     replace_ids: true,
                     ..Default::default()
                 },
-            )?);
+            )?)
+            .clone();
 
             let debug_locations = if let Some(context) = context {
                 let debug_info = DebugInfo::extract(&db, &program).map_err(|_| {

src/bin/cairo-native-run.rs

@@ -1,8 +1,3 @@
-#![feature(arc_unwrap_or_clone)]
-#![feature(iter_intersperse)]
-#![feature(nonzero_ops)]
-#![feature(strict_provenance)]
-
 use cairo_lang_compiler::{
     compile_prepared_db, db::RootDatabase, project::setup_project, CompilerConfig,
 };
@@ -19,6 +14,7 @@ use cairo_native::{
     utils::register_runtime_symbols,
 };
 use clap::Parser;
+use itertools::Itertools;
 use melior::{
     dialect::DialectRegistry,
     ir::{Location, Module},
@@ -34,7 +30,6 @@ use std::{
     fs::{self, File},
     io::{self, Write},
     path::{Path, PathBuf},
-    sync::Arc,
 };
 use tracing::info;
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
@@ -163,8 +158,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                             .param_types
                             .iter()
                             .map(ToString::to_string)
-                            .intersperse_with(|| ", ".to_string())
-                            .collect::<String>()
+                            .join(", ")
                     )
                 }
                 e => panic!("{:?}", e),
@@ -199,14 +193,15 @@ fn load_program(path: &Path) -> Result<Program, Box<dyn std::error::Error>> {
         Some("cairo") => {
             let mut db = RootDatabase::builder().detect_corelib().build()?;
             let main_crate_ids = setup_project(&mut db, path)?;
-            Arc::unwrap_or_clone(compile_prepared_db(
+            (*compile_prepared_db(
                 &mut db,
                 main_crate_ids,
                 CompilerConfig {
                     replace_ids: true,
                     ..Default::default()
                 },
             )?)
+            .clone()
         }
         Some("sierra") => {
             let program_src = fs::read_to_string(path)?;

src/compiler.rs

@@ -529,7 +529,15 @@ where
         function.entry_point,
         initial_state,
         |statement_idx, state| {
-            let block = blocks.try_insert(statement_idx.0, Block::new(&[])).unwrap();
+            let block = {
+                if let std::collections::btree_map::Entry::Vacant(e) = blocks.entry(statement_idx.0)
+                {
+                    e.insert(Block::new(&[]));
+                    blocks.get_mut(&statement_idx.0).unwrap()
+                } else {
+                    panic!("statement index already present in block");
+                }
+            };
 
             Ok(match &statements[statement_idx.0] {
                 Statement::Invocation(invocation) => {

src/debug_info.rs

@@ -39,7 +39,7 @@ impl DebugInfo {
                     .map(|x| x.map(|location| (type_declaration.id.clone(), location)))
                     .transpose()
             })
-            .try_collect()?;
+            .collect::<Result<HashMap<_, _>, DiagnosticAdded>>()?;
 
         let libfunc_declarations = program
             .libfunc_declarations
@@ -49,7 +49,7 @@ impl DebugInfo {
                     .map(|x| x.map(|location| (libfunc_declaration.id.clone(), location)))
                     .transpose()
             })
-            .try_collect::<HashMap<_, _>>()?;
+            .collect::<Result<HashMap<_, _>, DiagnosticAdded>>()?;
 
         let statements =
             find_all_statements(db, |id| libfunc_declarations.contains_key(id), program)?;
@@ -58,7 +58,7 @@ impl DebugInfo {
             .funcs
             .iter()
             .map(|function| Ok((function.id.clone(), find_func(db, function)?)))
-            .try_collect()?;
+            .collect::<Result<HashMap<_, _>, DiagnosticAdded>>()?;
 
         Ok(Self {
             type_declarations,

src/debug_info/statements.rs

@@ -47,16 +47,20 @@ fn find_statement_locations(
         db.concrete_function_with_body_postpanic_lowered(function_long_id.body(db)?.unwrap())?;
 
     // Map Sierra to pre-Sierra statements.
-    let mut sierra_to_pre_sierra_mappings =
+    let sierra_to_pre_sierra_mappings =
         map_sierra_to_pre_sierra_statements(function.entry_point, statements, &function_impl.body);
 
     // Remove Sierra-specific invocations (they have no location since they are compiler-generated).
-    sierra_to_pre_sierra_mappings
-        .extract_if(|_, statement| match statement {
-            GenStatement::Invocation(invocation) => contains_libfunc(&invocation.libfunc_id),
-            GenStatement::Return(_) => false,
+    let sierra_to_pre_sierra_mappings: HashMap<_, _> = sierra_to_pre_sierra_mappings
+        .into_iter()
+        .filter(|(_, statement)| {
+            if let GenStatement::Invocation(invocation) = statement {
+                !contains_libfunc(&invocation.libfunc_id)
+            } else {
+                false
+            }
         })
-        .for_each(|_| {});
+        .collect();
 
     // Map Sierra to lowering statements by using the pre-Sierra mappings.
     Ok(remap_sierra_statements_to_locations(

src/error/compile.rs

@@ -8,7 +8,7 @@ use cairo_lang_sierra::{
     ids::{ConcreteLibfuncId, ConcreteTypeId},
     program_registry::ProgramRegistryError,
 };
-use std::{backtrace::Backtrace, fmt, ops::Deref};
+use std::{fmt, ops::Deref};
 use thiserror::Error;
 
 pub type CompileError = Box<Error<CoreType, CoreLibfunc>>;
@@ -21,7 +21,8 @@ where
     <TType as GenericType>::Concrete: TypeBuilder<TType, TLibfunc>,
     <TLibfunc as GenericLibfunc>::Concrete: LibfuncBuilder<TType, TLibfunc>,
 {
-    pub backtrace: Backtrace,
+    // TODO: enable once its stable in rust
+    // pub backtrace: Backtrace,
     pub source: ErrorImpl<TType, TLibfunc>,
 }
 
@@ -61,7 +62,7 @@ where
 {
     fn from(error: E) -> Self {
         Self {
-            backtrace: Backtrace::capture(),
+            // backtrace: Backtrace::capture(),
             source: error.into(),
         }
     }
@@ -91,7 +92,7 @@ where
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Error")
-            .field("backtrace", &self.backtrace)
+            // .field("backtrace", &self.backtrace)
             .field("source", &self.source)
             .finish()
     }

src/error/jit_engine.rs

@@ -8,7 +8,7 @@ use cairo_lang_sierra::{
     program_registry::ProgramRegistryError,
 };
 use serde::{Deserializer, Serializer};
-use std::{alloc::LayoutError, backtrace::Backtrace, fmt, ops::Deref};
+use std::{alloc::LayoutError, fmt, ops::Deref};
 use thiserror::Error;
 
 pub type RunnerError<'de, D, S> = Box<Error<'de, CoreType, CoreLibfunc, D, S>>;
@@ -23,7 +23,8 @@ where
     D: Deserializer<'de>,
     S: Serializer,
 {
-    pub backtrace: Backtrace,
+    // TODO: enable once its stable in rust
+    // pub backtrace: Backtrace,
     pub source: ErrorImpl<'de, TType, TLibfunc, D, S>,
 }
 
@@ -69,7 +70,7 @@ where
 {
     fn from(error: E) -> Self {
         Self {
-            backtrace: Backtrace::capture(),
+            // backtrace: Backtrace::capture(),
             source: error.into(),
         }
     }
@@ -103,7 +104,7 @@ where
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Error")
-            .field("backtrace", &self.backtrace)
+            // .field("backtrace", &self.backtrace)
             .field("source", &self.source)
             .finish()
     }

src/error/libfuncs.rs

@@ -1,12 +1,13 @@
 use cairo_lang_sierra::program_registry::ProgramRegistryError;
-use std::{alloc::LayoutError, backtrace::Backtrace, fmt, num::TryFromIntError, ops::Deref};
+use std::{alloc::LayoutError, fmt, num::TryFromIntError, ops::Deref};
 use thiserror::Error;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, Error)]
 pub struct Error {
-    pub backtrace: Backtrace,
+    // TODO: enable once its stable in rust
+    // pub backtrace: Backtrace,
     pub source: ErrorImpl,
 }
 
@@ -30,7 +31,7 @@ where
 {
     fn from(error: E) -> Self {
         Self {
-            backtrace: Backtrace::capture(),
+            // backtrace: Backtrace::capture(),
             source: error.into(),
         }
     }
@@ -41,6 +42,8 @@ pub enum ErrorImpl {
     #[error(transparent)]
     LayoutError(#[from] LayoutError),
     #[error(transparent)]
+    LayoutErrorPolyfill(#[from] crate::utils::LayoutError),
+    #[error(transparent)]
     MlirError(#[from] melior::Error),
     #[error(transparent)]
     ProgramRegistryError(#[from] Box<ProgramRegistryError>),
@@ -54,6 +57,7 @@ impl From<super::CoreTypeBuilderError> for ErrorImpl {
             super::types::ErrorImpl::LayoutError(e) => Self::LayoutError(e),
             super::types::ErrorImpl::ProgramRegistryError(e) => Self::ProgramRegistryError(e),
             super::types::ErrorImpl::TryFromIntError(e) => Self::TryFromIntError(e),
+            super::types::ErrorImpl::LayoutErrorPolyfill(e) => Self::LayoutErrorPolyfill(e),
         }
     }
 }

src/error/types.rs

@@ -1,12 +1,13 @@
 use cairo_lang_sierra::program_registry::ProgramRegistryError;
-use std::{alloc::LayoutError, backtrace::Backtrace, fmt, num::TryFromIntError, ops::Deref};
+use std::{alloc::LayoutError, fmt, num::TryFromIntError, ops::Deref};
 use thiserror::Error;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, Error)]
 pub struct Error {
-    pub backtrace: Backtrace,
+    // TODO: enable once its stable in rust
+    // pub backtrace: Backtrace,
     pub source: ErrorImpl,
 }
 
@@ -30,7 +31,7 @@ where
 {
     fn from(error: E) -> Self {
         Self {
-            backtrace: Backtrace::capture(),
+            // backtrace: Backtrace::capture(),
             source: error.into(),
         }
     }
@@ -41,6 +42,8 @@ pub enum ErrorImpl {
     #[error(transparent)]
     LayoutError(#[from] LayoutError),
     #[error(transparent)]
+    LayoutErrorPolyfill(#[from] crate::utils::LayoutError),
+    #[error(transparent)]
     ProgramRegistryError(#[from] Box<ProgramRegistryError>),
     #[error(transparent)]
     TryFromIntError(#[from] TryFromIntError),

src/jit_runner.rs

@@ -147,7 +147,8 @@ where
                 TType,
                 TLibfunc,
             >>::new(
-                ret_ptr.map_addr(|addr| unsafe { addr.unchecked_add(offset) }),
+                // ret_ptr.map_addr(|addr| unsafe { addr.unchecked_add(offset) }),
+                NonNull::new(((ret_ptr.as_ptr() as usize) + offset) as *mut _).unwrap(),
                 registry,
                 ty,
             ))

src/lib.rs

@@ -86,17 +86,6 @@
 //!   - `registry: &ProgramRegistry<TType, TLibfunc>`: The registry extracted from the program.
 //!   - `metadata: &mut MetadataStorage`: Current compiler metadata.
 
-#![feature(alloc_layout_extra)]
-#![feature(arc_unwrap_or_clone)]
-#![feature(box_into_inner)]
-#![feature(error_generic_member_access)]
-#![feature(hash_extract_if)]
-#![feature(int_roundings)]
-#![feature(iter_intersperse)]
-#![feature(iterator_try_collect)]
-#![feature(map_try_insert)]
-#![feature(nonzero_ops)]
-#![feature(strict_provenance)]
 // #![warn(missing_docs)]
 #![allow(clippy::missing_safety_doc)]