add unused check

Author: CppCXY

crates/code_analysis/src/db_index/declaration/decl_tree.rs

@@ -312,6 +312,10 @@ impl LuaDeclarationTree {
     pub fn get_scope(&self, scope_id: &LuaScopeId) -> Option<&LuaScope> {
         self.scopes.get(scope_id.id as usize)
     }
+
+    pub fn get_decls(&self) -> &HashMap<LuaDeclId, LuaDecl> {
+        &self.decls
+    }
 }
 
 #[derive(Debug)]

crates/code_analysis/src/diagnostic/checker/analyze_error.rs

@@ -1,10 +1,10 @@
-use crate::DiagnosticCode;
+use crate::{DiagnosticCode, SemanticModel};
 
 use super::DiagnosticContext;
 
 pub const CODES: &[DiagnosticCode] = &[DiagnosticCode::TypeNotFound, DiagnosticCode::DuplicateType];
 
-pub fn check(context: &mut DiagnosticContext) -> Option<()> {
+pub fn check(context: &mut DiagnosticContext, _: &SemanticModel) -> Option<()> {
     let db = context.get_db();
     let file_id = context.get_file_id();
     let diagnostic_index = db.get_diagnostic_index();

crates/code_analysis/src/diagnostic/checker/depreacated.rs

@@ -1,5 +1,7 @@
 mod analyze_error;
 mod syntax_error;
+mod unused;
+mod depreacated;
 
 use lsp_types::{Diagnostic, DiagnosticSeverity, DiagnosticTag, NumberOrString};
 use rowan::TextRange;
@@ -12,51 +14,55 @@ use super::{
     DiagnosticCode,
 };
 
-pub fn check_file(context: &mut DiagnosticContext) -> Option<()> {
+pub fn check_file(context: &mut DiagnosticContext, semantic_model:&mut SemanticModel) -> Option<()> {
     macro_rules! check {
         ($module:ident) => {
             if $module::CODES
                 .iter()
                 .any(|code| context.is_checker_enable_by_code(code))
             {
-                $module::check(context);
+                $module::check(context, semantic_model);
             }
         };
     }
 
     check!(syntax_error);
     check!(analyze_error);
+    check!(unused);
 
     Some(())
 }
 
 pub struct DiagnosticContext<'a> {
-    semantic_model: SemanticModel<'a>,
+    file_id: FileId,
+    db: &'a DbIndex,
     diagnostics: Vec<Diagnostic>,
     workspace_enabled: Arc<HashSet<DiagnosticCode>>,
     workspace_disabled: Arc<HashSet<DiagnosticCode>>,
 }
 
 impl<'a> DiagnosticContext<'a> {
     pub fn new(
-        semantic_model: SemanticModel<'a>,
+        file_id: FileId,
+        db: &'a DbIndex,
         workspace_enabled: Arc<HashSet<DiagnosticCode>>,
         workspace_disabled: Arc<HashSet<DiagnosticCode>>,
     ) -> Self {
         Self {
-            semantic_model,
+            file_id,
+            db,
             diagnostics: Vec::new(),
             workspace_disabled,
             workspace_enabled,
         }
     }
 
     pub fn get_db(&self) -> &DbIndex {
-        &self.semantic_model.get_db()
+        &self.db
     }
 
     pub fn get_file_id(&self) -> FileId {
-        self.semantic_model.get_file_id()
+        self.file_id
     }
 
     pub fn add_diagnostic(
@@ -118,7 +124,7 @@ impl<'a> DiagnosticContext<'a> {
     }
 
     fn translate_range(&self, range: TextRange) -> Option<lsp_types::Range> {
-        let document = self.semantic_model.get_document();
+        let document = self.db.get_vfs().get_document(&self.file_id)?;
         let (start_line, start_character) = document.get_line_col(range.start())?;
         let (end_line, end_character) = document.get_line_col(range.end())?;
 

crates/code_analysis/src/diagnostic/checker/mod.rs

@@ -1,11 +1,10 @@
-use crate::DiagnosticCode;
+use crate::{DiagnosticCode, SemanticModel};
 
 use super::DiagnosticContext;
 
 pub const CODES: &[DiagnosticCode] = &[DiagnosticCode::SyntaxError];
 
-pub fn check(context: &mut DiagnosticContext) -> Option<()> {
-    let semantic_model = &context.semantic_model;
+pub fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) -> Option<()> {
     if let Some(parse_errors) = semantic_model.get_file_parse_error() {
         for parse_error in parse_errors {
             context.add_diagnostic(

crates/code_analysis/src/diagnostic/checker/syntax_error.rs

@@ -0,0 +1,49 @@
+use crate::{DiagnosticCode, LuaDecl, LuaReferenceIndex, SemanticModel};
+
+use super::DiagnosticContext;
+
+pub const CODES: &[DiagnosticCode] = &[DiagnosticCode::Unused];
+
+pub fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) -> Option<()> {
+    let file_id = semantic_model.get_file_id();
+    let decl_tree = semantic_model
+        .get_db()
+        .get_decl_index()
+        .get_decl_tree(&file_id)?;
+
+    let ref_index = semantic_model.get_db().get_reference_index();
+    for (_, decl) in decl_tree.get_decls().iter() {
+        if !is_decl_used(decl, ref_index) {
+            let name = decl.get_name();
+            if name.starts_with('_') {
+                continue;
+            }
+            context.add_diagnostic(
+                DiagnosticCode::Unused,
+                decl.get_range(),
+                format!(
+                    "{0} is never used, if this is intentional, prefix it with an underscore: _{0}",
+                    name
+                ),
+                None,
+            );
+        }
+    }
+
+    Some(())
+}
+
+fn is_decl_used(decl: &LuaDecl, local_refs: &LuaReferenceIndex) -> bool {
+    if decl.is_global() {
+        return true;
+    } else if decl.is_param() && decl.get_name() == "..." {
+        return true;
+    }
+
+    let file_id = decl.get_file_id();
+    if let Some(refs) = local_refs.get_local_references(&file_id, &decl.get_id()) {
+        return !refs.is_empty();
+    }
+
+    false
+}

crates/code_analysis/src/diagnostic/checker/unused.rs

@@ -42,14 +42,16 @@ impl LuaDiagnostic {
             return None;
         }
 
-        let model = compilation.get_semantic_model(file_id)?;
+        let db = compilation.get_db();
+        let mut semantic_model = compilation.get_semantic_model(file_id)?;
         let mut context = DiagnosticContext::new(
-            model,
+            file_id,
+            db,
             self.workspace_enabled.clone(),
             self.workspace_disabled.clone(),
         );
 
-        check_file(&mut context);
+        check_file(&mut context, &mut semantic_model);
 
         Some(context.get_diagnostics())
     }