impl auto require

Author: CppCXY

crates/emmylua_ls/src/handlers/command/commands/emmy_auto_require.rs

@@ -1,10 +1,158 @@
+use std::{collections::HashMap, time::Duration};
+
+use code_analysis::FileId;
+use emmylua_parser::{LuaAstNode, LuaExpr, LuaStat};
+use lsp_types::{ApplyWorkspaceEditParams, Command, Position, TextEdit, WorkspaceEdit};
 use serde_json::Value;
 
-use crate::context::ServerContextSnapshot;
+use crate::{
+    context::ServerContextSnapshot,
+    util::{module_name_convert, time_cancel_token},
+};
 
 pub const COMMAND: &str = "emmy.auto.require";
 
-#[allow(unused)]
 pub async fn handle(context: ServerContextSnapshot, args: Vec<Value>) -> Option<()> {
+    let add_to: FileId = serde_json::from_value(args.get(0)?.clone()).ok()?;
+    let need_require_file_id: FileId = serde_json::from_value(args.get(1)?.clone()).ok()?;
+    let position: Position = serde_json::from_value(args.get(2)?.clone()).ok()?;
+
+    let analysis = context.analysis.read().await;
+    let semantic_model = analysis.compilation.get_semantic_model(add_to)?;
+    let module_info = semantic_model
+        .get_db()
+        .get_module_index()
+        .get_module(need_require_file_id)?;
+    let emmyrc = semantic_model.get_emmyrc();
+    let require_like_func = &emmyrc.runtime.require_like_function;
+    let auto_require_func = emmyrc.completion.auto_require_function.clone();
+    let file_convension = emmyrc.completion.auto_require_naming_convention;
+    let local_name = module_name_convert(&module_info.name, file_convension);
+    let require_str = format!(
+        "local {} = {}(\"{}\")",
+        local_name, auto_require_func, module_info.full_module_name
+    );
+    let document = semantic_model.get_document();
+    let offset = document.get_offset(position.line as usize, position.character as usize)?;
+    let root_block = semantic_model.get_root().get_block()?;
+    let mut last_require_stat: Option<LuaStat> = None;
+    for stat in root_block.get_stats() {
+        if stat.get_position() > offset {
+            break;
+        }
+
+        if is_require_stat(stat.clone(), &require_like_func).unwrap_or(false) {
+            last_require_stat = Some(stat);
+        }
+    }
+
+    let line = if let Some(last_require_stat) = last_require_stat {
+        let last_require_stat_end = last_require_stat.get_range().end();
+        document.get_line(last_require_stat_end)? + 1
+    } else {
+        0
+    };
+
+    let text_edit = TextEdit {
+        range: lsp_types::Range {
+            start: Position {
+                line: line as u32,
+                character: 0,
+            },
+            end: Position {
+                line: line as u32,
+                character: 0,
+            },
+        },
+        new_text: format!("{}\n", require_str),
+    };
+
+    let uri = document.get_uri();
+    let mut changes = HashMap::new();
+    changes.insert(uri.clone(), vec![text_edit.clone()]);
+
+    let client = context.client;
+    let cancel_token = time_cancel_token(Duration::from_secs(5));
+    let apply_edit_params = ApplyWorkspaceEditParams {
+        label: None,
+        edit: WorkspaceEdit {
+            changes: Some(changes),
+            document_changes: None,
+            change_annotations: None,
+        },
+    };
+
+    tokio::spawn(async move {
+        let res = client.apply_edit(apply_edit_params, cancel_token).await;
+        if let Some(res) = res {
+            if !res.applied {
+                log::error!("Failed to apply edit: {:?}", res.failure_reason);
+            }
+        }
+    });
+
     Some(())
 }
