add diagnostic prog macro, add more doc completion

Author: CppCXY

Cargo.lock

@@ -6,6 +6,7 @@ edition = "2021"
 [dependencies]
 url = "2.5.2"
 emmylua_parser = { path = "../emmylua_parser" }
+diagnostic_macro = { path = "../diagnostic_macro" }
 globset = "0.4.15"
 percent-encoding = "2.3"
 flagset = "0.4.6"

crates/code_analysis/Cargo.toml

@@ -1,10 +1,9 @@
-use std::{fmt, str::FromStr};
-
+use diagnostic_macro::LuaDiagnosticMacro;
 use lsp_types::DiagnosticSeverity;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema, LuaDiagnosticMacro)]
 #[serde(rename_all = "kebab-case")]
 pub enum DiagnosticCode {
     None,
@@ -30,72 +29,6 @@ pub enum DiagnosticCode {
     // ... other variants
 }
 
-impl DiagnosticCode {
-    pub fn get_name(&self) -> &str {
-        match self {
-            DiagnosticCode::None => "none",
-            DiagnosticCode::SyntaxError => "syntax-error",
-            DiagnosticCode::TypeNotFound => "type-not-found",
-            DiagnosticCode::MissingReturn => "missing-return",
-            DiagnosticCode::TypeNotMatch => "type-not-match",
-            DiagnosticCode::MissingParameter => "missing-parameter",
-            DiagnosticCode::InjectFieldFail => "inject-field-fail",
-            DiagnosticCode::UnreachableCode => "unreachable-code",
-            DiagnosticCode::Unused => "unused",
-            DiagnosticCode::UndefinedGlobal => "undefined-global",
-            DiagnosticCode::NeedImport => "need-import",
-            DiagnosticCode::Deprecated => "deprecated",
-            DiagnosticCode::AccessPrivateMember => "access-private-member",
-            DiagnosticCode::AccessProtectedMember => "access-protected-member",
-            DiagnosticCode::AccessPackageMember => "access-package-member",
-            DiagnosticCode::NoDiscard => "no-discard",
-            DiagnosticCode::DisableGlobalDefine => "disable-global-define",
-            DiagnosticCode::UndefinedField => "undefined-field",
-            DiagnosticCode::LocalConstReassign => "local-const-reassign",
-            DiagnosticCode::DuplicateType => "duplicate-type",
-            // ... handle other variants
-        }
-    }
-}
-
-// Implement FromStr for DiagnosticCode
-impl FromStr for DiagnosticCode {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "syntax-error" => Ok(DiagnosticCode::SyntaxError),
-            "type-not-found" => Ok(DiagnosticCode::TypeNotFound),
-            "missing-return" => Ok(DiagnosticCode::MissingReturn),
-            "type-not-match" => Ok(DiagnosticCode::TypeNotMatch),
-            "missing-parameter" => Ok(DiagnosticCode::MissingParameter),
-            "inject-field-fail" => Ok(DiagnosticCode::InjectFieldFail),
-            "unreachable-code" => Ok(DiagnosticCode::UnreachableCode),
-            "unused" => Ok(DiagnosticCode::Unused),
-            "undefined-global" => Ok(DiagnosticCode::UndefinedGlobal),
-            "need-import" => Ok(DiagnosticCode::NeedImport),
-            "deprecated" => Ok(DiagnosticCode::Deprecated),
-            "access-private-member" => Ok(DiagnosticCode::AccessPrivateMember),
-            "access-protected-member" => Ok(DiagnosticCode::AccessProtectedMember),
-            "access-package-member" => Ok(DiagnosticCode::AccessPackageMember),
-            "no-discard" => Ok(DiagnosticCode::NoDiscard),
-            "disable-global-define" => Ok(DiagnosticCode::DisableGlobalDefine),
-            "undefined-field" => Ok(DiagnosticCode::UndefinedField),
-            "local-const-reassign" => Ok(DiagnosticCode::LocalConstReassign),
-            "duplicate-type" => Ok(DiagnosticCode::DuplicateType),
-            // ... handle other variants
-            _ => Ok(DiagnosticCode::None),
-        }
-    }
-}
-
-// Implement Display for DiagnosticCode
-impl fmt::Display for DiagnosticCode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.get_name())
-    }
-}
-
 // Update functions to match enum variants
 pub fn get_default_severity(code: DiagnosticCode) -> DiagnosticSeverity {
     match code {

crates/code_analysis/src/diagnostic/lua_diagnostic_code.rs

@@ -0,0 +1,12 @@
+[package]
+name = "diagnostic_macro"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+syn = "2.0"
+quote = "1.0"

crates/diagnostic_macro/Cargo.toml

@@ -0,0 +1,119 @@
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    parse_macro_input, DeriveInput, Data, Fields, Ident,
+    spanned::Spanned,
+};
+
+// Convert enum variant names to kebab-case
+fn to_kebab_case(ident: &Ident) -> String {
+    let s = ident.to_string();
+    let mut result = String::new();
+    for (i, c) in s.chars().enumerate() {
+        if c.is_uppercase() && i != 0 {
+            result.push('-');
+            result.push(c.to_ascii_lowercase());
+        } else {
+            result.push(c.to_ascii_lowercase());
+        }
+    }
+    result
+}
+
+#[proc_macro_derive(LuaDiagnosticMacro)]
+pub fn lua_diagnostic_macro(input: TokenStream) -> TokenStream {
+    // Parse the input TokenStream into DeriveInput
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.ident.clone();
+
+    // Ensure the input is an enum
+    let variants = match input.data {
+        Data::Enum(ref data_enum) => &data_enum.variants,
+        _ => {
+            return syn::Error::new(
+                input.span(),
+                "LuaDiagnosticMacro only supports enums"
+            )
+            .to_compile_error()
+            .into();
+        }
+    };
+
+    // Generate get_name / FromStr / Display / all based on variants
+    let mut variant_idents = Vec::new();
+    let mut variant_strings = Vec::new();
+
+    for variant in variants.iter() {
+        let variant_ident = &variant.ident;
+        // Handle unit variants
+        if let Fields::Unit = &variant.fields {
+            let kebab_case_string = to_kebab_case(variant_ident);
+            variant_idents.push(variant_ident);
+            variant_strings.push(kebab_case_string);
+        } else {
+            // Only unit variants are supported
+            return syn::Error::new(variant.ident.span(), "Only unit variants supported")
+                .to_compile_error()
+                .into();
+        }
+    }
+
+    // Build match arms for get_name()
+    let get_name_arms = variant_idents.iter().zip(variant_strings.iter()).map(|(ident, kc)| {
+        quote! {
+            #name::#ident => #kc
+        }
+    });
+
+    // Build match arms for FromStr
+    let from_str_arms = variant_idents.iter().zip(variant_strings.iter()).map(|(ident, kc)| {
+        quote! {
+            #kc => Ok(#name::#ident)
+        }
+    });
+
+    // Build the all() array
+    let all_variants = variant_idents.iter().map(|ident| {
+        quote! { #name::#ident }
+    });
+
+    // Generate the complete impl block
+    let expanded = quote! {
+        impl #name {
+            pub fn get_name(&self) -> &str {
+                match self {
+                    #(#get_name_arms),*,
+                    _ => "none"
+                }
+            }
+
+            // Return all variants
+            pub fn all() -> Vec<#name> {
+                vec![
+                    #(#all_variants),*
+                ]
+            }
+        }
+
+        impl ::std::str::FromStr for #name {
+            type Err = ();
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    #(#from_str_arms),*,
+                    _ => Ok(#name::None),
+                }
+            }
+        }
+
+        impl ::std::fmt::Display for #name {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                write!(f, "{}", self.get_name())
+            }
+        }
+    };
+
+    expanded.into()
+}

