clippy and fmt issues

Author: xunilrj

sway-core/src/semantic_analysis/type_resolve.rs

@@ -5,9 +5,15 @@ use sway_error::{
 use sway_types::{Ident, Span, Spanned};
 
 use crate::{
-    ast_elements::type_parameter::ConstGenericExpr, language::{
-        ty::{self, TyTraitItem}, CallPath, CallPathType, QualifiedCallPath
-    }, monomorphization::type_decl_opt_to_type_id, namespace::{Module, ModulePath, ResolvedDeclaration, ResolvedTraitImplItem}, type_system::SubstTypes, EnforceTypeArguments, Engines, Namespace, SubstTypesContext, TypeId, TypeInfo
+    ast_elements::type_parameter::ConstGenericExpr,
+    language::{
+        ty::{self, TyTraitItem},
+        CallPath, CallPathType, QualifiedCallPath,
+    },
+    monomorphization::type_decl_opt_to_type_id,
+    namespace::{Module, ModulePath, ResolvedDeclaration, ResolvedTraitImplItem},
+    type_system::SubstTypes,
+    EnforceTypeArguments, Engines, Namespace, SubstTypesContext, TypeId, TypeInfo,
 };
 
 use super::namespace::TraitMap;
@@ -27,20 +33,21 @@ fn resolve_const_generics_ambiguous(
     mod_path: &ModulePath,
     self_type: Option<TypeId>,
 ) -> Result<(), ErrorEmitted> {
-    match expr {
-        ConstGenericExpr::AmbiguousVariableExpression { ident } => {
-            let _ = resolve_call_path(
-                handler,
-                engines,
-                namespace,
-                mod_path,
-                &CallPath { prefixes: vec![], suffix: ident.clone(), callpath_type: CallPathType::Ambiguous },
-                self_type,
-                VisibilityCheck::No,
-            )
-            .map(|d| d.expect_typed())?;
-        },
-        _ => {}
+    if let ConstGenericExpr::AmbiguousVariableExpression { ident } = expr {
+        let _ = resolve_call_path(
+            handler,
+            engines,
+            namespace,
+            mod_path,
+            &CallPath {
+                prefixes: vec![],
+                suffix: ident.clone(),
+                callpath_type: CallPathType::Ambiguous,
+            },
+            self_type,
+            VisibilityCheck::No,
+        )
+        .map(|d| d.expect_typed())?;
     }
     Ok(())
 }
@@ -115,7 +122,14 @@ pub fn resolve_type(
                 check_visibility,
             )
             .unwrap_or_else(|err| engines.te().id_of_error_recovery(err));
-            resolve_const_generics_ambiguous(length.expr(), handler, engines, namespace, mod_path, self_type)?;
+            resolve_const_generics_ambiguous(
+                length.expr(),
+                handler,
+                engines,
+                namespace,
+                mod_path,
+                self_type,
+            )?;
 
             engines.te().insert_array(engines, elem_ty, length.clone())
         }
@@ -209,7 +223,14 @@ pub fn resolve_type(
             engines.te().insert_ref(engines, *to_mutable_value, ty)
         }
         TypeInfo::StringArray(length) => {
-            resolve_const_generics_ambiguous(length.expr(), handler, engines, namespace, mod_path, self_type)?;
+            resolve_const_generics_ambiguous(
+                length.expr(),
+                handler,
+                engines,
+                namespace,
+                mod_path,
+                self_type,
+            )?;
             type_id
         }
         _ => type_id,

sway-core/src/type_system/monomorphization.rs

@@ -1,17 +1,21 @@
+use crate::{
+    decl_engine::{engine::DeclEngineGetParsedDeclId, DeclEngineInsert, MaterializeConstGenerics},
+    language::{
+        ty::{self, TyExpression},
+        CallPath,
+    },
+    namespace::{ModulePath, ResolvedDeclaration},
+    semantic_analysis::type_resolve::{resolve_type, VisibilityCheck},
+    type_system::ast_elements::create_type_id::CreateTypeId,
+    EnforceTypeArguments, Engines, GenericArgument, Namespace, SubstTypes, SubstTypesContext,
+    TypeId, TypeParameter, TypeSubstMap,
+};
 use std::collections::BTreeMap;
-
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
 };
-use sway_types::{Ident, Named, Span, Spanned};
-
-use crate::{
-    decl_engine::{engine::DeclEngineGetParsedDeclId, DeclEngineInsert, MaterializeConstGenerics}, engine_threading::DebugWithEngines, language::{
-        ty::{self, TyExpression},
-        CallPath,
-    }, namespace::{ModulePath, ResolvedDeclaration}, semantic_analysis::type_resolve::{resolve_type, VisibilityCheck}, type_system::ast_elements::create_type_id::CreateTypeId, EnforceTypeArguments, Engines, GenericArgument, Namespace, SubstTypes, SubstTypesContext, TypeId, TypeParameter, TypeSubstMap
-};
+use sway_types::{Ident, Span, Spanned};
 
 pub(crate) trait MonomorphizeHelper {
     fn name(&self) -> &Ident;
@@ -115,7 +119,7 @@ where
 
             let params = value.type_parameters();
             let args = type_arguments.iter_mut();
-                
+
             for (param, arg) in params.iter().zip(args) {
                 // eprintln!("    {} {}", param.name(), arg.span().as_str());
 
@@ -135,28 +139,37 @@ where
                             VisibilityCheck::Yes,
                         )
                         .unwrap_or_else(|err| engines.te().id_of_error_recovery(err));
-                    },
+                    }
                     (TypeParameter::Const(_), GenericArgument::Type(arg)) => {
-                        let suffix = arg.call_path_tree.as_ref().unwrap().qualified_call_path.call_path.suffix.clone();
+                        let suffix = arg
+                            .call_path_tree
+                            .as_ref()
+                            .unwrap()
+                            .qualified_call_path
+                            .call_path
+                            .suffix
+                            .clone();
                         let _ = crate::semantic_analysis::type_resolve::resolve_call_path(
                             handler,
                             engines,
                             namespace,
                             mod_path,
-                            &CallPath { prefixes: vec![], suffix, callpath_type: crate::language::CallPathType::Ambiguous },
+                            &CallPath {
+                                prefixes: vec![],
+                                suffix,
+                                callpath_type: crate::language::CallPathType::Ambiguous,
+                            },
                             self_type,
                             VisibilityCheck::No,
                         )
                         .map(|d| d.expect_typed())?;
-                    },
+                    }
                     (TypeParameter::Type(_), GenericArgument::Const(_)) => todo!(),
                     (TypeParameter::Const(_), GenericArgument::Const(_)) => todo!(),
                     // GenericArgument::Const(arg) => {
-                        
+
                     // },
                 }
-
-                
             }
 
             let mut params = vec![];

sway-core/src/type_system/unify/unifier.rs

@@ -485,9 +485,7 @@ impl<'a> Unifier<'a> {
                                     span,
                                 );
                             }
-                            (None, None) => {
-                                
-                            },
+                            (None, None) => {},
                         }
                     }
                     _ => {