+
+fn is_require_stat(stat: LuaStat, require_like_func: &Vec<String>) -> Option<bool> {
+    match stat {
+        LuaStat::LocalStat(local_stat) => {
+            let exprs = local_stat.get_value_exprs();
+            for expr in exprs {
+                if is_require_expr(expr, require_like_func).unwrap_or(false) {
+                    return Some(true);
+                }
+            }
+        }
+        LuaStat::AssignStat(assign_stat) => {
+            let (_, exprs) = assign_stat.get_var_and_expr_list();
+            for expr in exprs {
+                if is_require_expr(expr, require_like_func).unwrap_or(false) {
+                    return Some(true);
+                }
+            }
+        }
+        LuaStat::CallExprStat(call_expr_stat) => {
+            let expr = call_expr_stat.get_call_expr()?;
+            if is_require_expr(expr.into(), require_like_func).unwrap_or(false) {
+                return Some(true);
+            }
+        }
+        _ => {}
+    }
+
+    Some(false)
+}
+
+fn is_require_expr(expr: LuaExpr, require_like_func: &Vec<String>) -> Option<bool> {
+    if let LuaExpr::CallExpr(call_expr) = expr {
+        let name = call_expr.get_prefix_expr()?;
+        if let LuaExpr::NameExpr(name_expr) = name {
+            let name = name_expr.get_name_text()?;
+            if require_like_func.contains(&name.to_string()) || name == "require" {
+                return Some(true);
+            }
+        }
+    }
+
+    Some(false)
+}
+
+pub fn make_auto_require(
+    title: &str,
+    add_to: FileId,
+    need_require_file_id: FileId,
+    position: Position,
+) -> Command {
+    let args = vec![
+        serde_json::to_value(add_to).unwrap(),
+        serde_json::to_value(need_require_file_id).unwrap(),
+        serde_json::to_value(position).unwrap(),
+    ];
+
+    Command {
+        title: title.to_string(),
+        command: COMMAND.to_string(),
+        arguments: Some(args),
+    }
+}

crates/emmylua_ls/src/handlers/command/commands/mod.rs

@@ -7,6 +7,7 @@ mod emmy_disable_code;
 mod emmy_fix_format;
 
 pub use emmy_disable_code::{make_disable_code_command, DisableAction};
+pub use emmy_auto_require::make_auto_require;
 
 pub fn get_commands_list() -> Vec<String> {
     let mut commands = Vec::new();

crates/emmylua_ls/src/handlers/completion/providers/auto_require_provider.rs

@@ -1,14 +1,22 @@
 use code_analysis::{EmmyrcFilenameConvention, ModuleInfo};
 use emmylua_parser::{LuaAstNode, LuaNameExpr};
-use lsp_types::CompletionItem;
+use lsp_types::{CompletionItem, Position};
 
-use crate::handlers::completion::completion_builder::CompletionBuilder;
+use crate::{
+    handlers::{command::make_auto_require, completion::completion_builder::CompletionBuilder},
+    util::module_name_convert,
+};
 
 pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
     if builder.is_cancelled() {
         return None;
     }
 
+    let enable = builder.semantic_model.get_emmyrc().completion.auto_require;
+    if !enable {
+        return None;
+    }
+
     let name_expr = LuaNameExpr::cast(builder.trigger_token.parent()?)?;
     // optimize for large project
     let prefix = name_expr.get_name_text()?.to_lowercase();
@@ -23,6 +31,9 @@ pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
         .get_db()
         .get_module_index()
         .get_module_infos();
+    let range = builder.trigger_token.text_range();
+    let document = builder.semantic_model.get_document();
+    let lsp_position = document.to_lsp_range(range)?.start;
 
     let mut completions = Vec::new();
     for module_info in module_infos {
@@ -35,6 +46,7 @@ pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
                 &prefix,
                 &module_info,
                 file_convension,
+                lsp_position,
                 &mut completions,
             );
         }
@@ -52,6 +64,7 @@ fn add_module_completion_item(
     prefix: &str,
     module_info: &ModuleInfo,
     file_convension: EmmyrcFilenameConvention,
+    position: Position,
     completions: &mut Vec<CompletionItem>,
 ) -> Option<()> {
     let completion_name = module_name_convert(&module_info.name, file_convension);
@@ -70,76 +83,16 @@ fn add_module_completion_item(
             detail: Some(format!("    (in {})", module_info.full_module_name)),
             ..Default::default()
         }),
+        command: Some(make_auto_require(
+            "",
+            builder.semantic_model.get_file_id(),
+            module_info.file_id,
+            position
+        )),
         ..Default::default()
     };
 
     completions.push(completion_item);
 
     Some(())
 }