crates/diagnostic_macro/src/lib.rs

@@ -0,0 +1,128 @@
+use std::collections::HashSet;
+
+use code_analysis::DiagnosticCode;
+use emmylua_parser::{
+    LuaAstNode, LuaClosureExpr, LuaComment, LuaDocTagParam, LuaSyntaxKind,
+    LuaTokenKind,
+};
+use lsp_types::CompletionItem;
+
+use crate::handlers::completion::completion_builder::CompletionBuilder;
+
+pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
+    if builder.is_cancelled() {
+        return None;
+    }
+
+    let trigger_token = &builder.trigger_token;
+    if !matches!(trigger_token.kind().into(), LuaTokenKind::TkName) {
+        return None;
+    }
+
+    let parent_node = trigger_token.parent()?;
+    match parent_node.kind().into() {
+        LuaSyntaxKind::DocTagParam => {
+            add_tag_param_name_completion(builder, LuaDocTagParam::cast(parent_node)?);
+        }
+        LuaSyntaxKind::DocTagCast => {
+            add_tag_cast_name_completion(builder);
+        }
+        LuaSyntaxKind::DocTagDiagnostic => {
+            add_tag_diagnostic_action_completion(builder);
+        }
+        LuaSyntaxKind::DocDiagnosticCodeList => {
+            add_tag_diagnostic_code_completion(builder);
+        }
+        _ => {}
+    }
+
+    builder.stop_here();
+
+    Some(())
+}
+
+fn add_tag_param_name_completion(
+    builder: &mut CompletionBuilder,
+    node: LuaDocTagParam,
+) -> Option<()> {
+    let comment = node.ancestors::<LuaComment>().next()?;
+    let owner = comment.get_owner()?;
+    let closure = owner.descendants::<LuaClosureExpr>().next()?;
+    let params = closure.get_params_list()?.get_params();
+    for param in params {
+        let completion_item = CompletionItem {
+            label: param.get_name_token()?.get_name_text().to_string(),
+            kind: Some(lsp_types::CompletionItemKind::VARIABLE),
+            ..Default::default()
+        };
+
+        builder.add_completion_item(completion_item);
+    }
+
+    Some(())
+}
+
+fn add_tag_cast_name_completion(
+    builder: &mut CompletionBuilder,
+) -> Option<()> {
+    let file_id = builder.semantic_model.get_file_id();
+    let decl_tree = builder
+        .semantic_model
+        .get_db()
+        .get_decl_index()
+        .get_decl_tree(&file_id)?;
+    let mut duplicated_name = HashSet::new();
+    let local_env = decl_tree.get_env_decls(builder.trigger_token.text_range().start())?;
+    for decl_id in local_env.iter() {
+        let name = {
+            let decl = builder
+                .semantic_model
+                .get_db()
+                .get_decl_index()
+                .get_decl(&decl_id)?;
+            
+            decl.get_name().to_string()
+        };
+        if duplicated_name.contains(&name) {
+            continue;
+        }
+
+        duplicated_name.insert(name.clone());
+        let completion_item = CompletionItem {
+            label: name,
+            kind: Some(lsp_types::CompletionItemKind::VARIABLE),
+            ..Default::default()
+        };
+        builder.add_completion_item(completion_item);
+    }
+
+    Some(())
+}
+
+fn add_tag_diagnostic_action_completion(builder: &mut CompletionBuilder) {
+    let actions = vec!["disable", "disable-next-line"];
+    for (sorted_index, action) in actions.iter().enumerate() {
+        let completion_item = CompletionItem {
+            label: action.to_string(),
+            kind: Some(lsp_types::CompletionItemKind::EVENT),
+            sort_text: Some(format!("{:03}", sorted_index)),
+            ..Default::default()
+        };
+
+        builder.add_completion_item(completion_item);
+    }
+}
+
+fn add_tag_diagnostic_code_completion(builder: &mut CompletionBuilder) {
+    let codes = DiagnosticCode::all();
+    for (sorted_index, code) in codes.iter().enumerate() {
+        let completion_item = CompletionItem {
+            label: code.get_name().to_string(),
+            kind: Some(lsp_types::CompletionItemKind::EVENT),
+            sort_text: Some(format!("{:03}", sorted_index)),
+            ..Default::default()
+        };
+
+        builder.add_completion_item(completion_item);
+    }
+}

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

@@ -5,6 +5,7 @@ mod file_path_provider;
 mod keywords_provider;
 mod member_provider;
 mod module_path_provider;
+mod doc_name_token_provider;
 
 use super::completion_builder::CompletionBuilder;
 
@@ -16,6 +17,7 @@ pub fn add_completions(builder: &mut CompletionBuilder) -> Option<()> {
     member_provider::add_completion(builder);
     doc_tag_provider::add_completion(builder);
     doc_type_provider::add_completion(builder);
+    doc_name_token_provider::add_completion(builder);
 
     Some(())
 }