Fix import order tree-wide.

I ran cargo +nightly fmt with these settings:
imports_granularity = Module
group_imports = StdExternalCrate

Author: mstange

fxprof-processed-profile/src/cpu_delta.rs

@@ -1,6 +1,7 @@
-use serde::ser::{Serialize, Serializer};
 use std::time::Duration;
 
+use serde::ser::{Serialize, Serializer};
+
 /// The amount of CPU time between thread samples.
 ///
 /// This is used in the Firefox Profiler UI to draw an activity graph per thread.

fxprof-processed-profile/src/fast_hash_map.rs

@@ -1,5 +1,6 @@
-use fxhash::FxHasher;
 use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 
+use fxhash::FxHasher;
+
 pub type FastHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;

fxprof-processed-profile/src/library_info.rs

@@ -1,7 +1,9 @@
-use debugid::DebugId;
-use serde::{ser::SerializeMap, Serialize, Serializer};
 use std::sync::Arc;
 
+use debugid::DebugId;
+use serde::ser::SerializeMap;
+use serde::{Serialize, Serializer};
+
 /// A library ("binary" / "module" / "DSO") which is loaded into a process.
 /// This can be the main executable file or a dynamic library, or any other
 /// mapping of executable memory.

fxprof-processed-profile/src/native_symbols.rs

@@ -1,11 +1,9 @@
 use serde::ser::{Serialize, SerializeMap, Serializer};
 
-use crate::{
-    fast_hash_map::FastHashMap,
-    global_lib_table::GlobalLibIndex,
-    library_info::Symbol,
-    thread_string_table::{ThreadInternalStringIndex, ThreadStringTable},
-};
+use crate::fast_hash_map::FastHashMap;
+use crate::global_lib_table::GlobalLibIndex;
+use crate::library_info::Symbol;
+use crate::thread_string_table::{ThreadInternalStringIndex, ThreadStringTable};
 
 /// The native symbols that are used by frames in a thread's `FrameTable`.
 /// They can be from different libraries. Only used symbols are included.

fxprof-processed-profile/src/reference_timestamp.rs

@@ -1,6 +1,7 @@
-use serde::ser::{Serialize, Serializer};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
+use serde::ser::{Serialize, Serializer};
+
 /// A timestamp which anchors the profile in absolute time.
 ///
 /// In the profile JSON, this uses a UNIX timestamp.

fxprof-processed-profile/src/resource_table.rs

@@ -3,8 +3,7 @@ use serde::ser::{Serialize, SerializeMap, Serializer};
 use crate::fast_hash_map::FastHashMap;
 use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
 use crate::serialization_helpers::SerializableSingleValueColumn;
