Format all rust imports consistently (#12381)

Author: alex

src/rust/cryptography-keepalive/src/lib.rs

@@ -4,10 +4,11 @@
 
 #![deny(rust_2018_idioms, clippy::undocumented_unsafe_blocks)]
 
-use pyo3::pybacked::{PyBackedBytes, PyBackedStr};
 use std::cell::UnsafeCell;
 use std::ops::Deref;
 
+use pyo3::pybacked::{PyBackedBytes, PyBackedStr};
+
 pub struct KeepAlive<T: StableDeref> {
     values: UnsafeCell<Vec<T>>,
 }

src/rust/cryptography-key-parsing/src/ec.rs

@@ -2,10 +2,10 @@
 // 2.0, and the BSD License. See the LICENSE file in the root of this repository
 // for complete details.
 
-use crate::{KeyParsingError, KeyParsingResult};
-
 use cryptography_x509::common::EcParameters;
 
+use crate::{KeyParsingError, KeyParsingResult};
+
 pub(crate) fn ec_params_to_group(
     params: &EcParameters<'_>,
 ) -> KeyParsingResult<openssl::ec::EcGroup> {

src/rust/cryptography-openssl/src/aead.rs

@@ -2,10 +2,10 @@
 // 2.0, and the BSD License. See the LICENSE file in the root of this repository
 // for complete details.
 
+use foreign_types_shared::{ForeignType, ForeignTypeRef};
 use openssl_sys as ffi;
 
 use crate::{cvt, cvt_p, OpenSSLResult};
-use foreign_types_shared::{ForeignType, ForeignTypeRef};
 
 pub enum AeadType {
     ChaCha20Poly1305,

src/rust/cryptography-openssl/src/fips.rs

@@ -2,17 +2,18 @@
 // 2.0, and the BSD License. See the LICENSE file in the root of this repository
 // for complete details.
 
-#[cfg(not(any(CRYPTOGRAPHY_IS_LIBRESSL, CRYPTOGRAPHY_IS_BORINGSSL)))]
-use openssl_sys as ffi;
-
-#[cfg(CRYPTOGRAPHY_OPENSSL_300_OR_GREATER)]
-use crate::{cvt, OpenSSLResult};
 #[cfg(all(
     CRYPTOGRAPHY_OPENSSL_300_OR_GREATER,
     not(any(CRYPTOGRAPHY_IS_LIBRESSL, CRYPTOGRAPHY_IS_BORINGSSL))
 ))]
 use std::ptr;
 
