Revert "Reformat imports to a consistent style for imports"

This reverts commit 139d15cd84.

sdk/program/src/account_info.rs

@@ -1,10 +1,8 @@
-use {
-    crate::{clock::Epoch, program_error::ProgramError, pubkey::Pubkey},
-    std::{
-        cell::{Ref, RefCell, RefMut},
-        cmp, fmt,
-        rc::Rc,
-    },
+use crate::{clock::Epoch, program_error::ProgramError, pubkey::Pubkey};
+use std::{
+    cell::{Ref, RefCell, RefMut},
+    cmp, fmt,
+    rc::Rc,
 };
 
 /// Account information

sdk/program/src/bpf_loader_upgradeable.rs

@@ -8,15 +8,13 @@
 //! upgradeable programs which still have a functioning authority.  For more
 //! information refer to `loader_upgradeable_instruction.rs`
 
-use {
-    crate::{
-        instruction::{AccountMeta, Instruction, InstructionError},
-        loader_upgradeable_instruction::UpgradeableLoaderInstruction,
-        pubkey::Pubkey,
-        system_instruction, sysvar,
-    },
-    bincode::serialized_size,
+use crate::{
+    instruction::{AccountMeta, Instruction, InstructionError},
+    loader_upgradeable_instruction::UpgradeableLoaderInstruction,
+    pubkey::Pubkey,
+    system_instruction, sysvar,
 };
+use bincode::serialized_size;
 
 crate::declare_id!("BPFLoaderUpgradeab1e11111111111111111111111");
 

sdk/program/src/decode_error.rs

@@ -13,7 +13,8 @@ pub trait DecodeError<E> {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, num_derive::FromPrimitive};
+    use super::*;
+    use num_derive::FromPrimitive;
 
     #[test]
     fn test_decode_custom_error_to_enum() {

sdk/program/src/entrypoint.rs

@@ -2,18 +2,17 @@
 //! BPFLoader.  For more information see './bpf_loader.rs'
 
 extern crate alloc;
-use {
-    crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey},
-    alloc::vec::Vec,
-    std::{
-        alloc::Layout,
-        cell::RefCell,
-        mem::size_of,
-        ptr::null_mut,
-        rc::Rc,
-        result::Result as ResultGeneric,
-        slice::{from_raw_parts, from_raw_parts_mut},
-    },
+use crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+use alloc::vec::Vec;
+use std::{
+    alloc::Layout,
+    cell::RefCell,
+    mem::size_of,
+    ptr::null_mut,
+    rc::Rc,
+    // Hide Result from bindgen gets confused about generics in non-generic type declarations
+    result::Result as ResultGeneric,
+    slice::{from_raw_parts, from_raw_parts_mut},
 };
 
 pub type ProgramResult = ResultGeneric<(), ProgramError>;
@@ -355,7 +354,8 @@ pub unsafe fn deserialize<'a>(input: *mut u8) -> (&'a Pubkey, Vec<AccountInfo<'a
 
 #[cfg(test)]
 mod test {
-    use {super::*, std::alloc::GlobalAlloc};
+    use super::*;
+    use std::alloc::GlobalAlloc;
 
     #[test]
     fn test_bump_allocator() {

sdk/program/src/entrypoint_deprecated.rs

@@ -4,16 +4,15 @@
 //!  './bpf_loader_deprecated.rs'
 
 extern crate alloc;
-use {
-    crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey},
-    alloc::vec::Vec,
-    std::{
-        cell::RefCell,
-        mem::size_of,
-        rc::Rc,
-        result::Result as ResultGeneric,
-        slice::{from_raw_parts, from_raw_parts_mut},
-    },
+use crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+use alloc::vec::Vec;
+use std::{
+    cell::RefCell,
+    mem::size_of,
+    rc::Rc,
+    // Hide Result from bindgen gets confused about generics in non-generic type declarations
+    result::Result as ResultGeneric,
+    slice::{from_raw_parts, from_raw_parts_mut},
 };
 
 pub type ProgramResult = ResultGeneric<(), ProgramError>;

sdk/program/src/feature.rs

@@ -58,7 +58,8 @@ pub fn activate_with_lamports(
 
 #[cfg(test)]
 mod test {
-    use {super::*, solana_program::clock::Slot};
+    use super::*;
+    use solana_program::clock::Slot;
 
     #[test]
     fn feature_sizeof() {

sdk/program/src/fee_calculator.rs

@@ -1,8 +1,9 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    crate::{clock::DEFAULT_MS_PER_SLOT, ed25519_program, message::Message, secp256k1_program},
-    log::*,
-};
+use crate::clock::DEFAULT_MS_PER_SLOT;
+use crate::ed25519_program;
+use crate::message::Message;
+use crate::secp256k1_program;
+use log::*;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug, AbiExample)]
 #[serde(rename_all = "camelCase")]
@@ -179,10 +180,8 @@ impl FeeRateGovernor {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{pubkey::Pubkey, system_instruction},
-    };
+    use super::*;
+    use crate::{pubkey::Pubkey, system_instruction};
 
     #[test]
     fn test_fee_rate_governor_burn() {

sdk/program/src/hash.rs

@@ -1,12 +1,10 @@
 //! The `hash` module provides functions for creating SHA-256 hashes.
 
-use {
-    crate::sanitize::Sanitize,
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    sha2::{Digest, Sha256},
-    std::{convert::TryFrom, fmt, mem, str::FromStr},
-    thiserror::Error,
-};
+use crate::sanitize::Sanitize;
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use sha2::{Digest, Sha256};
+use std::{convert::TryFrom, fmt, mem, str::FromStr};
+use thiserror::Error;
 
 pub const HASH_BYTES: usize = 32;
 /// Maximum string length of a base58 encoded hash

sdk/program/src/instruction.rs

@@ -1,13 +1,12 @@
 #![allow(clippy::integer_arithmetic)]
 //! Defines a composable Instruction type and a memory-efficient CompiledInstruction.
 
-use {
-    crate::{pubkey::Pubkey, sanitize::Sanitize, short_vec},
-    bincode::serialize,
-    borsh::BorshSerialize,
-    serde::Serialize,
-    thiserror::Error,
-};
+use crate::sanitize::Sanitize;
+use crate::{pubkey::Pubkey, short_vec};
+use bincode::serialize;
+use borsh::BorshSerialize;
+use serde::Serialize;
+use thiserror::Error;
 
 /// Reasons the runtime might have rejected an instruction.
 ///

sdk/program/src/keccak.rs

@@ -1,10 +1,8 @@
-use {
-    crate::sanitize::Sanitize,
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    sha3::{Digest, Keccak256},
-    std::{convert::TryFrom, fmt, mem, str::FromStr},
-    thiserror::Error,
-};
+use crate::sanitize::Sanitize;
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use sha3::{Digest, Keccak256};
+use std::{convert::TryFrom, fmt, mem, str::FromStr};
+use thiserror::Error;
 
 pub const HASH_BYTES: usize = 32;
 /// Maximum string length of a base58 encoded hash

sdk/program/src/lamports.rs

@@ -1,4 +1,5 @@
-use {crate::instruction::InstructionError, thiserror::Error};
+use crate::instruction::InstructionError;
+use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum LamportsError {

sdk/program/src/message.rs

@@ -1,22 +1,20 @@
 #![allow(clippy::integer_arithmetic)]
 //! A library for generating a message from a sequence of instructions
 
-use {
-    crate::{
-        bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable,
-        hash::Hash,
-        instruction::{AccountMeta, CompiledInstruction, Instruction},
-        pubkey::Pubkey,
-        sanitize::{Sanitize, SanitizeError},
-        serialize_utils::{
-            append_slice, append_u16, append_u8, read_pubkey, read_slice, read_u16, read_u8,
-        },
-        short_vec, system_instruction, system_program, sysvar,
-    },
-    itertools::Itertools,
-    lazy_static::lazy_static,
-    std::{convert::TryFrom, str::FromStr},
+use crate::sanitize::{Sanitize, SanitizeError};
+use crate::serialize_utils::{
+    append_slice, append_u16, append_u8, read_pubkey, read_slice, read_u16, read_u8,
 };
+use crate::{
+    bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable,
+    hash::Hash,
+    instruction::{AccountMeta, CompiledInstruction, Instruction},
+    pubkey::Pubkey,
+    short_vec, system_instruction, system_program, sysvar,
+};
+use itertools::Itertools;
+use lazy_static::lazy_static;
+use std::{convert::TryFrom, str::FromStr};
 
 lazy_static! {
     // Copied keys over since direct references create cyclical dependency.
@@ -551,11 +549,9 @@ impl Message {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{hash, instruction::AccountMeta},
-        std::collections::HashSet,
-    };
+    use super::*;
+    use crate::{hash, instruction::AccountMeta};
+    use std::collections::HashSet;
 
     #[test]
     fn test_message_unique_program_ids() {

sdk/program/src/nonce/state/current.rs

@@ -1,8 +1,6 @@
-use {
-    super::Versions,
-    crate::{fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey},
-    serde_derive::{Deserialize, Serialize},
-};
+use super::Versions;
+use crate::{fee_calculator::FeeCalculator, hash::Hash, pubkey::Pubkey};
+use serde_derive::{Deserialize, Serialize};
 
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq, Clone)]
 pub struct Data {

sdk/program/src/nonce/state/mod.rs

@@ -1,5 +1,6 @@
 mod current;
 pub use current::{Data, State};
+
 use serde_derive::{Deserialize, Serialize};
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]

sdk/program/src/program_error.rs

@@ -1,11 +1,9 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    crate::{decode_error::DecodeError, instruction::InstructionError, msg, pubkey::PubkeyError},
-    borsh::maybestd::io::Error as BorshIoError,
-    num_traits::{FromPrimitive, ToPrimitive},
-    std::convert::TryFrom,
-    thiserror::Error,
-};
+use crate::{decode_error::DecodeError, instruction::InstructionError, msg, pubkey::PubkeyError};
+use borsh::maybestd::io::Error as BorshIoError;
+use num_traits::{FromPrimitive, ToPrimitive};
+use std::convert::TryFrom;
+use thiserror::Error;
 
 /// Reasons the program may fail
 #[derive(Clone, Debug, Deserialize, Eq, Error, PartialEq, Serialize)]

sdk/program/src/program_stubs.rs

@@ -2,14 +2,12 @@
 
 #![cfg(not(target_arch = "bpf"))]
 
-use {
-    crate::{
-        account_info::AccountInfo, entrypoint::ProgramResult, instruction::Instruction,
-        program_error::UNSUPPORTED_SYSVAR, pubkey::Pubkey,
-    },
-    itertools::Itertools,
-    std::sync::{Arc, RwLock},
+use crate::{
+    account_info::AccountInfo, entrypoint::ProgramResult, instruction::Instruction,
+    program_error::UNSUPPORTED_SYSVAR, pubkey::Pubkey,
 };
+use itertools::Itertools;
+use std::sync::{Arc, RwLock};
 
 lazy_static::lazy_static! {
     static ref SYSCALL_STUBS: Arc<RwLock<Box<dyn SyscallStubs>>> = Arc::new(RwLock::new(Box::new(DefaultSyscallStubs {})));

sdk/program/src/pubkey.rs

@@ -393,7 +393,8 @@ impl fmt::Display for Pubkey {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, std::str::from_utf8};
+    use super::*;
+    use std::str::from_utf8;
 
     #[test]
     fn test_new_unique() {

sdk/program/src/secp256k1_recover.rs

@@ -1,8 +1,6 @@
-use {
-    borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
-    core::convert::TryFrom,
-    thiserror::Error,
-};
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use core::convert::TryFrom;
+use thiserror::Error;
 
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
 pub enum Secp256k1RecoverError {

sdk/program/src/serialize_utils.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::integer_arithmetic)]
-use crate::{pubkey::Pubkey, sanitize::SanitizeError};
+use crate::pubkey::Pubkey;
+use crate::sanitize::SanitizeError;
 
 pub fn append_u16(buf: &mut Vec<u8>, data: u16) {
     let start = buf.len();

sdk/program/src/short_vec.rs

@@ -1,12 +1,10 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    serde::{
-        de::{self, Deserializer, SeqAccess, Visitor},
-        ser::{self, SerializeTuple, Serializer},
-        Deserialize, Serialize,
-    },
-    std::{convert::TryFrom, fmt, marker::PhantomData},
+use serde::{
+    de::{self, Deserializer, SeqAccess, Visitor},
+    ser::{self, SerializeTuple, Serializer},
+    {Deserialize, Serialize},
 };
+use std::{convert::TryFrom, fmt, marker::PhantomData};
 
 /// Same as u16, but serialized with 1 to 3 bytes. If the value is above
 /// 0x7f, the top bit is set and the remaining value is stored in the next
@@ -267,11 +265,9 @@ pub fn decode_shortu16_len(bytes: &[u8]) -> Result<(usize, usize), ()> {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        assert_matches::assert_matches,
-        bincode::{deserialize, serialize},
-    };
+    use super::*;
+    use assert_matches::assert_matches;
+    use bincode::{deserialize, serialize};
 
     /// Return the serialized length.
     fn encode_len(len: u16) -> Vec<u8> {

sdk/program/src/slot_hashes.rs

@@ -2,10 +2,8 @@
 //!
 //! this account carries the Bank's most recent bank hashes for some N parents
 //!
-use {
-    crate::hash::Hash,
-    std::{iter::FromIterator, ops::Deref},
-};
+use crate::hash::Hash;
+use std::{iter::FromIterator, ops::Deref};
 
 pub const MAX_ENTRIES: usize = 512; // about 2.5 minutes to get your vote in
 
@@ -53,7 +51,8 @@ impl Deref for SlotHashes {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::hash::hash};
+    use super::*;
+    use crate::hash::hash;
 
     #[test]
     fn test() {

sdk/program/src/slot_history.rs

@@ -3,7 +3,8 @@
 //! slot history
 //!
 pub use crate::clock::Slot;
-use bv::{BitVec, BitsMut};
+use bv::BitVec;
+use bv::BitsMut;
 
 #[repr(C)]
 #[derive(Clone, Serialize, Deserialize, PartialEq)]
@@ -85,7 +86,8 @@ impl SlotHistory {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, log::*};
+    use super::*;
+    use log::*;
 
     #[test]
     fn slot_history_test1() {

sdk/program/src/stake/instruction.rs

@@ -1,14 +1,14 @@
 use {
+    crate::stake::{
+        config,
+        program::id,
+        state::{Authorized, Lockup, StakeAuthorize, StakeState},
+    },
     crate::{
         clock::{Epoch, UnixTimestamp},
         decode_error::DecodeError,
         instruction::{AccountMeta, Instruction},
         pubkey::Pubkey,
-        stake::{
-            config,
-            program::id,
-            state::{Authorized, Lockup, StakeAuthorize, StakeState},
-        },
         system_instruction, sysvar,
     },
     log::*,
@@ -680,7 +680,8 @@ pub fn set_lockup_checked(
 
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::instruction::InstructionError};
+    use super::*;
+    use crate::instruction::InstructionError;
 
     #[test]
     fn test_custom_error_decode() {

sdk/program/src/stake_history.rs

@@ -3,6 +3,7 @@
 //! this account carries history about stake activations and de-activations
 //!
 pub use crate::clock::Epoch;
+
 use std::ops::Deref;
 
 pub const MAX_ENTRIES: usize = 512; // it should never take as many as 512 epochs to warm up or cool down

sdk/program/src/system_instruction.rs

@@ -1,15 +1,13 @@
-use {
-    crate::{
-        decode_error::DecodeError,
-        instruction::{AccountMeta, Instruction, InstructionError},
-        nonce,
-        pubkey::Pubkey,
-        system_program,
-        sysvar::{recent_blockhashes, rent},
-    },
-    num_derive::{FromPrimitive, ToPrimitive},
-    thiserror::Error,
+use crate::{
+    decode_error::DecodeError,
+    instruction::{AccountMeta, Instruction, InstructionError},
+    nonce,
+    pubkey::Pubkey,
+    system_program,
+    sysvar::{recent_blockhashes, rent},
 };
+use num_derive::{FromPrimitive, ToPrimitive};
+use thiserror::Error;
 
 #[derive(Error, Debug, Serialize, Clone, PartialEq, FromPrimitive, ToPrimitive)]
 pub enum SystemError {
@@ -569,11 +567,9 @@ pub fn authorize_nonce_account(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::instruction::{Instruction, InstructionError},
-        num_traits::ToPrimitive,
-    };
+    use super::*;
+    use crate::instruction::{Instruction, InstructionError};
+    use num_traits::ToPrimitive;
 
     fn get_keys(instruction: &Instruction) -> Vec<Pubkey> {
         instruction.accounts.iter().map(|x| x.pubkey).collect()

sdk/program/src/sysvar/clock.rs

@@ -1,6 +1,7 @@
 //! This account contains the clock slot, epoch, and leader_schedule_epoch
 //!
 pub use crate::clock::Clock;
+
 use crate::{impl_sysvar_get, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarC1ock11111111111111111111111111111111", Clock);

sdk/program/src/sysvar/epoch_schedule.rs

@@ -1,6 +1,7 @@
 //! This account contains the current cluster rent
 //!
 pub use crate::epoch_schedule::EpochSchedule;
+
 use crate::{impl_sysvar_get, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarEpochSchedu1e111111111111111111111111", EpochSchedule);

sdk/program/src/sysvar/instructions.rs

@@ -105,10 +105,8 @@ pub fn get_instruction_relative(
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{instruction::AccountMeta, message::Message, pubkey::Pubkey},
-    };
+    use super::*;
+    use crate::{instruction::AccountMeta, message::Message, pubkey::Pubkey};
 
     #[test]
     fn test_load_store_instruction() {

sdk/program/src/sysvar/mod.rs

@@ -108,11 +108,9 @@ macro_rules! impl_sysvar_get {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{clock::Epoch, program_error::ProgramError, pubkey::Pubkey},
-        std::{cell::RefCell, rc::Rc},
-    };
+    use super::*;
+    use crate::{clock::Epoch, program_error::ProgramError, pubkey::Pubkey};
+    use std::{cell::RefCell, rc::Rc};
 
     #[repr(C)]
     #[derive(Serialize, Deserialize, Debug, Default, PartialEq)]

sdk/program/src/sysvar/recent_blockhashes.rs

@@ -1,13 +1,11 @@
 #![allow(clippy::integer_arithmetic)]
-use {
-    crate::{
-        declare_sysvar_id,
-        fee_calculator::FeeCalculator,
-        hash::{hash, Hash},
-        sysvar::Sysvar,
-    },
-    std::{cmp::Ordering, collections::BinaryHeap, iter::FromIterator, ops::Deref},
+use crate::{
+    declare_sysvar_id,
+    fee_calculator::FeeCalculator,
+    hash::{hash, Hash},
+    sysvar::Sysvar,
 };
+use std::{cmp::Ordering, collections::BinaryHeap, iter::FromIterator, ops::Deref};
 
 pub const MAX_ENTRIES: usize = 150;
 
@@ -147,7 +145,8 @@ pub fn create_test_recent_blockhashes(start: usize) -> RecentBlockhashes {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::clock::MAX_PROCESSING_AGE};
+    use super::*;
+    use crate::clock::MAX_PROCESSING_AGE;
 
     #[test]
     #[allow(clippy::assertions_on_constants)]

sdk/program/src/sysvar/rent.rs

@@ -1,6 +1,7 @@
 //! This account contains the current cluster rent
 //!
 pub use crate::rent::Rent;
+
 use crate::{impl_sysvar_get, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarRent111111111111111111111111111111111", Rent);

sdk/program/src/sysvar/slot_hashes.rs

@@ -3,6 +3,7 @@
 //! this account carries the Bank's most recent bank hashes for some N parents
 //!
 pub use crate::slot_hashes::SlotHashes;
+
 use crate::{account_info::AccountInfo, program_error::ProgramError, sysvar::Sysvar};
 
 crate::declare_sysvar_id!("SysvarS1otHashes111111111111111111111111111", SlotHashes);
@@ -21,10 +22,8 @@ impl Sysvar for SlotHashes {
 
 #[cfg(test)]
 mod tests {
-    use {
-        super::*,
-        crate::{clock::Slot, hash::Hash, slot_hashes::MAX_ENTRIES},
-    };
+    use super::*;
+    use crate::{clock::Slot, hash::Hash, slot_hashes::MAX_ENTRIES};
 
     #[test]
     fn test_size_of() {

sdk/program/src/sysvar/slot_history.rs

@@ -3,11 +3,12 @@
 //! this account carries a bitvector of slots present over the past
 //! epoch
 //!
-use crate::sysvar::Sysvar;
 pub use crate::{
     account_info::AccountInfo, program_error::ProgramError, slot_history::SlotHistory,
 };
 
+use crate::sysvar::Sysvar;
+
 crate::declare_sysvar_id!("SysvarS1otHistory11111111111111111111111111", SlotHistory);
 
 impl Sysvar for SlotHistory {

sdk/program/src/sysvar/stake_history.rs

@@ -3,6 +3,7 @@
 //! this account carries history about stake activations and de-activations
 //!
 pub use crate::stake_history::StakeHistory;
+
 use crate::sysvar::Sysvar;
 
 crate::declare_sysvar_id!("SysvarStakeHistory1111111111111111111111111", StakeHistory);
@@ -17,7 +18,8 @@ impl Sysvar for StakeHistory {
 
 #[cfg(test)]
 mod tests {
-    use {super::*, crate::stake_history::*};
+    use super::*;
+    use crate::stake_history::*;
 
     #[test]
     fn test_size_of() {