Collect Expression from asm register decls (FuelLabs#4128)

## Description
Collects `Expression` variants in `AsmRegisterDeclaration` and
`TyAsmRegisterDeclaration` if there are any.

Closes FuelLabs#3715

sway-core/src/language/parsed/expression/asm.rs

@@ -7,15 +7,15 @@ use sway_types::{ident::Ident, span::Span};
 
 #[derive(Debug, Clone)]
 pub struct AsmExpression {
-    pub(crate) registers: Vec<AsmRegisterDeclaration>,
+    pub registers: Vec<AsmRegisterDeclaration>,
     pub(crate) body: Vec<AsmOp>,
     pub(crate) returns: Option<(AsmRegister, Span)>,
     pub(crate) return_type: TypeInfo,
     pub(crate) whole_block_span: Span,
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct AsmRegisterDeclaration {
+pub struct AsmRegisterDeclaration {
     pub(crate) name: Ident,
-    pub(crate) initializer: Option<Expression>,
+    pub initializer: Option<Expression>,
 }

sway-core/src/language/ty/expression/asm.rs

@@ -6,7 +6,7 @@ use crate::{engine_threading::*, language::ty::*, type_system::*};
 
 #[derive(Clone, Debug)]
 pub struct TyAsmRegisterDeclaration {
-    pub(crate) initializer: Option<TyExpression>,
+    pub initializer: Option<TyExpression>,
     pub(crate) name: Ident,
 }
 

sway-lsp/src/traverse/parsed_tree.rs

@@ -588,8 +588,12 @@ impl<'a> ParsedTree<'a> {
                     self.handle_expression(&branch.result);
                 }
             }
-            ExpressionKind::Asm(_) => {
-                //TODO handle asm expressions
+            ExpressionKind::Asm(asm) => {
+                for register in &asm.registers {
+                    if let Some(initializer) = &register.initializer {
+                        self.handle_expression(initializer);
+                    }
+                }
             }
             ExpressionKind::MethodApplication(method_application_expression) => {
                 let MethodApplicationExpression {

sway-lsp/src/traverse/typed_tree.rs

@@ -642,7 +642,13 @@ impl<'a> TypedTree<'a> {
                     self.handle_expression(r#else, namespace);
                 }
             }
-            ty::TyExpressionVariant::AsmExpression { .. } => {}
+            ty::TyExpressionVariant::AsmExpression { registers, .. } => {
+                for register in registers {
+                    if let Some(initializer) = &register.initializer {
+                        self.handle_expression(initializer, namespace);
+                    }
+                }
+            }
             ty::TyExpressionVariant::StructFieldAccess {
                 prefix,
                 field_to_access,