-
-fn module_name_convert(name: &str, file_convension: EmmyrcFilenameConvention) -> String {
-    let mut module_name = name.to_string();
-
-    match file_convension {
-        EmmyrcFilenameConvention::SnakeCase => {
-            module_name = to_snake_case(&module_name);
-        }
-        EmmyrcFilenameConvention::CamelCase => {
-            module_name = to_camel_case(&module_name);
-        }
-        EmmyrcFilenameConvention::PascalCase => {
-            module_name = to_pascal_case(&module_name);
-        }
-        EmmyrcFilenameConvention::Keep => {}
-    }
-
-    module_name
-}
-
-fn to_snake_case(s: &str) -> String {
-    let mut result = String::new();
-    for (i, ch) in s.chars().enumerate() {
-        if ch.is_uppercase() && i != 0 {
-            result.push('_');
-            result.push(ch.to_ascii_lowercase());
-        } else {
-            result.push(ch.to_ascii_lowercase());
-        }
-    }
-    result
-}
-
-fn to_camel_case(s: &str) -> String {
-    let mut result = String::new();
-    let mut next_uppercase = false;
-    for (i, ch) in s.chars().enumerate() {
-        if ch == '_' || ch == '-' || ch == '.' {
-            next_uppercase = true;
-        } else if next_uppercase {
-            result.push(ch.to_ascii_uppercase());
-            next_uppercase = false;
-        } else if i == 0 {
-            result.push(ch.to_ascii_lowercase());
-        } else {
-            result.push(ch);
-        }
-    }
-    result
-}
-
-fn to_pascal_case(s: &str) -> String {
-    let mut result = String::new();
-    let mut next_uppercase = true;
-    for ch in s.chars() {
-        if ch == '_' || ch == '-' || ch == '.' {
-            next_uppercase = true;
-        } else if next_uppercase {
-            result.push(ch.to_ascii_uppercase());
-            next_uppercase = false;
-        } else {
-            result.push(ch.to_ascii_lowercase());
-        }
-    }
-    result
-}

crates/emmylua_ls/src/handlers/semantic_token/mod.rs

@@ -26,6 +26,10 @@ pub async fn on_semantic_token_handler(
     let file_id = analysis.get_file_id(&uri)?;
     let mut semantic_model = analysis.compilation.get_semantic_model(file_id)?;
 
+    if !semantic_model.get_emmyrc().semantic_tokens.enable {
+        return None;
+    }
+
     let result = build_semantic_tokens(
         &mut semantic_model,
         unsafe { SEMANTIC_MULTILINE_SUPPORT },

crates/emmylua_ls/src/util/mod.rs

@@ -1,5 +1,7 @@
 mod time_cancel_token;
 mod humanize_type;
+mod module_name_convert;
 
 pub use time_cancel_token::time_cancel_token; 
 pub use humanize_type::humanize_type;
+pub use module_name_convert::module_name_convert;

crates/emmylua_ls/src/util/module_name_convert.rs

@@ -0,0 +1,67 @@
+use code_analysis::EmmyrcFilenameConvention;
+
+pub fn module_name_convert(name: &str, file_convension: EmmyrcFilenameConvention) -> String {
+    let mut module_name = name.to_string();
+
+    match file_convension {
+        EmmyrcFilenameConvention::SnakeCase => {
+            module_name = to_snake_case(&module_name);
+        }
+        EmmyrcFilenameConvention::CamelCase => {
+            module_name = to_camel_case(&module_name);
+        }
+        EmmyrcFilenameConvention::PascalCase => {
+            module_name = to_pascal_case(&module_name);
+        }
+        EmmyrcFilenameConvention::Keep => {}
+    }
+
+    module_name
+}
+
+fn to_snake_case(s: &str) -> String {
+    let mut result = String::new();
+    for (i, ch) in s.chars().enumerate() {
+        if ch.is_uppercase() && i != 0 {
+            result.push('_');
+            result.push(ch.to_ascii_lowercase());
+        } else {
+            result.push(ch.to_ascii_lowercase());
+        }
+    }
+    result
+}
+
+fn to_camel_case(s: &str) -> String {
+    let mut result = String::new();
+    let mut next_uppercase = false;
+    for (i, ch) in s.chars().enumerate() {
+        if ch == '_' || ch == '-' || ch == '.' {
+            next_uppercase = true;
+        } else if next_uppercase {
+            result.push(ch.to_ascii_uppercase());
+            next_uppercase = false;
+        } else if i == 0 {
+            result.push(ch.to_ascii_lowercase());
+        } else {
+            result.push(ch);
+        }
+    }
+    result
+}
+
+fn to_pascal_case(s: &str) -> String {
+    let mut result = String::new();
+    let mut next_uppercase = true;
+    for ch in s.chars() {
+        if ch == '_' || ch == '-' || ch == '.' {
+            next_uppercase = true;
+        } else if next_uppercase {
+            result.push(ch.to_ascii_uppercase());
+            next_uppercase = false;
+        } else {
+            result.push(ch.to_ascii_lowercase());
+        }
+    }
+    result
+}