[move-ide] Symbolication refactoring (#22102)

## Description 

This is a long overdue refactoring of the symbolicator. No code was
changed, only moved around.

## Test plan 

All tests must pass

Author: awelc

external-crates/move/crates/move-analyzer/src/analysis/mod.rs

@@ -1,5 +1,166 @@
 // Copyright (c) The Move Contributors
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::{
+    compiler_info::CompilerInfo,
+    symbols::{
+        compilation::{CompiledPkgInfo, SymbolsComputationData},
+        cursor::CursorContext,
+        def_info::DefInfo,
+        mod_defs::ModuleDefs,
+        use_def::{References, UseDef, UseDefMap},
+    },
+    utils::expansion_mod_ident_to_map_key,
+};
+
+use im::ordmap::OrdMap;
+use lsp_types::Position;
+use std::collections::BTreeMap;
+
+use move_compiler::{
+    expansion::ast::ModuleIdent,
+    parser::ast as P,
+    shared::{NamedAddressMap, files::MappedFiles, unique_map::UniqueMap},
+    typing::{ast::ModuleDefinition, visitor::TypingVisitorContext},
+};
+use move_ir_types::location::Loc;
+use move_symbol_pool::Symbol;
+
 pub mod parsing_analysis;
 pub mod typing_analysis;
+
+pub type DefMap = BTreeMap<Loc, DefInfo>;
+
+/// Run parsing analysis for either main program or dependencies
+pub fn run_parsing_analysis(
+    computation_data: &mut SymbolsComputationData,
+    compiled_pkg_info: &CompiledPkgInfo,
+    cursor_context: Option<&mut CursorContext>,
+    parsed_program: &P::Program,
+) {
+    let mut parsing_symbolicator = parsing_analysis::ParsingAnalysisContext {
+        mod_outer_defs: &mut computation_data.mod_outer_defs,
+        files: &compiled_pkg_info.mapped_files,
+        references: &mut computation_data.references,
+        def_info: &mut computation_data.def_info,
+        use_defs: UseDefMap::new(),
+        current_mod_ident_str: None,
+        alias_lengths: BTreeMap::new(),
+        pkg_addresses: &NamedAddressMap::new(),
+        cursor: cursor_context,
+    };
+
+    parsing_symbolicator.prog_symbols(
+        parsed_program,
+        &mut computation_data.mod_use_defs,
+        &mut computation_data.mod_to_alias_lengths,
+    );
+}
+
+/// Run typing analysis for either main program or dependencies
+pub fn run_typing_analysis(
+    mut computation_data: SymbolsComputationData,
+    mapped_files: &MappedFiles,
+    compiler_info: &mut CompilerInfo,
+    typed_program_modules: &UniqueMap<ModuleIdent, ModuleDefinition>,
+) -> SymbolsComputationData {
+    let mut typing_symbolicator = typing_analysis::TypingAnalysisContext {
+        mod_outer_defs: &mut computation_data.mod_outer_defs,
+        files: mapped_files,
+        references: &mut computation_data.references,
+        def_info: &mut computation_data.def_info,
+        use_defs: UseDefMap::new(),
+        current_mod_ident_str: None,
+        alias_lengths: &BTreeMap::new(),
+        traverse_only: false,
+        compiler_info,
+        type_params: BTreeMap::new(),
+        expression_scope: OrdMap::new(),
+    };
+
+    process_typed_modules(
+        typed_program_modules,
+        &computation_data.mod_to_alias_lengths,
+        &mut typing_symbolicator,
+        &mut computation_data.mod_use_defs,
+    );
+    computation_data
+}
+
+pub fn find_datatype(mod_defs: &ModuleDefs, datatype_name: &Symbol) -> Option<Loc> {
+    mod_defs.structs.get(datatype_name).map_or_else(
+        || {
+            mod_defs
+                .enums
+                .get(datatype_name)
+                .map(|enum_def| enum_def.name_loc)
+        },
+        |struct_def| Some(struct_def.name_loc),
+    )
+}
+
+fn process_typed_modules<'a>(
+    typed_modules: &UniqueMap<ModuleIdent, ModuleDefinition>,
+    mod_to_alias_lengths: &'a BTreeMap<String, BTreeMap<Position, usize>>,
+    typing_symbolicator: &mut typing_analysis::TypingAnalysisContext<'a>,
+    mod_use_defs: &mut BTreeMap<String, UseDefMap>,
+) {
+    for (module_ident, module_def) in typed_modules.key_cloned_iter() {
+        let mod_ident_str = expansion_mod_ident_to_map_key(&module_ident.value);
+        typing_symbolicator.use_defs = mod_use_defs.remove(&mod_ident_str).unwrap();
+        typing_symbolicator.alias_lengths = mod_to_alias_lengths.get(&mod_ident_str).unwrap();
+        typing_symbolicator.visit_module(module_ident, module_def);
+
+        let use_defs = std::mem::replace(&mut typing_symbolicator.use_defs, UseDefMap::new());
+        mod_use_defs.insert(mod_ident_str, use_defs);
+    }
+}
+
+/// Add use of a function, method, struct or enum identifier
+fn add_member_use_def(
+    member_def_name: &Symbol, // may be different from use_name for methods
+    files: &MappedFiles,
+    mod_defs: &ModuleDefs,
+    use_name: &Symbol,
+    use_loc: &Loc,
+    references: &mut References,
+    def_info: &DefMap,
+    use_defs: &mut UseDefMap,
+    alias_lengths: &BTreeMap<Position, usize>,
+) -> Option<UseDef> {
+    let Some(name_file_start) = files.start_position_opt(use_loc) else {
+        debug_assert!(false);
+        return None;
+    };
+    let name_start = Position {
+        line: name_file_start.line_offset() as u32,
+        character: name_file_start.column_offset() as u32,
+    };
+    if let Some(member_def) = mod_defs
+        .functions
+        .get(member_def_name)
+        .or_else(|| mod_defs.structs.get(member_def_name))
+        .or_else(|| mod_defs.enums.get(member_def_name))
+    {
+        let member_info = def_info.get(&member_def.name_loc).unwrap();
+        // type def location exists only for structs and enums (and not for functions)
+        let ident_type_def_loc = match member_info {
+            DefInfo::Struct(_, name, ..) | DefInfo::Enum(_, name, ..) => {
+                find_datatype(mod_defs, name)
+            }
+            _ => None,
+        };
+        let ud = UseDef::new(
+            references,
+            alias_lengths,
+            use_loc.file_hash(),
+            name_start,
+            member_def.name_loc,
+            use_name,
+            ident_type_def_loc,
+        );
+        use_defs.insert(name_start.line, ud.clone());
+        return Some(ud);
+    }
+    None
+}

