Replace std for alloc

Author: febo

README.md

@@ -171,11 +171,12 @@ pub fn process_instruction(
 By default, Pinocchio is a `no_std` crate. This means that it does not use any code from the
 standard (`std`) library. While this does not affect how Pinocchio is used, there is a one
 particular apparent difference. Helpers that need to allocate memory, such as fetching `SlotHashes`
-sysvar data, are not available. To enable these helpers, the `std` feature must be enabled when adding
-Pinocchio as a dependency:
+sysvar data, are not available. To enable these helpers, the `alloc` feature must be enabled when
+adding Pinocchio as a dependency:
 ```
-pinocchio = { version = "0.10.0", features = ["std"] }
+pinocchio = { version = "0.10.0", features = ["alloc"] }
 ```
+The `alloc` feature uses the `alloc` crate.
 
 ## Advance entrypoint configuration
 

sdk/pinocchio/Cargo.toml

@@ -19,7 +19,7 @@ unexpected_cfgs = { level = "warn", check-cfg = [
 
 [features]
 copy = ["solana-account-view/copy", "solana-address/copy"]
-std = ["solana-address/std"]
+alloc = []
 
 [dependencies]
 solana-account-view = { workspace = true }

sdk/pinocchio/src/entrypoint/mod.rs

@@ -5,7 +5,7 @@ pub mod lazy;
 
 pub use lazy::{InstructionContext, MaybeAccount};
 
-#[cfg(not(feature = "std"))]
+#[cfg(not(feature = "alloc"))]
 use core::alloc::{GlobalAlloc, Layout};
 
 #[cfg(target_os = "solana")]
@@ -459,8 +459,8 @@ macro_rules! default_panic_handler {
 /// This macro sets up a default panic handler that logs the location (file, line and column) where
 /// the panic occurred and then calls the syscall `abort()`.
 ///
-/// This macro can only be used when all crates are `no_std` and the `"std"` feature is disabled.
-#[cfg(not(feature = "std"))]
+/// This macro can only be used when all crates are `no_std` and the `"alloc"` feature is disabled.
+#[cfg(not(feature = "alloc"))]
 #[macro_export]
 macro_rules! nostd_panic_handler {
     () => {
@@ -525,12 +525,12 @@ macro_rules! default_allocator {
 
 /// A global allocator that does not allocate memory.
 ///
-/// Using this macro with the `"std"` feature enabled will result in a compile error.
-#[cfg(feature = "std")]
+/// Using this macro with the `"alloc"` feature enabled will result in a compile error.
+#[cfg(feature = "alloc")]
 #[macro_export]
 macro_rules! no_allocator {
     () => {
-        compile_error!("Feature 'std' cannot be enabled.");
+        compile_error!("Feature 'alloc' cannot be enabled.");
     };
 }
 
@@ -542,8 +542,8 @@ macro_rules! no_allocator {
 ///
 /// The program will panic if it tries to dynamically allocate memory.
 ///
-/// This is used when the `"std"` feature is disabled.
-#[cfg(not(feature = "std"))]
+/// This is used when the `"alloc"` feature is disabled.
+#[cfg(not(feature = "alloc"))]
 #[macro_export]
 macro_rules! no_allocator {
     () => {
@@ -653,13 +653,13 @@ mod alloc {
     }
 }
 
-#[cfg(not(feature = "std"))]
+#[cfg(not(feature = "alloc"))]
 /// An allocator that does not allocate memory.
 #[cfg_attr(feature = "copy", derive(Copy))]
 #[derive(Clone, Debug)]
 pub struct NoAllocator;
 
-#[cfg(not(feature = "std"))]
+#[cfg(not(feature = "alloc"))]
 unsafe impl GlobalAlloc for NoAllocator {
     #[inline]
     unsafe fn alloc(&self, _: Layout) -> *mut u8 {
@@ -674,13 +674,13 @@ unsafe impl GlobalAlloc for NoAllocator {
 
 #[cfg(all(test, not(target_os = "solana")))]
 mod tests {
-    extern crate std;
+    extern crate alloc;
 
-    use core::{alloc::Layout, ptr::copy_nonoverlapping};
-    use std::{
+    use alloc::{
         alloc::{alloc, dealloc},
         vec,
     };
+    use core::{alloc::Layout, ptr::copy_nonoverlapping};
 
     use super::*;
 
@@ -703,7 +703,7 @@ mod tests {
             unsafe {
                 let ptr = alloc(layout);
                 if ptr.is_null() {
-                    std::alloc::handle_alloc_error(layout);
+                    alloc::alloc::handle_alloc_error(layout);
                 }
                 AlignedMemory { ptr, layout }
             }

sdk/pinocchio/src/lib.rs

@@ -166,10 +166,10 @@
 //! code from the standard (`std`) library. While this does not affect how Pinocchio
 //! is used, there is a one particular apparent difference. Helpers that need to
 //! allocate memory, such as fetching `SlotHashes` sysvar, are not available. To
-//! enable these helpers, the `std` feature must be enabled when adding Pinocchio
+//! enable these helpers, the `alloc` feature must be enabled when adding Pinocchio
 //! as a dependency:
 //! ```ignore
-//! pinocchio = { version = "0.10.0", features = ["std"] }
+//! pinocchio = { version = "0.10.0", features = ["alloc"] }
 //! ```
 //!
 //! ## Advanced entrypoint configuration
@@ -208,10 +208,10 @@
 //! cargo build-sbf --features bpf-entrypoint
 //! ```
 
-#![no_std]
+#![cfg_attr(not(test), no_std)]
 
-#[cfg(feature = "std")]
-extern crate std;
+#[cfg(feature = "alloc")]
+extern crate alloc;
 
 pub mod entrypoint;
 pub mod sysvars;

sdk/pinocchio/src/sysvars/slot_hashes/mod.rs

@@ -23,8 +23,8 @@ use crate::{
     Address,
 };
 
-#[cfg(feature = "std")]
-use std::boxed::Box;
+#[cfg(feature = "alloc")]
+use alloc::{boxed::Box, vec::Vec};
 
 /// `SysvarS1otHashes111111111111111111111111111`
 pub const SLOTHASHES_ID: Address = Address::new_from_array([
@@ -299,7 +299,7 @@ impl<'a> SlotHashes<Ref<'a, [u8]>> {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 impl SlotHashes<Box<[u8]>> {
     /// Fills the provided buffer with the full `SlotHashes` sysvar data.
     ///
@@ -320,7 +320,7 @@ impl SlotHashes<Box<[u8]>> {
     /// Allocates an optimal buffer for the sysvar data based on available features.
     #[inline(always)]
     fn allocate_and_fetch() -> Result<Box<[u8]>, ProgramError> {
-        let mut buf = std::vec::Vec::with_capacity(MAX_SIZE);
+        let mut buf = Vec::with_capacity(MAX_SIZE);
         unsafe {
             // SAFETY: `buf` was allocated with capacity `MAX_SIZE` so its
             // pointer is valid for exactly that many bytes. `fill_from_sysvar`

sdk/pinocchio/src/sysvars/slot_hashes/test.rs

@@ -9,7 +9,6 @@ use core::{
     ptr,
 };
 
-extern crate std;
 use std::io::Write;
 use std::vec::Vec;
 
@@ -460,7 +459,7 @@ fn test_from_account_info_constructor() {
 /// `SlotHashes` getters to make sure the view itself works.  We do not verify
 /// that the syscall populated real on-chain bytes, as doing so requires an
 /// environment outside the scope of host `cargo test`.
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 #[test]
 fn test_fetch_allocates_buffer_host() {
     const START_SLOT: u64 = 500;

sdk/pinocchio/src/sysvars/slot_hashes/test_edge.rs

@@ -1,6 +1,5 @@
-use crate::{error::ProgramError, sysvars::slot_hashes::*};
-extern crate std;
 use super::test_utils::{build_slot_hashes_bytes as raw_slot_hashes, make_account_info};
+use crate::{error::ProgramError, sysvars::slot_hashes::*};
 
 #[test]
 fn test_wrong_key_from_account_view() {

sdk/pinocchio/src/sysvars/slot_hashes/test_raw.rs

@@ -2,7 +2,6 @@
 
 use super::raw;
 use super::*;
-extern crate std;
 
 #[test]
 fn test_validate_buffer_size() {

sdk/pinocchio/src/sysvars/slot_hashes/test_utils.rs

@@ -3,7 +3,6 @@
 //! freely while production code remains `#![no_std]`.
 
 use super::*;
-extern crate std;
 use crate::account::{Account, AccountView};
 use core::ptr;
 use std::vec::Vec;