Optimize and format imports

[skip ci]

native/src/base/cxx_extern.rs

@@ -9,8 +9,8 @@ use libc::{c_char, mode_t};
 use crate::files::map_file_at;
 pub(crate) use crate::xwrap::*;
 use crate::{
-    clone_attr, cstr, cstr_buf, fclone_attr, fd_path, map_fd, map_file, slice_from_ptr,
+    CxxResultExt, Directory, FsPath, Utf8CStr, clone_attr, cstr, cstr_buf, fclone_attr, fd_path,
-    CxxResultExt, Directory, FsPath, Utf8CStr,
+    map_fd, map_file, slice_from_ptr,
 };
 
 pub(crate) fn fd_path_for_cxx(fd: RawFd, buf: &mut [u8]) -> isize {

native/src/base/dir.rs

@@ -1,9 +1,9 @@
 use crate::cxx_extern::readlinkat_for_cxx;
 use crate::{
-    cstr, cstr_buf, errno, fd_path, fd_set_attr, FileAttr, FsPath, LibcReturn, Utf8CStr,
+    FileAttr, FsPath, LibcReturn, Utf8CStr, Utf8CStrBuf, cstr, cstr_buf, errno, fd_path,
-    Utf8CStrBuf,
+    fd_set_attr,
 };
-use libc::{dirent, O_CLOEXEC, O_CREAT, O_RDONLY, O_TRUNC, O_WRONLY};
+use libc::{O_CLOEXEC, O_CREAT, O_RDONLY, O_TRUNC, O_WRONLY, dirent};
 use std::ffi::CStr;
 use std::fs::File;
 use std::ops::Deref;

native/src/base/logging.rs

@@ -1,13 +1,13 @@
 use std::fmt;
 use std::fmt::Arguments;
-use std::io::{stderr, stdout, Write};
+use std::io::{Write, stderr, stdout};
 use std::process::exit;
 
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::FromPrimitive;
 
 use crate::ffi::LogLevelCxx;
-use crate::{cstr_buf, Utf8CStr};
+use crate::{Utf8CStr, cstr_buf};
 
 // Ugly hack to avoid using enum
 #[allow(non_snake_case, non_upper_case_globals)]

native/src/base/misc.rs

@@ -1,12 +1,12 @@
-use crate::{ffi, StrErr, Utf8CStr};
+use crate::{StrErr, Utf8CStr, ffi};
 use argh::EarlyExit;
 use libc::c_char;
 use std::fmt::Arguments;
 use std::io::Write;
 use std::mem::ManuallyDrop;
 use std::process::exit;
-use std::sync::atomic::{AtomicPtr, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicPtr, Ordering};
 use std::{fmt, io, slice, str};
 
 pub fn errno() -> &'static mut i32 {

native/src/base/result.rs

@@ -3,7 +3,7 @@ use std::fmt::Display;
 use std::panic::Location;
 
 use crate::logging::Formatter;
-use crate::{log_with_args, log_with_formatter, LogLevel};
+use crate::{LogLevel, log_with_args, log_with_formatter};
 
 // Error handling throughout the Rust codebase in Magisk:
 //

native/src/boot/build.rs

@@ -1,4 +1,4 @@
-use pb_rs::{types::FileDescriptor, ConfigBuilder};
+use pb_rs::{ConfigBuilder, types::FileDescriptor};
 
 use crate::codegen::gen_cxx_binding;
 

native/src/boot/dtb.rs

@@ -2,12 +2,12 @@ use std::{cell::UnsafeCell, process::exit};
 
 use argh::FromArgs;
 use fdt::{
-    node::{FdtNode, NodeProperty},
     Fdt, FdtError,
+    node::{FdtNode, NodeProperty},
 };
 
 use base::{
-    libc::c_char, log_err, map_args, EarlyExitExt, LoggedResult, MappedFile, ResultExt, Utf8CStr,
+    EarlyExitExt, LoggedResult, MappedFile, ResultExt, Utf8CStr, libc::c_char, log_err, map_args,
 };
 
 use crate::{check_env, patch::patch_verity};

native/src/boot/lib.rs

@@ -3,14 +3,14 @@
 #![feature(iter_intersperse)]
 #![feature(try_blocks)]
 
-pub use libz_rs_sys::*;
-pub use libbz2_rs_sys::*;
 pub use base;
 use cpio::cpio_commands;
 use dtb::dtb_commands;
+pub use libbz2_rs_sys::*;
+pub use libz_rs_sys::*;
 use patch::hexpatch;
 use payload::extract_boot_from_payload;
-use sign::{get_sha, sha1_hash, sha256_hash, sign_boot_image, verify_boot_image, SHA};
+use sign::{SHA, get_sha, sha1_hash, sha256_hash, sign_boot_image, verify_boot_image};
 use std::env;
 
 mod cpio;

native/src/boot/payload.rs

@@ -9,10 +9,10 @@ use quick_protobuf::{BytesReader, MessageRead};
 
 use crate::{
     ffi,
-    proto::update_metadata::{mod_InstallOperation::Type, DeltaArchiveManifest},
+    proto::update_metadata::{DeltaArchiveManifest, mod_InstallOperation::Type},
 };
 use base::{
-    error, ffi::Utf8CStrRef, LoggedError, LoggedResult, ReadSeekExt, ResultExt, Utf8CStr, WriteExt,
+    LoggedError, LoggedResult, ReadSeekExt, ResultExt, Utf8CStr, WriteExt, error, ffi::Utf8CStrRef,
 };
 
 macro_rules! bad_payload {

native/src/boot/sign.rs

@@ -15,18 +15,18 @@ use rsa::pkcs1v15::{
     Signature as RsaSignature, SigningKey as RsaSigningKey, VerifyingKey as RsaVerifyingKey,
 };
 use rsa::pkcs8::SubjectPublicKeyInfoRef;
-use rsa::signature::hazmat::{PrehashSigner, PrehashVerifier};
 use rsa::signature::SignatureEncoding;
+use rsa::signature::hazmat::{PrehashSigner, PrehashVerifier};
 use rsa::{RsaPrivateKey, RsaPublicKey};
 use sha1::Sha1;
 use sha2::{Sha256, Sha384, Sha512};
-use x509_cert::der::asn1::{OctetString, PrintableString};
-use x509_cert::der::Any;
-use x509_cert::spki::AlgorithmIdentifier;
 use x509_cert::Certificate;
+use x509_cert::der::Any;
+use x509_cert::der::asn1::{OctetString, PrintableString};
+use x509_cert::spki::AlgorithmIdentifier;
 
 use base::libc::c_char;
-use base::{log_err, LoggedResult, MappedFile, ResultExt, StrErr, Utf8CStr};
+use base::{LoggedResult, MappedFile, ResultExt, StrErr, Utf8CStr, log_err};
 
 use crate::ffi::BootImage;
 

native/src/core/build.rs

@@ -1,4 +1,4 @@
-use pb_rs::{types::FileDescriptor, ConfigBuilder};
+use pb_rs::{ConfigBuilder, types::FileDescriptor};
 
 use crate::codegen::gen_cxx_binding;
 

native/src/core/daemon.rs

@@ -1,8 +1,8 @@
 use crate::consts::{MAGISK_FULL_VER, MAIN_CONFIG, SECURE_DIR};
 use crate::db::Sqlite3;
 use crate::ffi::{
-    check_key_combo, disable_modules, exec_common_scripts, exec_module_scripts, get_magisk_tmp,
+    DbEntryKey, ModuleInfo, RequestCode, check_key_combo, disable_modules, exec_common_scripts,
-    initialize_denylist, setup_magisk_env, DbEntryKey, ModuleInfo, RequestCode,
+    exec_module_scripts, get_magisk_tmp, initialize_denylist, setup_magisk_env,
 };
 use crate::get_prop;
 use crate::logging::{magisk_logging, setup_logfile, start_log_daemon};
@@ -11,7 +11,7 @@ use crate::package::ManagerInfo;
 use crate::su::SuInfo;
 use base::libc::{O_CLOEXEC, O_RDONLY};
 use base::{
-    cstr, error, info, libc, open_fd, path, AtomicArc, BufReadExt, FsPathBuf, ResultExt, Utf8CStr,
+    AtomicArc, BufReadExt, FsPathBuf, ResultExt, Utf8CStr, cstr, error, info, libc, open_fd, path,
 };
 use std::fs::File;
 use std::io::BufReader;

native/src/core/db.rs

@@ -1,9 +1,10 @@
 #![allow(improper_ctypes, improper_ctypes_definitions)]
-use crate::daemon::{MagiskD, MAGISKD};
+use crate::daemon::{MAGISKD, MagiskD};
 use crate::ffi::{
-    open_and_init_db, sqlite3, sqlite3_errstr, DbEntryKey, DbStatement, DbValues, MntNsMode,
+    DbEntryKey, DbStatement, DbValues, MntNsMode, open_and_init_db, sqlite3, sqlite3_errstr,
 };
 use crate::socket::{IpcRead, IpcWrite};
+use DbArg::{Integer, Text};
 use base::{LoggedResult, ResultExt, Utf8CStr};
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
@@ -15,7 +16,6 @@ use std::pin::Pin;
 use std::ptr;
 use std::ptr::NonNull;
 use thiserror::Error;
-use DbArg::{Integer, Text};
 
 fn sqlite_err_str(code: i32) -> &'static Utf8CStr {
     // SAFETY: sqlite3 always returns UTF-8 strings

native/src/core/derive/decodable.rs

@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
 use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
-use syn::{parse_macro_input, parse_quote, Data, DeriveInput, Fields, GenericParam};
+use syn::{Data, DeriveInput, Fields, GenericParam, parse_macro_input, parse_quote};
 
 pub(crate) fn derive_decodable(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = parse_macro_input!(input as DeriveInput);

native/src/core/lib.rs

@@ -8,9 +8,9 @@
 
 use crate::ffi::SuRequest;
 use crate::socket::Encodable;
-use base::{libc, Utf8CStr};
+use base::{Utf8CStr, libc};
-use cxx::{type_id, ExternType};
+use cxx::{ExternType, type_id};
-use daemon::{daemon_entry, MagiskD};
+use daemon::{MagiskD, daemon_entry};
 use derive::Decodable;
 use logging::{android_logging, setup_logfile, zygisk_close_logd, zygisk_get_logd, zygisk_logging};
 use mount::{find_preinit_device, revert_unmount};

native/src/core/logging.rs

@@ -1,15 +1,15 @@
-use crate::consts::{LOGFILE, LOG_PIPE};
+use crate::consts::{LOG_PIPE, LOGFILE};
 use crate::ffi::get_magisk_tmp;
 use crate::logging::LogFile::{Actual, Buffer};
 use base::libc::{
-    getpid, gettid, localtime_r, pthread_sigmask, sigaddset, sigset_t, sigtimedwait, time_t,
+    O_CLOEXEC, O_RDWR, O_WRONLY, PIPE_BUF, SIG_BLOCK, SIG_SETMASK, SIGPIPE, getpid, gettid,
-    timespec, tm, O_CLOEXEC, O_RDWR, O_WRONLY, PIPE_BUF, SIGPIPE, SIG_BLOCK, SIG_SETMASK,
+    localtime_r, pthread_sigmask, sigaddset, sigset_t, sigtimedwait, time_t, timespec, tm,
 };
 use base::{
-    const_format::concatcp, cstr_buf, libc, raw_cstr, FsPathBuf, LogLevel, Logger, ReadExt,
+    FsPathBuf, LOGGER, LogLevel, Logger, ReadExt, Utf8CStr, Utf8CStrBuf, WriteExt,
-    Utf8CStr, Utf8CStrBuf, WriteExt, LOGGER,
+    const_format::concatcp, cstr_buf, libc, raw_cstr,
 };
-use bytemuck::{bytes_of, write_zeroes, Pod, Zeroable};
+use bytemuck::{Pod, Zeroable, bytes_of, write_zeroes};
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::FromPrimitive;
 use std::cmp::min;

native/src/core/resetprop/persist.rs

@@ -9,15 +9,15 @@ use std::{
 
 use quick_protobuf::{BytesReader, MessageRead, MessageWrite, Writer};
 
-use crate::ffi::{prop_cb_exec, PropCb};
+use crate::ffi::{PropCb, prop_cb_exec};
 use crate::resetprop::proto::persistent_properties::{
-    mod_PersistentProperties::PersistentPropertyRecord, PersistentProperties,
+    PersistentProperties, mod_PersistentProperties::PersistentPropertyRecord,
 };
 use base::const_format::concatcp;
 use base::libc::{O_CLOEXEC, O_RDONLY};
 use base::{
-    clone_attr, cstr, debug, libc::mkstemp, path, Directory, FsPathBuf, LibcReturn, LoggedResult,
+    Directory, FsPathBuf, LibcReturn, LoggedResult, MappedFile, SilentResultExt, Utf8CStr,
-    MappedFile, SilentResultExt, Utf8CStr, WalkResult,
+    WalkResult, clone_attr, cstr, debug, libc::mkstemp, path,
 };
 
 const PERSIST_PROP_DIR: &str = "/data/property";

native/src/core/socket.rs

@@ -1,5 +1,5 @@
-use base::{libc, warn, ReadExt, ResultExt, WriteExt};
+use base::{ReadExt, ResultExt, WriteExt, libc, warn};
-use bytemuck::{bytes_of, bytes_of_mut, Zeroable};
+use bytemuck::{Zeroable, bytes_of, bytes_of_mut};
 use std::io;
 use std::io::{ErrorKind, IoSlice, IoSliceMut, Read, Write};
 use std::mem::ManuallyDrop;

native/src/core/su/daemon.rs

@@ -1,12 +1,12 @@
-use crate::daemon::{to_app_id, to_user_id, MagiskD, AID_ROOT, AID_SHELL};
+use crate::UCred;
+use crate::daemon::{AID_ROOT, AID_SHELL, MagiskD, to_app_id, to_user_id};
 use crate::db::{DbSettings, MultiuserMode, RootAccess};
 use crate::ffi::{
-    app_log, app_notify, app_request, exec_root_shell, SuAppRequest, SuPolicy, SuRequest,
+    SuAppRequest, SuPolicy, SuRequest, app_log, app_notify, app_request, exec_root_shell,
 };
 use crate::socket::IpcRead;
 use crate::su::db::RootSettings;
-use crate::UCred;
+use base::{LoggedResult, ResultExt, WriteExt, debug, error, exit_on_error, libc, warn};
-use base::{debug, error, exit_on_error, libc, warn, LoggedResult, ResultExt, WriteExt};
 use std::fs::File;
 use std::os::fd::{FromRawFd, IntoRawFd};
 use std::os::unix::net::UnixStream;

native/src/core/su/db.rs

@@ -1,5 +1,5 @@
 use crate::daemon::{
-    to_app_id, to_user_id, MagiskD, AID_APP_END, AID_APP_START, AID_ROOT, AID_SHELL,
+    AID_APP_END, AID_APP_START, AID_ROOT, AID_SHELL, MagiskD, to_app_id, to_user_id,
 };
 use crate::db::DbArg::Integer;
 use crate::db::{MultiuserMode, RootAccess, SqlTable, SqliteResult, SqliteReturn};

native/src/core/zygisk/daemon.rs

@@ -1,13 +1,13 @@
 use crate::consts::MODULEROOT;
-use crate::daemon::{to_user_id, MagiskD};
+use crate::daemon::{MagiskD, to_user_id};
 use crate::ffi::{
-    get_magisk_tmp, restore_zygisk_prop, update_deny_flags, ZygiskRequest, ZygiskStateFlags,
+    ZygiskRequest, ZygiskStateFlags, get_magisk_tmp, restore_zygisk_prop, update_deny_flags,
 };
 use crate::socket::{IpcRead, UnixSocketExt};
 use base::libc::{O_CLOEXEC, O_CREAT, O_RDONLY, STDOUT_FILENO};
 use base::{
-    cstr, cstr_buf, error, fork_dont_care, libc, open_fd, raw_cstr, warn, Directory, FsPathBuf,
+    Directory, FsPathBuf, LoggedError, LoggedResult, ResultExt, WriteExt, cstr, cstr_buf, error,
-    LoggedError, LoggedResult, ResultExt, WriteExt,
+    fork_dont_care, libc, open_fd, raw_cstr, warn,
 };
 use std::fmt::Write;
 use std::os::fd::{AsRawFd, FromRawFd, RawFd};

native/src/init/getinfo.rs

@@ -1,10 +1,10 @@
-use crate::ffi::{backup_init, BootConfig, MagiskInit};
+use crate::ffi::{BootConfig, MagiskInit, backup_init};
-use base::{path, BytesExt, MappedFile};
+use base::{BytesExt, MappedFile, path};
 
 impl BootConfig {
     #[allow(unused_imports, unused_unsafe)]
     pub(crate) fn print(&self) {
-        use base::{debug, Utf8CStr};
+        use base::{Utf8CStr, debug};
         debug!("skip_initramfs=[{}]", self.skip_initramfs);
         debug!("force_normal_boot=[{}]", self.force_normal_boot);
         debug!("rootwait=[{}]", self.rootwait);

native/src/init/logging.rs

@@ -1,10 +1,10 @@
 use base::{
-    cstr,
+    LOGGER, LogLevel, Logger, Utf8CStr, cstr,
     libc::{
-        makedev, mknod, syscall, SYS_dup3, O_CLOEXEC, O_RDWR, O_WRONLY, STDERR_FILENO,
+        O_CLOEXEC, O_RDWR, O_WRONLY, S_IFCHR, STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO, SYS_dup3,
-        STDIN_FILENO, STDOUT_FILENO, S_IFCHR,
+        makedev, mknod, syscall,
     },
-    open_fd, path, raw_cstr, LogLevel, Logger, Utf8CStr, LOGGER,
+    open_fd, path, raw_cstr,
 };
 use std::{
     fs::File,

native/src/sepolicy/lib.rs

@@ -2,10 +2,7 @@
 #![feature(try_blocks)]
 
 pub use base;
-use base::libc::{O_CLOEXEC, O_RDONLY};
-use base::{BufReadExt, FsPath, LoggedResult, Utf8CStr};
 use std::fmt::Write;
-use std::io::{BufRead, BufReader, Cursor};
 
 use crate::ffi::SePolicy;
 

native/src/sepolicy/rules.rs

@@ -1,5 +1,5 @@
-use crate::{ffi::Xperm, SePolicy};
+use crate::{SePolicy, ffi::Xperm};
-use base::{set_log_level_state, LogLevel};
+use base::{LogLevel, set_log_level_state};
 
 macro_rules! rules {
     (@args all) => {