fnl: typo

Author: BrettMayson

bin/src/modules/fnl.rs

@@ -17,7 +17,7 @@ pub struct FineNewLineCheck {}
 
 impl Module for FineNewLineCheck {
     fn name(&self) -> &'static str {
-        "Fine New Line Check"
+        "Final New Line Check"
     }
 
     fn check(&self, ctx: &Context) -> Result<Report, crate::Error> {

hls/src/config/lints.rs

@@ -11,6 +11,7 @@ use tracing::{debug, warn};
 use url::Url;
 
 use crate::{
+    config::ConfigAnalyzer,
     diag_manager::DiagManager,
     preprocessor::PreprocessorAnalyzer,
     workspace::{EditorWorkspace, EditorWorkspaces},
@@ -85,6 +86,20 @@ async fn check_addon(source: WorkspacePath, workspace: EditorWorkspace) {
                                 lsp_diags.entry(file).or_insert_with(Vec::new).push(diag);
                             }
                         }
+                        let config_analyzer = ConfigAnalyzer::get();
+                        config_analyzer.functions_defined.insert(
+                            {
+                                // `/folder/addon/blah` => addon
+                                let parts: Vec<&str> = source.as_str().split('/').collect();
+                                if parts.len() < 3 {
+                                    warn!("Invalid config path: {}", source.as_str());
+                                    parts[1].to_string()
+                                } else {
+                                    parts[2].to_string()
+                                }
+                            },
+                            report.functions_defined().clone(),
+                        );
                     }
                     Err(err) => {
                         warn!("failed to process config: {:?}", err);

hls/src/config/mod.rs

@@ -1,5 +1,7 @@
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 
+use dashmap::DashMap;
+use hemtt_workspace::addons::DefinedFunctions;
 use tower_lsp::Client;
 use url::Url;
 
@@ -8,11 +10,15 @@ use crate::workspace::EditorWorkspace;
 mod lints;
 
 #[derive(Clone)]
-pub struct ConfigAnalyzer {}
+pub struct ConfigAnalyzer {
+    pub(crate) functions_defined: Arc<DashMap<String, DefinedFunctions>>,
+}
 
 impl ConfigAnalyzer {
     pub fn get() -> Self {
-        static SINGLETON: LazyLock<ConfigAnalyzer> = LazyLock::new(|| ConfigAnalyzer {});
+        static SINGLETON: LazyLock<ConfigAnalyzer> = LazyLock::new(|| ConfigAnalyzer {
+            functions_defined: Arc::new(DashMap::new()),
+        });
         (*SINGLETON).clone()
     }
 

hls/src/main.rs

@@ -15,6 +15,7 @@ use crate::workspace::EditorWorkspaces;
 
 mod audio;
 mod color;
+mod completion;
 mod config;
 mod diag_manager;
 mod files;
@@ -59,6 +60,19 @@ impl LanguageServer for Backend {
                         work_done_progress: None,
                     },
                 }),
