basic support readonly

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/doc/property_tags.rs

@@ -1,6 +1,6 @@
 use crate::{
     AsyncState, LuaDeclId, LuaExport, LuaExportScope, LuaNoDiscard, LuaSemanticDeclId,
-    LuaSignatureId,
+    LuaSignatureId, PropertyDeclFeature,
 };
 
 use super::{
@@ -10,8 +10,8 @@ use super::{
 use crate::compilation::analyzer::doc::tags::report_orphan_tag;
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaDocDescriptionOwner, LuaDocTagAsync, LuaDocTagDeprecated,
-    LuaDocTagExport, LuaDocTagNodiscard, LuaDocTagSource, LuaDocTagVersion, LuaDocTagVisibility,
-    LuaTableExpr,
+    LuaDocTagExport, LuaDocTagNodiscard, LuaDocTagReadonly, LuaDocTagSource, LuaDocTagVersion,
+    LuaDocTagVisibility, LuaTableExpr,
 };
 
 pub fn analyze_visibility(
@@ -151,3 +151,15 @@ pub fn analyze_export(analyzer: &mut DocAnalyzer, tag: LuaDocTagExport) -> Optio
 
     Some(())
 }
+
+pub fn analyze_readonly(analyzer: &mut DocAnalyzer, readonly: LuaDocTagReadonly) -> Option<()> {
+    let owner_id = get_owner_id_or_report(analyzer, &readonly)?;
+
+    analyzer.db.get_property_index_mut().add_decl_feature(
+        analyzer.file_id,
+        owner_id,
+        PropertyDeclFeature::ReadOnly,
+    );
+
+    Some(())
+}

crates/emmylua_code_analysis/src/compilation/analyzer/doc/tags.rs

@@ -4,6 +4,7 @@ use emmylua_parser::{
 
 use crate::{
     AnalyzeError, DiagnosticCode, LuaDeclId,
+    compilation::analyzer::doc::property_tags::analyze_readonly,
     db_index::{LuaMemberId, LuaSemanticDeclId, LuaSignatureId},
 };
 
@@ -107,6 +108,9 @@ pub fn analyze_tag(analyzer: &mut DocAnalyzer, tag: LuaDocTag) -> Option<()> {
         LuaDocTag::Export(export) => {
             analyze_export(analyzer, export)?;
         }
+        LuaDocTag::Readonly(readonly) => {
+            analyze_readonly(analyzer, readonly)?;
+        }
         _ => {}
     }
 

crates/emmylua_code_analysis/src/db_index/property/decl_feature.rs

@@ -0,0 +1,22 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(u32)]
+pub enum PropertyDeclFeature {
+    ReadOnly = 1 << 0,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DeclFeatureFlag(u32);
+
+impl DeclFeatureFlag {
+    pub fn new() -> Self {
+        Self(0)
+    }
+
+    pub fn add_feature(&mut self, feature: PropertyDeclFeature) {
+        self.0 |= feature as u32;
+    }
+
+    pub fn has_feature(&self, feature: PropertyDeclFeature) -> bool {
+        (self.0 & (feature as u32)) != 0
+    }
+}

crates/emmylua_code_analysis/src/db_index/property/mod.rs

@@ -1,8 +1,10 @@
+mod decl_feature;
 #[allow(clippy::module_inception)]
 mod property;
 
 use std::collections::{HashMap, HashSet};
 
+pub use decl_feature::{DeclFeatureFlag, PropertyDeclFeature};
 use emmylua_parser::{LuaAstNode, LuaDocTagField, LuaDocType, LuaVersionCondition, VisibilityKind};
 pub use property::LuaCommonProperty;
 pub use property::{LuaDeprecated, LuaExport, LuaExportScope, LuaPropertyId};
@@ -215,6 +217,23 @@ impl LuaPropertyIndex {
         Some(())
     }
 
+    pub fn add_decl_feature(
+        &mut self,
+        file_id: FileId,
+        owner_id: LuaSemanticDeclId,
+        feature: PropertyDeclFeature,
+    ) -> Option<()> {
+        let (property, _) = self.get_or_create_property(owner_id.clone())?;
+        property.add_decl_feature(feature);
+
+        self.in_filed_owner
+            .entry(file_id)
+            .or_default()
+            .insert(owner_id);
+
+        Some(())
+    }
+
     pub fn get_property(&self, owner_id: &LuaSemanticDeclId) -> Option<&LuaCommonProperty> {
         self.property_owners_map
             .get(owner_id)

crates/emmylua_code_analysis/src/db_index/property/property.rs

@@ -1,5 +1,7 @@
 use emmylua_parser::{LuaVersionCondition, VisibilityKind};
 
+use crate::db_index::property::decl_feature::{DeclFeatureFlag, PropertyDeclFeature};
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct LuaCommonProperty {
     pub visibility: VisibilityKind,
@@ -9,6 +11,7 @@ pub struct LuaCommonProperty {
     pub version_conds: Option<Box<Vec<LuaVersionCondition>>>,
     pub tag_content: Option<Box<LuaTagContent>>,
     pub export: Option<LuaExport>,
+    pub decl_features: DeclFeatureFlag,
 }
 
 impl Default for LuaCommonProperty {
@@ -27,6 +30,7 @@ impl LuaCommonProperty {
             version_conds: None,
             tag_content: None,
             export: None,
+            decl_features: DeclFeatureFlag::new(),
         }
     }
 
@@ -82,6 +86,10 @@ impl LuaCommonProperty {
     pub fn add_extra_export(&mut self, export: LuaExport) {
         self.export = Some(export);
     }
+
+    pub fn add_decl_feature(&mut self, feature: PropertyDeclFeature) {
+        self.decl_features.add_feature(feature);
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

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

@@ -22,6 +22,7 @@ mod local_const_reassign;
 mod missing_fields;
 mod need_check_nil;
 mod param_type_check;
+mod readonly_check;
 mod redefined_local;
 mod require_module_visibility;
 mod return_type_mismatch;
@@ -118,6 +119,7 @@ pub fn check_file(context: &mut DiagnosticContext, semantic_model: &SemanticMode
         context,
         semantic_model,
     );
+    run_check::<readonly_check::ReadOnlyChecker>(context, semantic_model);
     Some(())
 }
 

crates/emmylua_code_analysis/src/diagnostic/checker/readonly_check.rs

@@ -0,0 +1,89 @@
+use emmylua_parser::{LuaAssignStat, LuaAst, LuaAstNode, LuaVarExpr};
+use rowan::{NodeOrToken, TextRange};
+
+use crate::{
+    DiagnosticCode, LuaSemanticDeclId, PropertyDeclFeature, SemanticDeclLevel, SemanticModel,
+};
+
+use super::{Checker, DiagnosticContext};
+
+pub struct ReadOnlyChecker;
+
+impl Checker for ReadOnlyChecker {
+    const CODES: &[DiagnosticCode] = &[DiagnosticCode::ReadOnly];
+
+    fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
+        let root = semantic_model.get_root().clone();
+        for ast_node in root.descendants::<LuaAst>() {
+            match ast_node {
+                LuaAst::LuaAssignStat(assign_stat) => {
+                    check_assignt_stat(context, semantic_model, &assign_stat);
+                }
+                // need check?
+                LuaAst::LuaFuncStat(_) => {}
+                // we need known function is readonly
+                LuaAst::LuaCallExpr(_) => {}
+                _ => {}
+            }
+        }
+    }
+}
+
+fn check_and_report_semantic_id(
+    context: &mut DiagnosticContext,
+    range: TextRange,
+    semantic_decl_id: LuaSemanticDeclId,
+) -> Option<()> {
+    // TODO filter self
+    let property_index = context.db.get_property_index();
+    if let Some(property) = property_index.get_property(&semantic_decl_id) {
+        if property
+            .decl_features
+            .has_feature(PropertyDeclFeature::ReadOnly)
+        {
+            context.add_diagnostic(
+                DiagnosticCode::ReadOnly,
+                range,
+                t!("The variable is marked as readonly and cannot be assigned to.").to_string(),
+                None,
+            );
+        }
+    }
+
+    Some(())
+}
+
+fn check_assignt_stat(
+    context: &mut DiagnosticContext,
+    semantic_model: &SemanticModel,
+    assign_stat: &LuaAssignStat,
+) -> Option<()> {
+    let (vars, _) = assign_stat.get_var_and_expr_list();
+    for var in vars {
+        let node_or_token = NodeOrToken::Node(var.syntax().clone());
+        let semantic_decl_id =
+            semantic_model.find_decl(node_or_token, SemanticDeclLevel::default());
+        if let Some(semantic_decl_id) = semantic_decl_id {
+            check_and_report_semantic_id(context, var.get_range(), semantic_decl_id);
+        }
+
+        match var {
+            LuaVarExpr::IndexExpr(index_expr) => {
+                let prefix_node = index_expr.get_prefix_expr()?;
+                let node_or_token = NodeOrToken::Node(prefix_node.syntax().clone());
+                let semantic_decl_id =
+                    semantic_model.find_decl(node_or_token, SemanticDeclLevel::default());
+                if let Some(semantic_decl_id) = semantic_decl_id {
+                    check_and_report_semantic_id(
+                        context,
+                        prefix_node.get_range(),
+                        semantic_decl_id,
+                    );
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Some(())
+}

crates/emmylua_code_analysis/src/diagnostic/lua_diagnostic_code.rs

@@ -103,6 +103,8 @@ pub enum DiagnosticCode {
     EnumValueMismatch,
     /// preferred-local-alias
     PreferredLocalAlias,
+    /// readonly
+    ReadOnly,
 
     #[serde(other)]
     None,