Upgrade to Rust v1.49.0

ci/docker-rust-nightly/Dockerfile

@@ -1,4 +1,4 @@
-FROM solanalabs/rust:1.48.0
+FROM solanalabs/rust:1.49.0
 ARG date
 
 RUN set -x \

ci/docker-rust/Dockerfile

@@ -1,6 +1,6 @@
 # Note: when the rust version is changed also modify
 # ci/rust-version.sh to pick up the new image tag
-FROM rust:1.48.0
+FROM rust:1.49.0
 
 # Add Google Protocol Buffers for Libra's metrics library.
 ENV PROTOC_VERSION 3.8.0

ci/rust-version.sh

@@ -18,13 +18,13 @@
 if [[ -n $RUST_STABLE_VERSION ]]; then
   stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.48.0
+  stable_version=1.49.0
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2020-12-13
+  nightly_version=2021-01-23
 fi
 
 

clap-utils/src/input_parsers.rs

@@ -167,12 +167,12 @@ pub fn resolve_signer(
     name: &str,
     wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
 ) -> Result<Option<String>, Box<dyn std::error::Error>> {
-    Ok(resolve_signer_from_path(
+    resolve_signer_from_path(
         matches,
         matches.value_of(name).unwrap(),
         name,
         wallet_manager,
-    )?)
+    )
 }
 
 pub fn lamports_of_sol(matches: &ArgMatches<'_>, name: &str) -> Option<u64> {

client/src/client_error.rs

@@ -35,16 +35,16 @@ impl From<TransportError> for ClientErrorKind {
     }
 }
 
