clippy and fmt issues

Author: xunilrj

sway-core/src/language/parsed/declaration.rs

@@ -123,7 +123,7 @@ impl Declaration {
             TypeAliasDeclaration(decl_id) => pe.get_type_alias(decl_id).span(),
             TraitTypeDeclaration(decl_id) => pe.get_trait_type(decl_id).span(),
             TraitFnDeclaration(decl_id) => pe.get_trait_fn(decl_id).span(),
-            ConstGenericDeclaration(decl_id) => {
+            ConstGenericDeclaration(_) => {
                 todo!("Will be implemented by https://github.com/FuelLabs/sway/issues/6860")
             }
         }

sway-core/src/language/ty/declaration/declaration.rs

@@ -570,7 +570,7 @@ impl TyDecl {
             TyDecl::VariableDecl(_decl) => None,
             TyDecl::ConstantDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
             TyDecl::ConfigurableDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),
-            TyDecl::ConstGenericDecl(decl) => {
+            TyDecl::ConstGenericDecl(_) => {
                 todo!("Will be implemented by https://github.com/FuelLabs/sway/issues/6860")
             }
             TyDecl::TraitTypeDecl(decl) => decl_engine.get_parsed_decl(&decl.decl_id),

sway-core/src/type_system/ast_elements/type_parameter.rs

@@ -1125,14 +1125,7 @@ impl ConstGenericExpr {
 
 impl PartialOrd for ConstGenericExpr {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        match (self, other) {
-            (Self::Literal { val: l, .. }, Self::Literal { val: r, .. }) => l.partial_cmp(r),
-            (
-                Self::AmbiguousVariableExpression { ident: l, .. },
-                Self::AmbiguousVariableExpression { ident: r, .. },
-            ) => l.partial_cmp(r),
-            _ => None,
-        }
+        Some(self.cmp(other))
     }
 }
 
@@ -1283,7 +1276,7 @@ impl Eq for ConstGenericParameter {}
 
 impl PartialOrd for ConstGenericParameter {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.name.as_str().partial_cmp(other.name.as_str())
+        Some(self.cmp(other))
     }
 }
 

sway-lsp/src/capabilities/document_symbol.rs

@@ -375,7 +375,9 @@ fn collect_enum_variants(decl: &TyEnumDecl) -> Vec<DocumentSymbol> {
             // Check for the presence of a CallPathTree, and if it exists, use the type information as the detail.
             let detail = variant
                 .type_argument
-                .call_path_tree()
+                .as_type_argument()
+                .unwrap()
+                .call_path_tree
                 .as_ref()
                 .map(|_| Some(variant.type_argument.span().as_str().to_string()))
                 .unwrap_or(None);
@@ -428,7 +430,10 @@ fn fn_decl_detail(parameters: &[TyFunctionParameter], return_type: &GenericArgum
 
     // Check for the presence of a CallPathTree, and if it exists, add it to the return type.
     let return_type = return_type
-        .call_path_tree()
+        .as_type_argument()
+        .unwrap()
+        .call_path_tree
+        .as_ref()
         .map(|_| format!(" -> {}", return_type.span().as_str()))
         .unwrap_or_default();
     format!("fn({params}){return_type}")

sway-lsp/src/capabilities/inlay_hints.rs

@@ -74,7 +74,13 @@ pub fn inlay_hints(
             }
 
             // Variable declaration hints
-            if var.type_ascription.call_path_tree().is_none() {
+            if var
+                .type_ascription
+                .as_type_argument()
+                .unwrap()
+                .call_path_tree
+                .is_none()
+            {
                 let type_info = engines.te().get(var.type_ascription.type_id());
                 if !matches!(
                     *type_info,

sway-lsp/src/traverse/parsed_tree.rs

@@ -1122,7 +1122,7 @@ impl Parse for GenericArgument {
             }
             _ => {
                 let symbol_kind = type_info_to_symbol_kind(ctx.engines.te(), &type_info, None);
-                if let Some(tree) = &self.call_path_tree() {
+                if let Some(tree) = &self.as_type_argument().unwrap().call_path_tree.as_ref() {
                     let token =
                         Token::from_parsed(ParsedAstToken::TypeArgument(self.clone()), symbol_kind);
                     collect_call_path_tree(ctx, tree, &token, ctx.tokens);

sway-lsp/src/traverse/typed_tree.rs

@@ -655,7 +655,13 @@ impl Parse for ty::TyVariableDecl {
             ));
             token.type_def = Some(TypeDefinition::Ident(self.name.clone()));
         }
-        if let Some(call_path_tree) = &self.type_ascription.call_path_tree() {
+        if let Some(call_path_tree) = &self
+            .type_ascription
+            .as_type_argument()
+            .unwrap()
+            .call_path_tree
+            .as_ref()
+        {
             collect_call_path_tree(ctx, call_path_tree, &self.type_ascription);
         }
         self.body.parse(ctx);
@@ -879,7 +885,10 @@ impl Parse for ty::ImplSelfOrTrait {
                 implementing_for.type_id(),
                 &typed_token,
                 implementing_for
-                    .call_path_tree()
+                    .as_type_argument()
+                    .unwrap()
+                    .call_path_tree
+                    .as_ref()
                     .map(|tree| tree.qualified_call_path.call_path.suffix.span())
                     .unwrap_or(implementing_for.span()),
             );
@@ -1367,7 +1376,13 @@ fn collect_const_decl(ctx: &ParseContext, const_decl: &ty::TyConstantDecl, ident
             TokenAstNode::Typed(TypedAstToken::TypedConstantDeclaration(const_decl.clone()));
         token.type_def = Some(TypeDefinition::Ident(const_decl.call_path.suffix.clone()));
     }
-    if let Some(call_path_tree) = &const_decl.type_ascription.call_path_tree() {
+    if let Some(call_path_tree) = &const_decl
+        .type_ascription
+        .as_type_argument()
+        .unwrap()
+        .call_path_tree
+        .as_ref()
+    {
         collect_call_path_tree(ctx, call_path_tree, &const_decl.type_ascription);
     }
     if let Some(value) = &const_decl.value {
@@ -1387,7 +1402,13 @@ fn collect_configurable_decl(
             TokenAstNode::Typed(TypedAstToken::TypedConfigurableDeclaration(decl.clone()));
         token.type_def = Some(TypeDefinition::Ident(decl.call_path.suffix.clone()));
     }
-    if let Some(call_path_tree) = &decl.type_ascription.call_path_tree() {
+    if let Some(call_path_tree) = &decl
+        .type_ascription
+        .as_type_argument()
+        .unwrap()
+        .call_path_tree
+        .as_ref()
+    {
         collect_call_path_tree(ctx, call_path_tree, &decl.type_ascription);
     }
     if let Some(value) = &decl.value {
@@ -1516,7 +1537,7 @@ fn collect_type_id(
 }
 
 fn collect_type_argument(ctx: &ParseContext, type_arg: &GenericArgument) {
-    if let Some(call_path_tree) = type_arg.call_path_tree() {
+    if let Some(call_path_tree) = type_arg.as_type_argument().unwrap().call_path_tree.as_ref() {
         collect_call_path_tree(ctx, call_path_tree, type_arg);
     } else {
         collect_type_id(