+                completion_provider: Some(CompletionOptions {
+                    resolve_provider: Some(false),
+                    trigger_characters: Some(vec![
+                        "(".to_string(),
+                        ",".to_string(),
+                        "\\".to_string(),
+                    ]),
+                    all_commit_characters: None,
+                    work_done_progress_options: WorkDoneProgressOptions {
+                        work_done_progress: None,
+                    },
+                    completion_item: None,
+                }),
                 definition_provider: Some(OneOf::Left(true)),
                 color_provider: Some(ColorProviderCapability::Options(
                     StaticTextDocumentColorProviderOptions {
@@ -110,7 +124,6 @@ impl LanguageServer for Backend {
     }
 
     async fn did_change_watched_files(&self, params: DidChangeWatchedFilesParams) {
-        debug!("did_change_watched_files");
         for x in params.changes {
             if x.uri.path().contains(".toml") {
                 ConfigAnalyzer::get()
@@ -124,7 +137,6 @@ impl LanguageServer for Backend {
     }
 
     async fn did_open(&self, params: DidOpenTextDocumentParams) {
-        debug!("did_open: {:?}", params.text_document.uri);
         let document = TextDocumentItem {
             uri: params.text_document.uri.clone(),
             text: TextInformation::Full(&params.text_document.text),
@@ -151,7 +163,6 @@ impl LanguageServer for Backend {
     }
 
     async fn did_save(&self, params: DidSaveTextDocumentParams) {
-        debug!("did_save: {:?}", params.text_document.uri);
         ConfigAnalyzer::get()
             .on_save(params.text_document.uri.clone(), self.client.clone())
             .await;
@@ -170,7 +181,6 @@ impl LanguageServer for Backend {
     }
 
     async fn did_close(&self, params: DidCloseTextDocumentParams) {
-        debug!("did_close: {:?}", params.text_document.uri);
         FileCache::get().on_close(&params.text_document.uri).await;
         SqfAnalyzer::get().on_close(&params.text_document.uri).await;
         PreprocessorAnalyzer::get()
@@ -208,6 +218,16 @@ impl LanguageServer for Backend {
     ) -> Result<Vec<ColorPresentation>> {
         color::presentation(params).await
     }
+
+    async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+        let uri = &params.text_document_position.text_document.uri;
+        let (_, ext) = uri.path().rsplit_once('.').unwrap_or((uri.path(), ""));
+        let ext = ext.to_lowercase();
+        if ["sqf", "ext", "cpp", "hpp", "inc"].contains(&ext.as_str()) {
+            return completion::completion(params.text_document_position, params.context).await;
+        }
+        Ok(None)
+    }
 }
 
 impl Backend {

hls/src/preprocessor/signature.rs

@@ -2,15 +2,14 @@ use hemtt_workspace::reporting::Definition;
 use tower_lsp::lsp_types::{
     ParameterInformation, ParameterLabel, SignatureHelp, SignatureHelpParams, SignatureInformation,
 };
-use tracing::{debug, warn};
+use tracing::warn;
 
 use crate::{files::FileCache, workspace::EditorWorkspaces};
 
 use super::PreprocessorAnalyzer;
 
 impl PreprocessorAnalyzer {
     pub async fn signature_help(&self, params: &SignatureHelpParams) -> Option<SignatureHelp> {
-        debug!("signature_help: {:?}", params);
         let url = &params.text_document_position_params.text_document.uri;
         let path = url.to_file_path().ok()?;
         #[derive(Debug, PartialEq, Eq)]

hls/src/sqf/lints.rs

@@ -41,6 +41,7 @@ impl Cache {
 async fn check_addons(workspace: EditorWorkspace, database: Arc<Database>, client: Client) {
     debug!("sqf: checking addons");
     let mut futures = JoinSet::new();
+    let mut next_addons = Vec::new();
     for addon in workspace.root().addons() {
         let Ok(source) = workspace.root().join(addon.as_str()) else {
             warn!("failed to join addon {:?}", addon);
@@ -68,6 +69,7 @@ async fn check_addons(workspace: EditorWorkspace, database: Arc<Database>, clien
                 ));
             }
         }
+        next_addons.push(addon);
     }
     tokio::spawn(async move {
         futures.join_all().await;
@@ -104,13 +106,24 @@ async fn check_sqf(
                 let workspace_files = WorkspaceFiles::new();
                 match hemtt_sqf::parser::run(&database, &processed) {
                     Ok(sqf) => {
-                        let (codes, _) = hemtt_sqf::analyze::analyze(
+                        let (codes, report) = hemtt_sqf::analyze::analyze(
                             &sqf,
                             workspace.config().as_ref(),
                             &processed,
-                            addon,
+                            addon.clone(),
                             database,
                         );
+                        if let Some(report) = report {
+                            let cache = SqfAnalyzer::get();
+                            let mut functions_defined = cache
+                                .functions_defined
+                                .entry(addon.name().to_string())
+                                .or_insert_with(HashMap::new);
+                            functions_defined.insert(
+                                source.as_str().to_string(),
+                                report.functions_defined().clone(),
+                            );
+                        }
                         for code in codes {
                             let Some(diag) = code.diagnostic() else {
                                 warn!("failed to get diagnostic");

hls/src/sqf/mod.rs

@@ -2,11 +2,14 @@ mod compiled;
 mod hover;
 mod lints;
 
-use std::sync::{Arc, LazyLock};
+use std::{
+    collections::HashMap,
+    sync::{Arc, LazyLock},
+};
 
 use dashmap::DashMap;
 use hemtt_sqf::parser::database::Database;
-use hemtt_workspace::reporting::Token;
+use hemtt_workspace::{addons::DefinedFunctions, reporting::Token};
 use tower_lsp::Client;
 use tracing::{error, warn};
 use url::Url;
@@ -21,13 +24,15 @@ use crate::{
 pub struct SqfAnalyzer {
     tokens: Arc<DashMap<Url, Vec<Arc<Token>>>>,
     databases: Arc<DashMap<EditorWorkspace, Arc<Database>>>,
+    pub(crate) functions_defined: Arc<DashMap<String, HashMap<String, DefinedFunctions>>>,
 }
 
 impl SqfAnalyzer {
     pub fn get() -> Self {
         static SINGLETON: LazyLock<SqfAnalyzer> = LazyLock::new(|| SqfAnalyzer {
             tokens: Arc::new(DashMap::new()),
             databases: Arc::new(DashMap::new()),
+            functions_defined: Arc::new(DashMap::new()),
         });
         (*SINGLETON).clone()
     }

libs/config/src/analyze/lints/collect_cfgfunctions.rs

@@ -76,9 +76,10 @@ impl LintRunner<LintData> for Runner {
                 for function in properties_category {
                     let Property::Class(func_class) = function else { continue };
                     let Some(class_name) = func_class.name() else { continue; }; 
-                    let func_name = format!("{prefix_real}_fnc_{}",class_name.as_str()).to_lowercase();
+                    let func_name = format!("{prefix_real}_fnc_{}",class_name.as_str());
+                    let func_name_lower = func_name.to_lowercase();
                     let mut functions_defined = data.functions_defined.lock().expect("mutex safety");
-                    functions_defined.insert(func_name);
+                    functions_defined.insert((func_name_lower, func_name.into()));
                 }
             }
         }

libs/config/tests/lints.rs

@@ -83,7 +83,7 @@ fn test_c09_magwell_missing_magazine() {
 #[test]
 fn test_collect_cfgfunctions() {
     let (_, report) = lint(stringify!(collect_cfgfunctions));
-    let mut functions_defined: Vec<&String> = report.functions_defined().iter().collect();
+    let mut functions_defined: Vec<&String> = report.functions_defined().iter().map(|(s, _)| s).collect();
     functions_defined.sort();
     insta::assert_compact_debug_snapshot!(functions_defined);
 }

libs/sqf/src/analyze/lints/s29_function_undefined.rs

@@ -133,11 +133,11 @@ impl LintRunner<LintData> for RunnerExpression {
                         return vec![];
                     }
                 };
-                let func_name = func_name.to_lowercase();
-                if is_project_func(&func_name, project) {
+                let func_name_lower = func_name.to_lowercase();
+                if is_project_func(&func_name_lower, project) {
                     let mut functions_defined =
                         data.functions_defined.lock().expect("mutex safety");
-                    functions_defined.insert(func_name);
+                    functions_defined.insert((func_name_lower, func_name.clone()));
                 }
             }
             _ => {}
@@ -167,10 +167,10 @@ impl LintRunner<LintData> for RunnerStatement {
         let Statement::AssignGlobal(func_name, _, _) = target else {
             return Vec::new();
         };
-        let func_name = func_name.to_lowercase();
-        if is_project_func(&func_name, project) {
+        let func_name_lower = func_name.to_lowercase();
+        if is_project_func(&func_name_lower, project) {
             let mut functions_defined = data.functions_defined.lock().expect("mutex safety");
-            functions_defined.insert(func_name);
+            functions_defined.insert((func_name_lower, func_name.clone().into()));
         }
 
         vec![]
@@ -206,7 +206,7 @@ impl LintRunner<LintData> for RunnerFinal {
         if let Some(toml::Value::Array(ignore)) = config.option("ignore") {
             for i in ignore {
                 if let Value::String(i) = i {
-                    all_defined.insert(i.to_lowercase());
+                    all_defined.insert((i.to_lowercase(), i.clone().into()));
                 }
             }
         }
@@ -220,14 +220,14 @@ impl LintRunner<LintData> for RunnerFinal {
                 .expect("not juliet")
                 .clone();
             for (func, position, start, end, file) in used {
-                if !all_defined.contains(&func) {
+                if !all_defined.iter().any(|(s, _)| s == &func) {
                     all_missing.entry(func).or_insert(Vec::new()).push((position, start, end, file));
                 }
             }
         }
 
         for (func, positions) in all_missing {
-            let similar = similar_values(&func, &all_defined.iter().map(std::string::String::as_str).collect::<Vec<_>>())
+            let similar = similar_values(&func, &all_defined.iter().map(|(s, _)| s.as_str()).collect::<Vec<_>>())
                 .into_iter()
                 .map(std::string::ToString::to_string)
                 .collect();