-use crate::thread_string_table::ThreadInternalStringIndex;
-use crate::thread_string_table::ThreadStringTable;
+use crate::thread_string_table::{ThreadInternalStringIndex, ThreadStringTable};
 
 #[derive(Debug, Clone, Default)]
 pub struct ResourceTable {

fxprof-processed-profile/src/sample_table.rs

@@ -1,8 +1,11 @@
-use crate::Timestamp;
-use crate::{cpu_delta::CpuDelta, serialization_helpers::SerializableSingleValueColumn};
-use serde::ser::{Serialize, SerializeMap, Serializer};
 use std::fmt::{Display, Formatter};
 
+use serde::ser::{Serialize, SerializeMap, Serializer};
+
+use crate::cpu_delta::CpuDelta;
+use crate::serialization_helpers::SerializableSingleValueColumn;
+use crate::Timestamp;
+
 /// The sample table contains stacks with timestamps and some extra information.
 ///
 /// In the most common case, this is used for time-based sampling: At a fixed but
@@ -263,10 +266,11 @@ impl Serialize for NativeAllocationsTable {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use assert_json_diff::assert_json_eq;
     use serde_json::json;
 
+    use super::*;
+
     #[test]
     fn test_serialize_native_allocations() {
         // example of `nativeAllocations`:

fxprof-processed-profile/src/thread_string_table.rs

@@ -1,7 +1,7 @@
 use serde::ser::{Serialize, Serializer};
 
-use crate::string_table::{GlobalStringIndex, GlobalStringTable, StringIndex};
-use crate::{fast_hash_map::FastHashMap, string_table::StringTable};
+use crate::fast_hash_map::FastHashMap;
+use crate::string_table::{GlobalStringIndex, GlobalStringTable, StringIndex, StringTable};
 
 #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub struct ThreadInternalStringIndex(pub StringIndex);

fxprof-processed-profile/tests/integration_tests/main.rs

@@ -1,16 +1,15 @@
+use std::sync::Arc;
+use std::time::Duration;
+
 use assert_json_diff::assert_json_eq;
 use debugid::DebugId;
-use serde_json::json;
-
 use fxprof_processed_profile::{
     CategoryColor, CategoryHandle, CpuDelta, Frame, FrameFlags, FrameInfo, LibraryInfo,
     MarkerDynamicField, MarkerFieldFormat, MarkerLocation, MarkerSchema, MarkerSchemaField,
     MarkerStaticField, MarkerTiming, Profile, ProfilerMarker, ReferenceTimestamp, SamplingInterval,
     Symbol, SymbolTable, Timestamp,
 };
-
-use std::sync::Arc;
-use std::time::Duration;
+use serde_json::json;
 
 // TODO: Add tests for CategoryPairHandle, ProcessHandle, ThreadHandle
 

gecko_profile/src/lib.rs

@@ -1,13 +1,12 @@
-pub use debugid;
-
-use debugid::{CodeId, DebugId};
-use serde_json::{json, Value};
+use std::cmp::Ordering;
 use std::collections::{BTreeMap, HashMap};
 use std::path::{Path, PathBuf};
-
-use std::cmp::Ordering;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
+pub use debugid;
+use debugid::{CodeId, DebugId};
+use serde_json::{json, Value};
+
 mod markers;
 
 pub use markers::*;
@@ -832,9 +831,10 @@ impl StringTable {
 
 #[cfg(test)]
 mod test {
+    use std::time::{Duration, Instant, SystemTime};
+
     use assert_json_diff::assert_json_eq;
     use serde_json::json;
-    use std::time::{Duration, Instant, SystemTime};
 
     use crate::{
         MarkerDynamicField, MarkerFieldFormat, MarkerLocation, MarkerSchema, MarkerSchemaField,

gecko_profile/src/markers.rs

@@ -2,9 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use std::time::Instant;
+
 use serde_derive::Serialize;
 use serde_json::{json, Value};
-use std::time::Instant;
 
 #[derive(Debug, Clone)]
 pub enum MarkerTiming {

samply-api/src/asm/mod.rs

@@ -1,16 +1,16 @@
 use std::str::FromStr;
 
+use samply_symbols::debugid::DebugId;
 use samply_symbols::{
-    debugid::DebugId, object, CodeByteReadingError, CodeId, FileAndPathHelper,
-    FileAndPathHelperError, LibraryInfo, LookupAddress, SymbolManager,
+    object, CodeByteReadingError, CodeId, FileAndPathHelper, FileAndPathHelperError, LibraryInfo,
+    LookupAddress, SymbolManager,
 };
 use serde_json::json;
 use yaxpeax_arch::{Arch, DecodeError, LengthedInstruction, Reader, U8Reader};
 use yaxpeax_x86::amd64::{Opcode, Operand};
 
-use crate::asm::response_json::DecodedInstruction;
-
 use self::response_json::Response;
+use crate::asm::response_json::DecodedInstruction;
 
 mod request_json;
 mod response_json;

samply-api/src/asm/request_json.rs

@@ -33,9 +33,10 @@ pub struct Request {
 #[cfg(test)]
 mod test {
 
-    use super::Request;
     use serde_json::Result;
 
+    use super::Request;
+
     #[test]
     fn parse_job() -> Result<()> {
         let data = r#"

samply-api/src/asm/response_json.rs

@@ -64,9 +64,10 @@ impl serde::Serialize for DecodedInstruction {
 
 #[cfg(test)]
 mod test {
-    use super::{DecodedInstruction, Response};
     use serde_json::Result;
 
+    use super::{DecodedInstruction, Response};
+
     #[test]
     fn serialize_correctly() -> Result<()> {
         let response = Response {

samply-api/src/lib.rs

@@ -142,12 +142,11 @@
 //! }
 //! ```
 
+use asm::AsmApi;
+use debugid::DebugId;
 pub use samply_symbols;
 pub use samply_symbols::debugid;
 use samply_symbols::{FileAndPathHelper, SymbolManager};
-
-use asm::AsmApi;
-use debugid::DebugId;
 use serde_json::json;
 use source::SourceApi;
 use symbolicate::SymbolicateApi;

samply-api/src/source/mod.rs

@@ -1,9 +1,11 @@
-use crate::{api_file_path::to_api_file_path, to_debug_id};
 use samply_symbols::{
     FileAndPathHelper, FileAndPathHelperError, LibraryInfo, LookupAddress, SymbolManager,
 };
 use serde_json::json;
 
+use crate::api_file_path::to_api_file_path;
+use crate::to_debug_id;
+
 mod request_json;
 mod response_json;
 

samply-api/src/source/request_json.rs

@@ -27,9 +27,10 @@ pub struct Request {
 #[cfg(test)]
 mod test {
 
-    use super::Request;
     use serde_json::Result;
 
+    use super::Request;
+
     #[test]
     fn parse_job() -> Result<()> {
         let data = r#"

samply-api/src/symbolicate/looked_up_addresses.rs

@@ -1,6 +1,7 @@
-use samply_symbols::FrameDebugInfo;
 use std::collections::BTreeMap;
 
+use samply_symbols::FrameDebugInfo;
+
 pub struct AddressResult {
     pub symbol_address: u32,
     pub symbol_name: String,

samply-api/src/symbolicate/mod.rs

@@ -1,10 +1,13 @@
-use crate::to_debug_id;
-use crate::{api_file_path::to_api_file_path, error::Error};
+use std::collections::HashMap;
+use std::num::NonZeroU32;
+
 use samply_symbols::{
     FileAndPathHelper, FramesLookupResult, LibraryInfo, LookupAddress, SymbolManager,
 };
-use std::collections::HashMap;
-use std::num::NonZeroU32;
+
+use crate::api_file_path::to_api_file_path;
+use crate::error::Error;
+use crate::to_debug_id;
 
 pub mod looked_up_addresses;
 pub mod request_json;

samply-api/src/symbolicate/request_json.rs

@@ -59,9 +59,10 @@ impl<'a> Iterator for JobIterator<'a> {
 #[cfg(test)]
 mod test {
 
-    use super::super::request_json::Request;
     use serde_json::Result;
 
+    use super::super::request_json::Request;
+
     #[test]
     fn parse_job() -> Result<()> {
         let data = r#"

samply-api/src/symbolicate/response_json.rs

@@ -1,4 +1,5 @@
-use std::{collections::HashMap, num::NonZeroU32};
+use std::collections::HashMap;
+use std::num::NonZeroU32;
 
 use serde_derive::Serialize;
 
@@ -101,9 +102,10 @@ impl From<&samply_symbols::Error> for Error {
 mod test {
     use std::collections::HashMap;
 
-    use super::super::response_json;
     use serde_json::Result;
 
+    use super::super::response_json;
+
     #[test]
     fn serialize_correctly() -> Result<()> {
         let response = response_json::Response {

samply-api/tests/integration_tests/main.rs

@@ -1,17 +1,15 @@
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
 use assert_json_diff::assert_json_eq;
 pub use samply_api::debugid::DebugId;
-use samply_api::samply_symbols;
-use samply_api::Api;
-use samply_symbols::OptionallySendFuture;
+use samply_api::{samply_symbols, Api};
 use samply_symbols::{
     CandidatePathInfo, FileAndPathHelper, FileAndPathHelperResult, FileLocation, LibraryInfo,
-    SymbolManager,
+    OptionallySendFuture, SymbolManager,
 };
 
-use std::fs::File;
-use std::io::{Read, Write};
-use std::path::PathBuf;
-
 pub async fn query_api(request_url: &str, request_json: &str, symbol_directory: PathBuf) -> String {
     let helper = Helper { symbol_directory };
     let symbol_manager = SymbolManager::with_helper(helper);

samply-symbols/src/binary_image.rs

@@ -1,9 +1,8 @@
 use debugid::DebugId;
-use linux_perf_data::{jitdump::JitDumpHeader, linux_perf_event_reader::RawData};
-use object::{
-    read::pe::{ImageNtHeaders, ImageOptionalHeader, PeFile, PeFile32, PeFile64},
-    FileKind, Object, ReadRef,
-};
+use linux_perf_data::jitdump::JitDumpHeader;
+use linux_perf_data::linux_perf_event_reader::RawData;
+use object::read::pe::{ImageNtHeaders, ImageOptionalHeader, PeFile, PeFile32, PeFile64};
+use object::{FileKind, Object, ReadRef};
 
 use crate::debugid_util::{code_id_for_object, debug_id_for_object};
 use crate::error::Error;

samply-symbols/src/breakpad/index.rs

@@ -1,3 +1,7 @@
+use std::fmt::Debug;
+use std::str::FromStr;
+use std::{mem, str};
+
 use debugid::DebugId;
 use memchr::memchr;
 use nom::bytes::complete::{tag, take_while};
@@ -10,10 +14,6 @@ use nom::{Err, IResult};
 use zerocopy::{AsBytes, LittleEndian, Ref, U32, U64};
 use zerocopy_derive::{AsBytes, FromBytes, FromZeroes, Unaligned};
 
-use std::fmt::Debug;
-use std::str::FromStr;
-use std::{mem, str};
-
 use crate::CodeId;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -1188,9 +1188,8 @@ fn inline_line(input: &[u8]) -> IResult<&[u8], impl Iterator<Item = Inlinee>> {
 mod test {
     use std::str::FromStr;
 
-    use crate::{ElfBuildId, PeCodeId};
-
     use super::*;
+    use crate::{ElfBuildId, PeCodeId};
 
     #[test]
     fn test1() {