[move-model] Track struct usage during build instead of lazy computation

Replace the expensive lazy computation in StructEnv::get_using_functions() which iterates over all modules and all functions with eager tracking during function body translation.

- Add using_functions field to StructEntry to accumulate usage during build

- In def_ana_fun, after translating function body, collect used structs via struct_usage() and update corresponding StructEntry

- Pass the collected using_functions from StructEntry to StructData during finalization

This eliminates the O(modules * functions) scan on every get_using_functions() call, making unused struct detection much more efficient.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: junxzm1990

third_party/move/move-model/src/builder/model_builder.rs

@@ -130,6 +130,8 @@ pub(crate) struct StructEntry {
     pub is_empty_struct: bool,
     pub is_native: bool,
     pub visibility: Visibility,
+    /// Functions that use this struct
+    pub using_functions: BTreeSet<QualifiedId<FunId>>,
 }
 
 #[derive(Debug, Clone)]
@@ -392,6 +394,7 @@ impl<'env> ModelBuilder<'env> {
             is_empty_struct: false,
             is_native,
             visibility,
+            using_functions: BTreeSet::new(),
         };
         self.struct_table.insert(name.clone(), entry);
         self.reverse_struct_table

third_party/move/move-model/src/builder/module_builder.rs

@@ -22,8 +22,9 @@ use crate::{
     metadata::lang_feature_versions::LANGUAGE_VERSION_FOR_PUBLIC_STRUCT,
     model::{
         self, EqIgnoringLoc, FieldData, FieldId, FunId, FunctionData, FunctionKind, FunctionLoc,
-        Loc, ModuleId, MoveIrLoc, NamedConstantData, NamedConstantId, NodeId, Parameter, SchemaId,
-        SpecFunId, SpecVarId, StructData, StructId, TypeParameter, TypeParameterKind,
+        Loc, ModuleId, MoveIrLoc, NamedConstantData, NamedConstantId, NodeId, Parameter,
+        QualifiedId, SchemaId, SpecFunId, SpecVarId, StructData, StructId, TypeParameter,
+        TypeParameterKind,
     },
     options::ModelBuilderOptions,
     pragmas::{
@@ -1490,6 +1491,24 @@ impl ModuleBuilder<'_, '_> {
             et.finalize_types(true);
             et.check_mutable_borrow_field(&translated);
             et.check_lambda_types(&translated);
+
+            // Track struct usage for unused struct detection
+            let mut used_structs = BTreeSet::new();
+            translated.struct_usage(self.parent.env, &mut used_structs);
+            let fun_qid = QualifiedId {
+                module_id: self.module_id,
+                id: FunId::new(full_name.symbol),
+            };
+            for struct_id in used_structs {
+                if let Some(struct_entry) = self
+                    .parent
+                    .struct_table
+                    .get_mut(&self.parent.reverse_struct_table.get(&(struct_id.module_id, struct_id.id)).expect("struct exists"))
+                {
+                    struct_entry.using_functions.insert(fun_qid);
+                }
+            }
+
             assert!(self.fun_defs.insert(full_name.symbol, translated).is_none());
             if let Some(specifiers) = access_specifiers {
                 assert!(self
@@ -3624,7 +3643,7 @@ impl ModuleBuilder<'_, '_> {
                 visibility: entry.visibility,
                 has_package_visibility: self.package_structs.contains(&entry.struct_id),
                 is_empty_struct: entry.is_empty_struct,
-                using_funs: RefCell::new(None),
+                using_funs: RefCell::new(Some(entry.using_functions.clone())),
             };
             struct_data.insert(StructId::new(name.symbol), data);
             if entry.visibility != Visibility::Private