external-crates/move/crates/move-analyzer/src/analysis/parsing_analysis.rs

@@ -2,11 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
+    analysis::{DefMap, add_member_use_def},
     symbols::{
-        AutoImportInsertionInfo, AutoImportInsertionKind, CallInfo, CursorContext,
-        CursorDefinition, CursorPosition, DefMap, ModuleDefs, References, UseDef, UseDefMap,
-        add_member_use_def, ignored_function, parsed_address,
-        parsing_leading_and_mod_names_to_map_key, parsing_mod_def_to_map_key,
+        cursor::{CursorContext, CursorDefinition, CursorPosition},
+        ignored_function,
+        mod_defs::{AutoImportInsertionInfo, AutoImportInsertionKind, CallInfo, ModuleDefs},
+        parsed_address,
+        use_def::{References, UseDef, UseDefMap},
     },
     utils::{loc_end_to_lsp_position_opt, loc_start_to_lsp_position_opt},
 };
@@ -921,6 +923,34 @@ impl<'a> ParsingAnalysisContext<'a> {
     }
 }
 
+/// Produces module ident string of the form pkg::module to be used as a map key.
+/// It's important that these are consistent between parsing AST and typed AST.
+pub fn parsing_mod_def_to_map_key(
+    pkg_addresses: &NamedAddressMap,
+    mod_def: &P::ModuleDefinition,
+) -> Option<String> {
+    // we assume that modules are declared using the PkgName::ModName pattern (which seems to be the
+    // standard practice) and while Move allows other ways of defining modules (i.e., with address
+    // preceding a sequence of modules), this method is now deprecated.
+    //
+    // TODO: make this function simply return String when the other way of defining modules is
+    // removed
+    mod_def
+        .address
+        .map(|a| parsing_leading_and_mod_names_to_map_key(pkg_addresses, a, mod_def.name))
+}
+
+/// Produces module ident string of the form pkg::module to be used as a map key.
+/// It's important that these are consistent between parsing AST and typed AST.
+fn parsing_leading_and_mod_names_to_map_key(
+    pkg_addresses: &NamedAddressMap,
+    ln: P::LeadingNameAccess,
+    name: P::ModuleName,
+) -> String {
+    let parsed_addr = parsed_address(ln, pkg_addresses);
+    format!("{}::{}", parsed_addr, name).to_string()
+}
+
 /// Produces module ident string of the form pkg::module to be used as a map key.
 /// It's important that these are consistent between parsing AST and typed AST,
 fn parsing_mod_ident_to_map_key(

external-crates/move/crates/move-analyzer/src/analysis/typing_analysis.rs

@@ -2,12 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
+    analysis::{DefMap, add_member_use_def, find_datatype},
     compiler_info::CompilerInfo,
     symbols::{
-        DefInfo, DefMap, LocalDef, MemberDefInfo, ModuleDefs, References, UseDef, UseDefMap,
-        add_member_use_def, expansion_mod_ident_to_map_key, find_datatype, type_def_loc,
+        def_info::DefInfo,
+        mod_defs::{MemberDefInfo, ModuleDefs},
+        type_def_loc,
+        use_def::{References, UseDef, UseDefMap},
     },
-    utils::{ignored_function, loc_start_to_lsp_position_opt},
+    utils::{expansion_mod_ident_to_map_key, ignored_function, loc_start_to_lsp_position_opt},
 };
 
 use move_compiler::{
@@ -26,7 +29,7 @@ use move_symbol_pool::Symbol;
 
 use im::OrdMap;
 use lsp_types::Position;
-use std::collections::BTreeMap;
+use std::{cmp, collections::BTreeMap};
 
 /// Data used during anlysis over typed AST
 pub struct TypingAnalysisContext<'a> {
@@ -61,6 +64,26 @@ pub struct TypingAnalysisContext<'a> {
     pub compiler_info: &'a mut CompilerInfo,
 }
 