-impl Into<TransportError> for ClientErrorKind {
-    fn into(self) -> TransportError {
-        match self {
-            Self::Io(err) => TransportError::IoError(err),
-            Self::TransactionError(err) => TransportError::TransactionError(err),
-            Self::Reqwest(err) => TransportError::Custom(format!("{:?}", err)),
-            Self::RpcError(err) => TransportError::Custom(format!("{:?}", err)),
-            Self::SerdeJson(err) => TransportError::Custom(format!("{:?}", err)),
-            Self::SigningError(err) => TransportError::Custom(format!("{:?}", err)),
-            Self::Custom(err) => TransportError::Custom(format!("{:?}", err)),
+impl From<ClientErrorKind> for TransportError {
+    fn from(client_error_kind: ClientErrorKind) -> Self {
+        match client_error_kind {
+            ClientErrorKind::Io(err) => Self::IoError(err),
+            ClientErrorKind::TransactionError(err) => Self::TransactionError(err),
+            ClientErrorKind::Reqwest(err) => Self::Custom(format!("{:?}", err)),
+            ClientErrorKind::RpcError(err) => Self::Custom(format!("{:?}", err)),
+            ClientErrorKind::SerdeJson(err) => Self::Custom(format!("{:?}", err)),
+            ClientErrorKind::SigningError(err) => Self::Custom(format!("{:?}", err)),
+            ClientErrorKind::Custom(err) => Self::Custom(format!("{:?}", err)),
         }
     }
 }
@@ -100,9 +100,9 @@ impl From<TransportError> for ClientError {
     }
 }
 
-impl Into<TransportError> for ClientError {
-    fn into(self) -> TransportError {
-        self.kind.into()
+impl From<ClientError> for TransportError {
+    fn from(client_error: ClientError) -> Self {
+        client_error.kind.into()
     }
 }
 

core/src/broadcast_stage.rs

@@ -347,6 +347,7 @@ fn update_peer_stats(
 ) {
     let now = timestamp();
     let last = last_datapoint_submit.load(Ordering::Relaxed);
+    #[allow(deprecated)]
     if now.saturating_sub(last) > 1000
         && last_datapoint_submit.compare_and_swap(last, now, Ordering::Relaxed) == last
     {

core/src/broadcast_stage/standard_broadcast_run.rs

@@ -329,6 +329,7 @@ impl StandardBroadcastRun {
         let mut get_peers_time = Measure::start("broadcast::get_peers");
         let now = timestamp();
         let last = self.last_peer_update.load(Ordering::Relaxed);
+        #[allow(deprecated)]
         if now - last > BROADCAST_PEER_UPDATE_INTERVAL_MS
             && self
                 .last_peer_update

core/src/cluster_info_vote_listener.rs

@@ -403,6 +403,7 @@ impl ClusterInfoVoteListener {
                     let last_version = bank.last_vote_sync.load(Ordering::Relaxed);
                     let (new_version, msgs) = verified_vote_packets.get_latest_votes(last_version);
                     verified_packets_sender.send(msgs)?;
+                    #[allow(deprecated)]
                     bank.last_vote_sync.compare_and_swap(
                         last_version,
                         new_version,

core/src/commitment_service.rs

@@ -263,15 +263,9 @@ mod tests {
     #[test]
     fn test_get_highest_confirmed_root() {
         assert_eq!(get_highest_confirmed_root(vec![], 10), 0);
-        let mut rooted_stake = vec![];
-        rooted_stake.push((0, 5));
-        rooted_stake.push((1, 5));
+        let rooted_stake = vec![(0, 5), (1, 5)];
         assert_eq!(get_highest_confirmed_root(rooted_stake, 10), 0);
-        let mut rooted_stake = vec![];
-        rooted_stake.push((1, 5));
-        rooted_stake.push((0, 10));
-        rooted_stake.push((2, 5));
-        rooted_stake.push((1, 4));
+        let rooted_stake = vec![(1, 5), (0, 10), (2, 5), (1, 4)];
         assert_eq!(get_highest_confirmed_root(rooted_stake, 10), 1);
     }
 

core/src/crds_gossip_pull.rs

@@ -145,10 +145,10 @@ impl CrdsFilterSet {
     }
 }
 
-impl Into<Vec<CrdsFilter>> for CrdsFilterSet {
-    fn into(self) -> Vec<CrdsFilter> {
-        let mask_bits = self.mask_bits;
-        self.filters
+impl From<CrdsFilterSet> for Vec<CrdsFilter> {
+    fn from(cfs: CrdsFilterSet) -> Self {
+        let mask_bits = cfs.mask_bits;
+        cfs.filters
             .into_iter()
             .enumerate()
             .map(|(seed, filter)| CrdsFilter {

core/src/crds_value.rs

@@ -303,7 +303,7 @@ impl<'de> Deserialize<'de> for Vote {
             from: Pubkey,
             transaction: Transaction,
             wallclock: u64,
-        };
+        }
         let vote = Vote::deserialize(deserializer)?;
         let vote = match vote.transaction.sanitize() {
             Ok(_) => Self::new(vote.from, vote.transaction, vote.wallclock),

core/src/poh_service.rs

@@ -125,7 +125,7 @@ impl PohService {
                 // sleep is not accurate enough to get a predictable time.
                 // Kernel can not schedule the thread for a while.
                 while (now.elapsed().as_nanos() as u64) < target_tick_ns {
-                    std::sync::atomic::spin_loop_hint();
+                    std::hint::spin_loop();
                 }
                 total_sleep_us += (now.elapsed().as_nanos() as u64 - elapsed_ns) / 1000;
                 now = Instant::now();

core/src/retransmit_stage.rs

@@ -121,6 +121,7 @@ fn update_retransmit_stats(
 
     let now = timestamp();
     let last = stats.last_ts.load(Ordering::Relaxed);
+    #[allow(deprecated)]
     if now.saturating_sub(last) > 2000
         && stats.last_ts.compare_and_swap(last, now, Ordering::Relaxed) == last
     {
@@ -310,6 +311,7 @@ fn retransmit(
 
     let now = timestamp();
     let last = last_peer_update.load(Ordering::Relaxed);
+    #[allow(deprecated)]
     if now.saturating_sub(last) > 1000
         && last_peer_update.compare_and_swap(last, now, Ordering::Relaxed) == last
     {

core/src/rpc.rs

@@ -749,7 +749,7 @@ impl JsonRpcRequestProcessor {
             // If the starting slot is lower than what's available in blockstore assume the entire
             // [start_slot..end_slot] can be fetched from BigTable.
             if let Some(bigtable_ledger_storage) = &self.bigtable_ledger_storage {
-                return Ok(self
+                return self
                     .runtime_handle
                     .block_on(
                         bigtable_ledger_storage
@@ -764,7 +764,7 @@ impl JsonRpcRequestProcessor {
                             "BigTable query failed (maybe timeout due to too large range?)"
                                 .to_string(),
                         )
-                    })?);
+                    });
             }
         }
 

core/src/tpu.rs

@@ -119,11 +119,12 @@ impl Tpu {
     }
 
     pub fn join(self) -> thread::Result<()> {
-        let mut results = vec![];
-        results.push(self.fetch_stage.join());
-        results.push(self.sigverify_stage.join());
-        results.push(self.cluster_info_vote_listener.join());
-        results.push(self.banking_stage.join());
+        let results = vec![
+            self.fetch_stage.join(),
+            self.sigverify_stage.join(),
+            self.cluster_info_vote_listener.join(),
+            self.banking_stage.join(),
+        ];
         let broadcast_result = self.broadcast_stage.join();
         for result in results {
             result?;

frozen-abi/macro/src/lib.rs

@@ -71,6 +71,7 @@ fn filter_allow_attrs(attrs: &mut Vec<Attribute>) {
     });
 }
 
+#[allow(deprecated)]
 #[cfg(RUSTC_WITH_SPECIALIZATION)]
 fn quote_for_specialization_detection() -> TokenStream2 {
     lazy_static! {

ledger-tool/src/main.rs

@@ -645,7 +645,7 @@ fn hardforks_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<Slot>> {
 
 fn load_bank_forks(
     arg_matches: &ArgMatches,
-    ledger_path: &PathBuf,
+    ledger_path: &Path,
     genesis_config: &GenesisConfig,
     process_options: ProcessOptions,
     access_type: AccessType,
@@ -653,7 +653,7 @@ fn load_bank_forks(
     snapshot_archive_path: Option<PathBuf>,
 ) -> bank_forks_utils::LoadResult {
     let blockstore = open_blockstore(&ledger_path, access_type, wal_recovery_mode);
-    let snapshot_path = ledger_path.clone().join(if blockstore.is_primary_access() {
+    let snapshot_path = ledger_path.join(if blockstore.is_primary_access() {
         "snapshot"
     } else {
         "snapshot.ledger-tool"
@@ -662,7 +662,7 @@ fn load_bank_forks(
         None
     } else {
         let snapshot_package_output_path =
-            snapshot_archive_path.unwrap_or_else(|| ledger_path.clone());
+            snapshot_archive_path.unwrap_or_else(|| ledger_path.to_path_buf());
         Some(SnapshotConfig {
             snapshot_interval_slots: 0, // Value doesn't matter
             snapshot_package_output_path,
@@ -1443,7 +1443,7 @@ fn main() {
                 last_in_slot: bool,
                 data_complete: bool,
                 shred: &'a Shred,
-            };
+            }
             let starting_slot = value_t_or_exit!(arg_matches, "starting_slot", Slot);
             let ending_slot = value_t!(arg_matches, "ending_slot", Slot).unwrap_or(Slot::MAX);
             let ledger = open_blockstore(&ledger_path, AccessType::TryPrimaryThenSecondary, None);
@@ -2442,13 +2442,13 @@ fn main() {
                                         cluster_points: String,
                                         old_capitalization: u64,
                                         new_capitalization: u64,
-                                    };
+                                    }
                                     fn format_or_na<T: std::fmt::Display>(
                                         data: Option<T>,
                                     ) -> String {
                                         data.map(|data| format!("{}", data))
                                             .unwrap_or_else(|| "N/A".to_owned())
-                                    };
+                                    }
                                     let mut point_details = detail
                                         .map(|d| d.points.iter().map(Some).collect::<Vec<_>>())
                                         .unwrap_or_default();

ledger/src/blockstore_db.rs

@@ -185,9 +185,10 @@ impl From<&str> for BlockstoreRecoveryMode {
         }
     }
 }
-impl Into<DBRecoveryMode> for BlockstoreRecoveryMode {
-    fn into(self) -> DBRecoveryMode {
-        match self {
+
+impl From<BlockstoreRecoveryMode> for DBRecoveryMode {
+    fn from(brm: BlockstoreRecoveryMode) -> Self {
+        match brm {
             BlockstoreRecoveryMode::TolerateCorruptedTailRecords => {
                 DBRecoveryMode::TolerateCorruptedTailRecords
             }
@@ -404,6 +405,7 @@ pub trait Column {
     fn key(index: Self::Index) -> Vec<u8>;
     fn index(key: &[u8]) -> Self::Index;
     fn primary_index(index: Self::Index) -> Slot;
+    #[allow(clippy::wrong_self_convention)]
     fn as_index(slot: Slot) -> Self::Index;
 }
 

metrics/src/counter.rs

@@ -164,6 +164,7 @@ impl Counter {
         }
     }
     pub fn init(&mut self) {
+        #![allow(deprecated)]
         self.lograte
             .compare_and_swap(0, Self::default_log_rate(), Ordering::Relaxed);
         self.metricsrate
@@ -188,6 +189,7 @@ impl Counter {
         }
 
         let lastlog = self.lastlog.load(Ordering::Relaxed);
+        #[allow(deprecated)]
         let prev = self
             .lastlog
             .compare_and_swap(lastlog, counts, Ordering::Relaxed);

metrics/src/metrics.rs

@@ -19,11 +19,11 @@ use std::{
 
 type CounterMap = HashMap<(&'static str, u64), CounterPoint>;
 
-impl Into<DataPoint> for CounterPoint {
-    fn into(self) -> DataPoint {
-        let mut point = DataPoint::new(self.name);
-        point.timestamp = self.timestamp;
-        point.add_field_i64("count", self.count);
+impl From<CounterPoint> for DataPoint {
+    fn from(counter_point: CounterPoint) -> Self {
+        let mut point = Self::new(counter_point.name);
+        point.timestamp = counter_point.timestamp;
+        point.add_field_i64("count", counter_point.count);
         point
     }
 }

perf/src/cuda_runtime.rs

@@ -89,18 +89,17 @@ impl<T: Clone + Default + Sized> Default for PinnedVec<T> {
     }
 }
 
-impl<T: Clone + Default + Sized> Into<Vec<T>> for PinnedVec<T> {
-    fn into(mut self) -> Vec<T> {
-        if self.pinned {
-            unpin(self.x.as_mut_ptr());
-            self.pinned = false;
+impl<T: Clone + Default + Sized> From<PinnedVec<T>> for Vec<T> {
+    fn from(mut pinned_vec: PinnedVec<T>) -> Self {
+        if pinned_vec.pinned {
+            unpin(pinned_vec.x.as_mut_ptr());
+            pinned_vec.pinned = false;
         }
-        self.pinnable = false;
-        self.recycler = None;
-        std::mem::take(&mut self.x)
+        pinned_vec.pinnable = false;
+        pinned_vec.recycler = None;
+        std::mem::take(&mut pinned_vec.x)
     }
 }
-
 pub struct PinnedIter<'a, T>(std::slice::Iter<'a, T>);
 
 pub struct PinnedIterMut<'a, T>(std::slice::IterMut<'a, T>);

perf/src/recycler.rs

@@ -114,9 +114,12 @@ impl<T: Default + Reset> RecyclerX<T> {
         let max_gc = self.stats.max_gc.load(Ordering::Relaxed);
         if len > max_gc {
             // this is not completely accurate, but for most cases should be fine.
-            self.stats
-                .max_gc
-                .compare_and_swap(max_gc, len, Ordering::Relaxed);
+            let _ = self.stats.max_gc.compare_exchange(
+                max_gc,
+                len,
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            );
         }
         let total = self.stats.total.load(Ordering::Relaxed);
         let reuse = self.stats.reuse.load(Ordering::Relaxed);

runtime/src/accounts_db.rs

@@ -3908,6 +3908,8 @@ impl AccountsDB {
     fn report_store_timings(&self) {
         let last = self.stats.last_store_report.load(Ordering::Relaxed);
         let now = solana_sdk::timing::timestamp();
+
+        #[allow(deprecated)]
         if now.saturating_sub(last) > 1000
             && self
                 .stats

runtime/src/bloom.rs

@@ -196,14 +196,18 @@ impl<T: BloomHashIndex> AtomicBloom<T> {
     }
 }
 
-impl<T: BloomHashIndex> Into<Bloom<T>> for AtomicBloom<T> {
-    fn into(self) -> Bloom<T> {
-        let bits: Vec<_> = self.bits.into_iter().map(AtomicU64::into_inner).collect();
+impl<T: BloomHashIndex> From<AtomicBloom<T>> for Bloom<T> {
+    fn from(atomic_bloom: AtomicBloom<T>) -> Self {
+        let bits: Vec<_> = atomic_bloom
+            .bits
+            .into_iter()
+            .map(AtomicU64::into_inner)
+            .collect();
         let num_bits_set = bits.iter().map(|x| x.count_ones() as u64).sum();
         let mut bits: BitVec<u64> = bits.into();
-        bits.truncate(self.num_bits);
+        bits.truncate(atomic_bloom.num_bits);
         Bloom {
-            keys: self.keys,
+            keys: atomic_bloom.keys,
             bits,
             num_bits_set,
             _phantom: PhantomData::default(),

runtime/src/log_collector.rs

@@ -30,9 +30,9 @@ impl LogCollector {
     }
 }
 
-impl Into<Vec<String>> for LogCollector {
-    fn into(self) -> Vec<String> {
-        self.inner.into_inner().messages
+impl From<LogCollector> for Vec<String> {
+    fn from(log_collector: LogCollector) -> Self {
+        log_collector.inner.into_inner().messages
     }
 }
 

runtime/src/native_loader.rs

@@ -14,7 +14,13 @@ use solana_sdk::{
     process_instruction::{InvokeContext, LoaderEntrypoint},
     pubkey::Pubkey,
 };
-use std::{collections::HashMap, env, path::PathBuf, str, sync::RwLock};
+use std::{
+    collections::HashMap,
+    env,
+    path::{Path, PathBuf},
+    str,
+    sync::RwLock,
+};
 use thiserror::Error;
 
 #[derive(Error, Debug, Serialize, Clone, PartialEq, FromPrimitive, ToPrimitive)]
@@ -85,12 +91,12 @@ impl NativeLoader {
     }
 
     #[cfg(windows)]
-    fn library_open(path: &PathBuf) -> Result<Library, libloading::Error> {
+    fn library_open(path: &Path) -> Result<Library, libloading::Error> {
         Library::new(path)
     }
 
     #[cfg(not(windows))]
-    fn library_open(path: &PathBuf) -> Result<Library, libloading::Error> {
+    fn library_open(path: &Path) -> Result<Library, libloading::Error> {
         // Linux tls bug can cause crash on dlclose(), workaround by never unloading
         Library::open(Some(path), libc::RTLD_NODELETE | libc::RTLD_NOW)
     }

runtime/src/serde_snapshot/future.rs

@@ -24,9 +24,9 @@ impl From<&AccountStorageEntry> for SerializableAccountStorageEntry {
     }
 }
 
-impl Into<AccountStorageEntry> for SerializableAccountStorageEntry {
-    fn into(self) -> AccountStorageEntry {
-        AccountStorageEntry::new_empty_map(self.id, self.accounts_current_len)
+impl From<SerializableAccountStorageEntry> for AccountStorageEntry {
+    fn from(s: SerializableAccountStorageEntry) -> Self {
+        AccountStorageEntry::new_empty_map(s.id, s.accounts_current_len)
     }
 }
 
@@ -71,43 +71,44 @@ pub(crate) struct DeserializableVersionedBank {
     pub(crate) message_processor: MessageProcessor,
 }
 
-impl Into<BankFieldsToDeserialize> for DeserializableVersionedBank {
-    fn into(self) -> BankFieldsToDeserialize {
+impl From<DeserializableVersionedBank> for BankFieldsToDeserialize {
+    fn from(dvb: DeserializableVersionedBank) -> Self {
         BankFieldsToDeserialize {
-            blockhash_queue: self.blockhash_queue,
-            ancestors: self.ancestors,
-            hash: self.hash,
-            parent_hash: self.parent_hash,
-            parent_slot: self.parent_slot,
-            hard_forks: self.hard_forks,
-            transaction_count: self.transaction_count,
-            tick_height: self.tick_height,
-            signature_count: self.signature_count,
-            capitalization: self.capitalization,
-            max_tick_height: self.max_tick_height,
-            hashes_per_tick: self.hashes_per_tick,
-            ticks_per_slot: self.ticks_per_slot,
-            ns_per_slot: self.ns_per_slot,
-            genesis_creation_time: self.genesis_creation_time,
-            slots_per_year: self.slots_per_year,
-            unused: self.unused,
-            slot: self.slot,
-            epoch: self.epoch,
-            block_height: self.block_height,
-            collector_id: self.collector_id,
-            collector_fees: self.collector_fees,
-            fee_calculator: self.fee_calculator,
-            fee_rate_governor: self.fee_rate_governor,
-            collected_rent: self.collected_rent,
-            rent_collector: self.rent_collector,
-            epoch_schedule: self.epoch_schedule,
-            inflation: self.inflation,
-            stakes: self.stakes,
-            epoch_stakes: self.epoch_stakes,
-            is_delta: self.is_delta,
+            blockhash_queue: dvb.blockhash_queue,
+            ancestors: dvb.ancestors,
+            hash: dvb.hash,
+            parent_hash: dvb.parent_hash,
+            parent_slot: dvb.parent_slot,
+            hard_forks: dvb.hard_forks,
+            transaction_count: dvb.transaction_count,
+            tick_height: dvb.tick_height,
+            signature_count: dvb.signature_count,
+            capitalization: dvb.capitalization,
+            max_tick_height: dvb.max_tick_height,
+            hashes_per_tick: dvb.hashes_per_tick,
+            ticks_per_slot: dvb.ticks_per_slot,
+            ns_per_slot: dvb.ns_per_slot,
+            genesis_creation_time: dvb.genesis_creation_time,
+            slots_per_year: dvb.slots_per_year,
+            unused: dvb.unused,
+            slot: dvb.slot,
+            epoch: dvb.epoch,
+            block_height: dvb.block_height,
+            collector_id: dvb.collector_id,
+            collector_fees: dvb.collector_fees,
+            fee_calculator: dvb.fee_calculator,
+            fee_rate_governor: dvb.fee_rate_governor,
+            collected_rent: dvb.collected_rent,
+            rent_collector: dvb.rent_collector,
+            epoch_schedule: dvb.epoch_schedule,
+            inflation: dvb.inflation,
+            stakes: dvb.stakes,
+            epoch_stakes: dvb.epoch_stakes,
+            is_delta: dvb.is_delta,
         }
     }
 }
+
 // Serializable version of Bank, not Deserializable to avoid cloning by using refs.
 // Sync fields with DeserializableVersionedBank!
 #[derive(Serialize)]

runtime/src/snapshot_utils.rs

@@ -585,7 +585,7 @@ pub fn remove_snapshot<P: AsRef<Path>>(slot: Slot, snapshot_path: P) -> Result<(
 pub fn bank_from_archive<P: AsRef<Path>>(
     account_paths: &[PathBuf],
     frozen_account_pubkeys: &[Pubkey],
-    snapshot_path: &PathBuf,
+    snapshot_path: &Path,
     snapshot_tar: P,
     archive_format: ArchiveFormat,
     genesis_config: &GenesisConfig,
@@ -760,7 +760,7 @@ fn rebuild_bank_from_snapshots<P>(
     snapshot_version: &str,
     account_paths: &[PathBuf],
     frozen_account_pubkeys: &[Pubkey],
-    unpacked_snapshots_dir: &PathBuf,
+    unpacked_snapshots_dir: &Path,
     append_vecs_path: P,
     genesis_config: &GenesisConfig,
     debug_keys: Option<Arc<HashSet<Pubkey>>>,

scripts/coverage.sh

@@ -10,7 +10,7 @@ if ! command -v grcov; then
   exit 1
 fi
 
-if [[ ! "$(grcov --version)" =~ 0.6.1 ]]; then
+if [[ ! "$(grcov --version)" =~ 0.[67].1 ]]; then
   echo Error: Required grcov version not installed
 
   echo "Installed version: $(grcov --version)"

sdk/cargo-build-bpf/src/main.rs

@@ -70,11 +70,7 @@ where
     }
 }
 
-fn build_bpf_package(
-    config: &Config,
-    target_directory: &PathBuf,
-    package: &cargo_metadata::Package,
-) {
+fn build_bpf_package(config: &Config, target_directory: &Path, package: &cargo_metadata::Package) {
     let program_name = {
         let cdylib_targets = package
             .targets

sdk/cargo-test-bpf/src/main.rs

@@ -67,11 +67,7 @@ where
     }
 }
 
-fn test_bpf_package(
-    config: &Config,
-    target_directory: &PathBuf,
-    package: &cargo_metadata::Package,
-) {
+fn test_bpf_package(config: &Config, target_directory: &Path, package: &cargo_metadata::Package) {
     let set_test_bpf_feature = package.features.contains_key("test-bpf");
 
     let bpf_out_dir = config

sdk/program/src/program_option.rs

@@ -950,6 +950,17 @@ impl<T> From<Option<T>> for COption<T> {
     }
 }
 
+#[rustversion::since(1.49.0)]
+impl<T> From<COption<T>> for Option<T> {
+    fn from(coption: COption<T>) -> Self {
+        match coption {
+            COption::Some(value) => Some(value),
+            COption::None => None,
+        }
+    }
+}
+
+#[rustversion::before(1.49.0)] // Remove `Into` once the BPF toolchain upgrades to 1.49.0 or newer
 impl<T> Into<Option<T>> for COption<T> {
     fn into(self) -> Option<T> {
         match self {

sdk/program/src/program_pack.rs

@@ -43,7 +43,7 @@ pub trait Pack: Sealed {
         if input.len() != Self::LEN {
             return Err(ProgramError::InvalidAccountData);
         }
-        Ok(Self::unpack_from_slice(input)?)
+        Self::unpack_from_slice(input)
     }
 
     /// Pack into slice

sdk/src/signature.rs

@@ -125,9 +125,9 @@ impl fmt::Display for Signature {
     }
 }
 
-impl Into<[u8; 64]> for Signature {
-    fn into(self) -> [u8; 64] {
-        <GenericArray<u8, U64> as Into<[u8; 64]>>::into(self.0)
+impl From<Signature> for [u8; 64] {
+    fn from(signature: Signature) -> Self {
+        signature.0.into()
     }
 }
 

storage-bigtable/src/access_token.rs

@@ -89,6 +89,7 @@ impl AccessToken {
                 return;
             }
 
+            #[allow(deprecated)]
             if self
                 .refresh_active
                 .compare_and_swap(false, true, Ordering::Relaxed)

storage-proto/src/convert.rs

@@ -768,11 +768,11 @@ impl TryFrom<tx_by_addr::TransactionByAddr> for Vec<TransactionByAddrInfo> {
     type Error = &'static str;
 
     fn try_from(collection: tx_by_addr::TransactionByAddr) -> Result<Self, Self::Error> {
-        Ok(collection
+        collection
             .tx_by_addrs
             .into_iter()
             .map(|tx_by_addr| tx_by_addr.try_into())
-            .collect::<Result<Vec<TransactionByAddrInfo>, Self::Error>>()?)
+            .collect::<Result<Vec<TransactionByAddrInfo>, Self::Error>>()
     }
 }