+#[cfg(not(any(CRYPTOGRAPHY_IS_LIBRESSL, CRYPTOGRAPHY_IS_BORINGSSL)))]
+use openssl_sys as ffi;
+
+#[cfg(CRYPTOGRAPHY_OPENSSL_300_OR_GREATER)]
+use crate::{cvt, OpenSSLResult};
+
 pub fn is_enabled() -> bool {
     cfg_if::cfg_if! {
         if #[cfg(any(CRYPTOGRAPHY_IS_LIBRESSL, CRYPTOGRAPHY_IS_BORINGSSL))] {

src/rust/cryptography-openssl/src/hmac.rs

@@ -92,9 +92,10 @@ impl std::ops::Deref for DigestBytes {
 
 #[cfg(test)]
 mod tests {
-    use super::DigestBytes;
     use openssl_sys as ffi;
 
+    use super::DigestBytes;
+
     #[test]
     fn test_digest_bytes() {
         let d = DigestBytes {

src/rust/cryptography-x509-verification/src/lib.rs

@@ -16,20 +16,20 @@ use std::fmt::Display;
 use std::vec;
 
 use asn1::ObjectIdentifier;
-use cryptography_x509::extensions::{DuplicateExtensionsError, Extensions};
-use cryptography_x509::{
-    common::Asn1Read,
-    extensions::{NameConstraints, SubjectAlternativeName},
-    name::GeneralName,
-    oid::{NAME_CONSTRAINTS_OID, SUBJECT_ALTERNATIVE_NAME_OID},
+use cryptography_x509::common::Asn1Read;
+use cryptography_x509::extensions::{
+    DuplicateExtensionsError, Extensions, NameConstraints, SubjectAlternativeName,
 };
-use types::{DNSPattern, RFC822Constraint, RFC822Name};
+use cryptography_x509::name::GeneralName;
+use cryptography_x509::oid::{NAME_CONSTRAINTS_OID, SUBJECT_ALTERNATIVE_NAME_OID};
 
 use crate::certificate::cert_is_self_issued;
 use crate::ops::{CryptoOps, VerificationCertificate};
 use crate::policy::Policy;
 use crate::trust_store::Store;
-use crate::types::{DNSConstraint, IPAddress, IPConstraint};
+use crate::types::{
+    DNSConstraint, DNSPattern, IPAddress, IPConstraint, RFC822Constraint, RFC822Name,
+};
 use crate::ApplyNameConstraintStatus::{Applied, Skipped};
 
 pub enum ValidationErrorKind<'chain, B: CryptoOps> {

src/rust/cryptography-x509-verification/src/ops.rs

@@ -90,9 +90,10 @@ pub trait CryptoOps {
 
 #[cfg(test)]
 pub(crate) mod tests {
+    use cryptography_x509::certificate::Certificate;
+
     use super::VerificationCertificate;
     use crate::certificate::tests::PublicKeyErrorOps;
-    use cryptography_x509::certificate::Certificate;
 
     pub(crate) fn v1_cert_pem() -> pem::Pem {
         pem::parse(

src/rust/cryptography-x509-verification/src/policy/extension.rs

@@ -2,19 +2,17 @@
 // 2.0, and the BSD License. See the LICENSE file in the root of this repository
 // for complete details.
 
+use cryptography_x509::certificate::Certificate;
+use cryptography_x509::extensions::{Extension, Extensions};
 use cryptography_x509::oid::{
     AUTHORITY_INFORMATION_ACCESS_OID, AUTHORITY_KEY_IDENTIFIER_OID, BASIC_CONSTRAINTS_OID,
     EXTENDED_KEY_USAGE_OID, KEY_USAGE_OID, NAME_CONSTRAINTS_OID, SUBJECT_ALTERNATIVE_NAME_OID,
     SUBJECT_KEY_IDENTIFIER_OID,
 };
-use cryptography_x509::{
-    certificate::Certificate,
-    extensions::{Extension, Extensions},
-};
 
-use crate::{
-    ops::CryptoOps, policy::Policy, ValidationError, ValidationErrorKind, ValidationResult,
-};
+use crate::ops::CryptoOps;
+use crate::policy::Policy;
+use crate::{ValidationError, ValidationErrorKind, ValidationResult};
 
 pub(crate) struct ExtensionPolicy<B: CryptoOps> {
     pub(crate) authority_information_access: ExtensionValidator<B>,
@@ -266,17 +264,13 @@ impl<B: CryptoOps> ExtensionValidator<B> {
 }
 
 pub(crate) mod ee {
-    use cryptography_x509::{
-        certificate::Certificate,
-        extensions::{
-            BasicConstraints, ExtendedKeyUsage, Extension, KeyUsage, SubjectAlternativeName,
-        },
+    use cryptography_x509::certificate::Certificate;
+    use cryptography_x509::extensions::{
+        BasicConstraints, ExtendedKeyUsage, Extension, KeyUsage, SubjectAlternativeName,
     };
 
-    use crate::{
-        ops::CryptoOps,
-        policy::{Policy, ValidationError, ValidationErrorKind, ValidationResult},
-    };
+    use crate::ops::CryptoOps;
+    use crate::policy::{Policy, ValidationError, ValidationErrorKind, ValidationResult};
 
     pub(crate) fn basic_constraints<'chain, B: CryptoOps>(
         _policy: &Policy<'_, B>,
@@ -379,20 +373,16 @@ pub(crate) mod ee {
 }
 
 pub(crate) mod ca {
-    use cryptography_x509::{
-        certificate::Certificate,
-        common::Asn1Read,
-        extensions::{
-            AuthorityKeyIdentifier, BasicConstraints, ExtendedKeyUsage, Extension, KeyUsage,
-            NameConstraints,
-        },
-        oid::EKU_ANY_KEY_USAGE_OID,
+    use cryptography_x509::certificate::Certificate;
+    use cryptography_x509::common::Asn1Read;
+    use cryptography_x509::extensions::{
+        AuthorityKeyIdentifier, BasicConstraints, ExtendedKeyUsage, Extension, KeyUsage,
+        NameConstraints,
     };
+    use cryptography_x509::oid::EKU_ANY_KEY_USAGE_OID;
 
-    use crate::{
-        ops::CryptoOps,
-        policy::{Policy, ValidationError, ValidationErrorKind, ValidationResult},
-    };
+    use crate::ops::CryptoOps;
+    use crate::policy::{Policy, ValidationError, ValidationErrorKind, ValidationResult};
 
     pub(crate) fn authority_key_identifier<'chain, B: CryptoOps>(
         _policy: &Policy<'_, B>,
@@ -529,16 +519,12 @@ pub(crate) mod ca {
 }
 
 pub(crate) mod common {
-    use cryptography_x509::{
-        certificate::Certificate,
-        common::Asn1Read,
-        extensions::{Extension, SequenceOfAccessDescriptions},
-    };
+    use cryptography_x509::certificate::Certificate;
+    use cryptography_x509::common::Asn1Read;
+    use cryptography_x509::extensions::{Extension, SequenceOfAccessDescriptions};
 
-    use crate::{
-        ops::CryptoOps,
-        policy::{Policy, ValidationResult},
-    };
+    use crate::ops::CryptoOps;
+    use crate::policy::{Policy, ValidationResult};
 
     pub(crate) fn authority_information_access<'chain, B: CryptoOps>(
         _policy: &Policy<'_, B>,

src/rust/cryptography-x509-verification/src/policy/mod.rs

@@ -601,24 +601,20 @@ mod tests {
 
     use asn1::{DateTime, SequenceOfWriter};
     use cryptography_x509::common::Time;
-    use cryptography_x509::{
-        extensions::SubjectAlternativeName,
-        name::{GeneralName, UnvalidatedIA5String},
-    };
+    use cryptography_x509::extensions::SubjectAlternativeName;
+    use cryptography_x509::name::{GeneralName, UnvalidatedIA5String};
 
     use super::{
         permits_validity_date, ECDSA_SHA256, ECDSA_SHA384, ECDSA_SHA512, RSASSA_PKCS1V15_SHA256,
         RSASSA_PKCS1V15_SHA384, RSASSA_PKCS1V15_SHA512, RSASSA_PSS_SHA256, RSASSA_PSS_SHA384,
         RSASSA_PSS_SHA512, WEBPKI_PERMITTED_SIGNATURE_ALGORITHMS,
     };
     use crate::certificate::tests::PublicKeyErrorOps;
-    use crate::{
-        policy::{
-            Subject, SPKI_RSA, SPKI_SECP256R1, SPKI_SECP384R1, SPKI_SECP521R1,
-            WEBPKI_PERMITTED_SPKI_ALGORITHMS,
-        },
-        types::{DNSName, IPAddress},
+    use crate::policy::{
+        Subject, SPKI_RSA, SPKI_SECP256R1, SPKI_SECP384R1, SPKI_SECP521R1,
+        WEBPKI_PERMITTED_SPKI_ALGORITHMS,
     };
+    use crate::types::{DNSName, IPAddress};
 
     #[test]
     fn test_webpki_permitted_spki_algorithms_canonical_encodings() {

src/rust/cryptography-x509-verification/src/trust_store.rs

@@ -6,8 +6,7 @@ use std::collections::HashMap;
 
 use cryptography_x509::name::Name;
 
-use crate::CryptoOps;
-use crate::VerificationCertificate;
+use crate::{CryptoOps, VerificationCertificate};
 
 /// A `Store` represents the core state needed for X.509 path validation.
 pub struct Store<'a, B: CryptoOps> {