+/// Definition of a local (or parameter)
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct LocalDef {
+    /// Location of the definition
+    pub def_loc: Loc,
+    /// Type of definition
+    pub def_type: N::Type,
+}
+
+impl PartialOrd for LocalDef {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl Ord for LocalDef {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.def_loc.cmp(&other.def_loc)
+    }
+}
+
 fn def_info_to_type_def_loc(
     mod_outer_defs: &BTreeMap<String, ModuleDefs>,
     def_info: &DefInfo,

external-crates/move/crates/move-analyzer/src/analyzer.rs

@@ -21,7 +21,19 @@ use std::{
 };
 
 use crate::{
-    code_action, completions::on_completion_request, context::Context, inlay_hints, symbols,
+    code_action,
+    completions::on_completion_request,
+    context::Context,
+    inlay_hints,
+    symbols::{
+        self,
+        compilation::PrecomputedPkgInfo,
+        requests::{
+            on_document_symbol_request, on_go_to_def_request, on_go_to_type_def_request,
+            on_hover_request, on_references_request,
+        },
+        runner::SymbolicatorRunner,
+    },
     vfs::on_text_document_sync_notification,
 };
 use url::Url;
@@ -47,9 +59,7 @@ pub fn run(implicit_deps: Dependencies) {
 
     let (connection, io_threads) = Connection::stdio();
     let symbols_map = Arc::new(Mutex::new(BTreeMap::new()));
-    let pkg_deps = Arc::new(Mutex::new(
-        BTreeMap::<PathBuf, symbols::PrecomputedPkgInfo>::new(),
-    ));
+    let pkg_deps = Arc::new(Mutex::new(BTreeMap::<PathBuf, PrecomputedPkgInfo>::new()));
     let ide_files_root: VfsPath = MemoryFS::new().into();
 
     let (id, client_response) = connection
@@ -142,7 +152,7 @@ pub fn run(implicit_deps: Dependencies) {
     };
     eprintln!("linting level {:?}", lint);
 
-    let symbolicator_runner = symbols::SymbolicatorRunner::new(
+    let symbolicator_runner = SymbolicatorRunner::new(
         ide_files_root.clone(),
         symbols_map.clone(),
         pkg_deps.clone(),
@@ -158,7 +168,7 @@ pub fn run(implicit_deps: Dependencies) {
     // to be available right after the client is initialized.
     if let Some(uri) = initialize_params.root_uri {
         let build_path = uri.to_file_path().unwrap();
-        if let Some(p) = symbols::SymbolicatorRunner::root_dir(&build_path) {
+        if let Some(p) = SymbolicatorRunner::root_dir(&build_path) {
             if let Ok((Some(new_symbols), _)) = symbols::get_symbols(
                 Arc::new(Mutex::new(BTreeMap::new())),
                 ide_files_root.clone(),
@@ -300,7 +310,7 @@ fn on_request(
     context: &Context,
     request: &Request,
     ide_files_root: VfsPath,
-    pkg_dependencies: Arc<Mutex<BTreeMap<PathBuf, symbols::PrecomputedPkgInfo>>>,
+    pkg_dependencies: Arc<Mutex<BTreeMap<PathBuf, PrecomputedPkgInfo>>>,
     shutdown_request_received: bool,
     implicit_deps: Dependencies,
 ) -> bool {
@@ -328,19 +338,19 @@ fn on_request(
             implicit_deps,
         ),
         lsp_types::request::GotoDefinition::METHOD => {
-            symbols::on_go_to_def_request(context, request);
+            on_go_to_def_request(context, request);
         }
         lsp_types::request::GotoTypeDefinition::METHOD => {
-            symbols::on_go_to_type_def_request(context, request);
+            on_go_to_type_def_request(context, request);
         }
         lsp_types::request::References::METHOD => {
-            symbols::on_references_request(context, request);
+            on_references_request(context, request);
         }
         lsp_types::request::HoverRequest::METHOD => {
-            symbols::on_hover_request(context, request);
+            on_hover_request(context, request);
         }
         lsp_types::request::DocumentSymbolRequest::METHOD => {
-            symbols::on_document_symbol_request(context, request);
+            on_document_symbol_request(context, request);
         }
         lsp_types::request::InlayHintRequest::METHOD => {
             inlay_hints::on_inlay_hint_request(context, request);
@@ -378,7 +388,7 @@ fn on_response(_context: &Context, _response: &Response) {
 
 fn on_notification(
     ide_files_root: VfsPath,
-    symbolicator_runner: &symbols::SymbolicatorRunner,
+    symbolicator_runner: &SymbolicatorRunner,
     notification: &Notification,
 ) {
     match notification.method.as_str() {

external-crates/move/crates/move-analyzer/src/code_action.rs

@@ -8,8 +8,10 @@ use crate::{
     },
     context::Context,
     symbols::{
-        ChainInfo, CompiledPkgInfo, CursorContext, PrecomputedPkgInfo, SymbolicatorRunner, Symbols,
-        get_compiled_pkg,
+        Symbols,
+        compilation::{CompiledPkgInfo, PrecomputedPkgInfo, get_compiled_pkg},
+        cursor::{ChainInfo, CursorContext},
+        runner::SymbolicatorRunner,
     },
     utils::loc_start_to_lsp_position_opt,
 };

external-crates/move/crates/move-analyzer/src/completions/dot.rs

@@ -5,7 +5,11 @@
 
 use crate::{
     completions::utils::{call_completion_item, mod_defs},
-    symbols::{DefInfo, FunType, Symbols, type_to_ide_string},
+    symbols::{
+        Symbols,
+        def_info::{DefInfo, FunType},
+        ide_strings::type_to_ide_string,
+    },
     utils::lsp_position_to_loc,
 };
 use lsp_types::{