add access visiblity check

Author: CppCXY

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

@@ -0,0 +1,135 @@
+use emmylua_parser::{LuaAst, LuaAstNode, LuaAstToken, LuaIndexExpr, LuaNameExpr, VisibilityKind};
+use rowan::TextRange;
+
+use crate::{DiagnosticCode, Emmyrc, LuaPropertyOwnerId, SemanticModel};
+
+use super::DiagnosticContext;
+
+pub const CODES: &[DiagnosticCode] = &[DiagnosticCode::AccessInvisible];
+
+pub fn check(context: &mut DiagnosticContext, semantic_model: &mut SemanticModel) -> Option<()> {
+    let file_id = semantic_model.get_file_id();
+    let root = semantic_model.get_root().clone();
+    for node in root.descendants::<LuaAst>() {
+        match node {
+            LuaAst::LuaNameExpr(name_expr) => {
+                if semantic_model
+                    .get_db()
+                    .get_reference_index()
+                    .is_write_range(file_id, name_expr.get_range())
+                {
+                    continue;
+                }
+                check_name_expr(context, semantic_model, name_expr);
+            }
+            LuaAst::LuaIndexExpr(index_expr) => {
+                if semantic_model
+                    .get_db()
+                    .get_reference_index()
+                    .is_write_range(file_id, index_expr.get_range())
+                {
+                    continue;
+                }
+                check_index_expr(context, semantic_model, index_expr);
+            }
+            _ => {}
+        }
+    }
+
+    Some(())
+}
+
+fn check_name_expr(
+    context: &mut DiagnosticContext,
+    semantic_model: &mut SemanticModel,
+    name_expr: LuaNameExpr,
+) -> Option<()> {
+    let property_owner = semantic_model
+        .get_property_owner_id(rowan::NodeOrToken::Node(name_expr.syntax().clone()))?;
+
+    let name_token = name_expr.get_name_token()?;
+    if !semantic_model.is_property_visiable(name_token.syntax().clone(), property_owner.clone()) {
+        let emmyrc = semantic_model.get_emmyrc();
+        report_reson(context, &emmyrc, name_token.get_range(), property_owner);
+    }
+    Some(())
+}
+
+fn check_index_expr(
+    context: &mut DiagnosticContext,
+    semantic_model: &mut SemanticModel,
+    index_expr: LuaIndexExpr,
+) -> Option<()> {
+    let property_owner = semantic_model
+        .get_property_owner_id(rowan::NodeOrToken::Node(index_expr.syntax().clone()))?;
+
+    let index_token = index_expr.get_index_name_token()?;
+    if !semantic_model.is_property_visiable(index_token.clone(), property_owner.clone()) {
+        let emmyrc = semantic_model.get_emmyrc();
+        report_reson(context, &emmyrc, index_token.text_range(), property_owner);
+    }
+
+    Some(())
+}
+
+fn report_reson(
+    context: &mut DiagnosticContext,
+    emmyrc: &Emmyrc,
+    range: TextRange,
+    property_owner_id: LuaPropertyOwnerId,
+) -> Option<()> {
+    let property = context
+        .db
+        .get_property_index()
+        .get_property(property_owner_id)?;
+
+    if let Some(version_conds) = &property.version_conds {
+        let version_number = emmyrc.runtime.version.to_lua_version_number();
+        let visiable = version_conds.iter().any(|cond| cond.check(&version_number));
+        if !visiable {
+            let message = t!(
+                "The current Lua version %{version} is not accessible; expected %{conds}.",
+                version = version_number,
+                conds = version_conds
+                    .iter()
+                    .map(|it| format!("{}", it))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            );
+
+            context.add_diagnostic(
+                DiagnosticCode::AccessInvisible,
+                range,
+                message.to_string(),
+                None,
+            );
+            return Some(());
+        }
+    }
+
+    if let Some(visiblity) = property.visibility {
+        let message = match visiblity {
+            VisibilityKind::Protected => {
+                t!("The property is protected and cannot be accessed outside its subclasses.")
+            }
+            VisibilityKind::Private => {
+                t!("The property is private and cannot be accessed outside the class.")
+            }
+            VisibilityKind::Package => {
+                t!("The property is package-private and cannot be accessed outside the package.")
+            }
+            _ => {
+                return None;
+            }
+        };
+
+        context.add_diagnostic(
+            DiagnosticCode::AccessInvisible,
+            range,
+            message.to_string(),
+            None,
+        );
+    }
+
+    Some(())
+}

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

@@ -3,6 +3,7 @@ mod syntax_error;
 mod unused;
 mod deprecated;
 mod undefined_global;
+mod access_invisible;
 
 use lsp_types::{Diagnostic, DiagnosticSeverity, DiagnosticTag, NumberOrString};
 use rowan::TextRange;
@@ -32,6 +33,7 @@ pub fn check_file(context: &mut DiagnosticContext, semantic_model:&mut SemanticM
     check!(unused);
     check!(deprecated);
     check!(undefined_global);
+    check!(access_invisible);
 
     Some(())
 }

crates/code_analysis/src/diagnostic/lua_diagnostic_code.rs

@@ -28,8 +28,8 @@ pub enum DiagnosticCode {
     UndefinedGlobal,
     /// Deprecated
     Deprecated,
-    /// Access invisible member
-    AccessInvisibleMember,
+    /// Access invisible
+    AccessInvisible,
     /// Discard return value
     DiscardReturns,
     /// Disable global define
@@ -70,7 +70,7 @@ pub fn get_default_severity(code: DiagnosticCode) -> DiagnosticSeverity {
         DiagnosticCode::Unused => DiagnosticSeverity::HINT,
         DiagnosticCode::UndefinedGlobal => DiagnosticSeverity::ERROR,
         DiagnosticCode::Deprecated => DiagnosticSeverity::HINT,
-        DiagnosticCode::AccessInvisibleMember => DiagnosticSeverity::WARNING,
+        DiagnosticCode::AccessInvisible => DiagnosticSeverity::WARNING,
         DiagnosticCode::DiscardReturns => DiagnosticSeverity::WARNING,
         DiagnosticCode::DisableGlobalDefine => DiagnosticSeverity::ERROR,
         DiagnosticCode::UndefinedField => DiagnosticSeverity::WARNING,

crates/emmylua_parser/src/kind/lua_version.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LuaVersionNumber {
     pub major: u32,
@@ -54,6 +56,15 @@ impl Ord for LuaVersionNumber {
     }
 }
 
+impl fmt::Display for LuaVersionNumber {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            LuaVersionNumber::LUA_JIT => write!(f, "Lua JIT"),
+            LuaVersionNumber { major, minor, .. } => write!(f, "Lua {}.{}", major, minor),
+        }
+    }
+}
+
 #[allow(unused)]
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum LuaVersionCondition {
@@ -71,4 +82,14 @@ impl LuaVersionCondition {
             LuaVersionCondition::Lte(v) => version <= v,
         }
     }
+}
+
+impl fmt::Display for LuaVersionCondition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LuaVersionCondition::Eq(v) => write!(f, "{}", v),
+            LuaVersionCondition::Gte(v) => write!(f, ">= {}", v),
+            LuaVersionCondition::Lte(v) => write!(f, "<= {}", v),
+        }
+    }
 }