support basic visible check for code completion

Author: CppCXY

.vscode/launch.json

@@ -20,7 +20,12 @@
                 }
             },
             "args": [
-                "--port", "5007"
+                "-c",
+                "tcp",
+                "--port",
+                "5007",
+                "--log-level",
+                "debug"
             ],
             "cwd": "${workspaceFolder}"
         },

crates/code_analysis/src/semantic/mod.rs

@@ -139,11 +139,19 @@ impl<'a> SemanticModel<'a> {
     }
 
     pub fn is_property_visiable(
-        &self,
+        &mut self,
         token: LuaSyntaxToken,
         property_owner: LuaPropertyOwnerId,
     ) -> bool {
-        check_visibility(self.db, self.file_id, &self.emmyrc, token, property_owner).unwrap_or(true)
+        check_visibility(
+            self.db,
+            self.file_id,
+            &self.emmyrc,
+            &mut self.infer_config,
+            token,
+            property_owner,
+        )
+        .unwrap_or(true)
     }
 
     pub fn get_emmyrc(&self) -> &Emmyrc {

crates/code_analysis/src/semantic/visibility/mod.rs

@@ -1,11 +1,17 @@
-use emmylua_parser::{LuaSyntaxToken, VisibilityKind};
+use emmylua_parser::{
+    LuaAstNode, LuaAstToken, LuaBlock, LuaClosureExpr, LuaFuncStat, LuaGeneralToken,
+    LuaSyntaxToken, LuaVarExpr, VisibilityKind,
+};
 
-use crate::{DbIndex, Emmyrc, FileId, LuaPropertyOwnerId};
+use crate::{DbIndex, Emmyrc, FileId, LuaMemberOwner, LuaPropertyOwnerId, LuaType};
+
+use super::{infer_expr, LuaInferConfig};
 
 pub fn check_visibility(
     db: &DbIndex,
     file_id: FileId,
     emmyrc: &Emmyrc,
+    infer_config: &mut LuaInferConfig,
     token: LuaSyntaxToken,
     property_owner: LuaPropertyOwnerId,
 ) -> Option<bool> {
@@ -26,15 +32,84 @@ pub fn check_visibility(
             // this donot use
             VisibilityKind::Internal |
             VisibilityKind::Public => return Some(true),
-            VisibilityKind::Protected => todo!(),
-            VisibilityKind::Private => todo!(),
+            VisibilityKind::Protected |
+            VisibilityKind::Private => {
+                return Some(check_visibility_by_visibility(db, infer_config, property_owner, token, visibility).unwrap_or(false));
+            },
             VisibilityKind::Package => {
                 return Some(file_id == property_owner.get_file_id()?);
             },
         }
+    }
+
+    Some(true)
+}
+
+fn check_visibility_by_visibility(
+    db: &DbIndex,
+    infer_config: &mut LuaInferConfig,
+    property_owner: LuaPropertyOwnerId,
+    token: LuaSyntaxToken,
+    visibility: VisibilityKind,
+) -> Option<bool> {
+    let member_owner = match property_owner {
+        LuaPropertyOwnerId::Member(member_id) => {
+            db.get_member_index().get_member(&member_id)?.get_owner()
+        }
+        _ => return Some(true),
+    };
 
+    let token = LuaGeneralToken::cast(token)?;
+    let blocks = token.ancestors::<LuaBlock>();
+    for block in blocks {
+        if check_block_visibility(db, infer_config, &member_owner, block, visibility)
+            .unwrap_or(false)
+        {
+            return Some(true);
+        }
     }
- 
+
     Some(false)
 }
 
+fn check_block_visibility(
+    db: &DbIndex,
+    infer_config: &mut LuaInferConfig,
+    member_owner: &LuaMemberOwner,
+    block: LuaBlock,
+    visibility: VisibilityKind,
+) -> Option<bool> {
+    let func_stat = block
+        .get_parent::<LuaClosureExpr>()?
+        .get_parent::<LuaFuncStat>()?;
+
+    let func_name = func_stat.get_func_name()?;
+    if let LuaVarExpr::IndexExpr(index_expr) = func_name {
+        let prefix_expr = index_expr.get_prefix_expr()?;
+        let typ = infer_expr(db, infer_config, prefix_expr.into())?;
+        if visibility == VisibilityKind::Protected {
+            match (typ, member_owner) {
+                (LuaType::Def(left), LuaMemberOwner::Type(right)) => {
+                    if left == *right {
+                        return Some(true);
+                    }
+
+                    // todo is subclass
+                }
+                _ => {}
+            }
+        } else if visibility == VisibilityKind::Private {
+            match (typ, member_owner) {
+                (LuaType::Def(left), LuaMemberOwner::Type(right)) => {
+                    return Some(left == *right);
+                }
+                (LuaType::TableConst(left), LuaMemberOwner::Element(right)) => {
+                    return Some(left == *right);
+                }
+                _ => {}
+            }
+        }
+    }
+
+    Some(false)
+}

crates/emmylua_ls/src/handlers/completion/add_completions/mod.rs

@@ -12,7 +12,7 @@ use crate::util::humanize_type;
 
 use super::completion_builder::CompletionBuilder;
 
-fn check_visibility(builder: &CompletionBuilder, id: LuaPropertyOwnerId) -> Option<()> {
+fn check_visibility(builder: &mut CompletionBuilder, id: LuaPropertyOwnerId) -> Option<()> {
     match id {
         LuaPropertyOwnerId::Member(_) => {}
         LuaPropertyOwnerId::LuaDecl(_) => {}

crates/emmylua_parser/src/grammar/doc/test.rs

@@ -1849,7 +1849,50 @@ Syntax(Chunk)@0..74
     Token(TkEndOfLine)@65..66 "\n"
     Token(TkWhitespace)@66..74 "        "
         "#;
-        
+
+        assert_ast_eq!(code, result);
+    }
+
+    #[test]
+    fn test_visiblity() {
+        let code = r#"
+        ---@private
+        ---@public
+        ---@package
+        ---@protected
+        "#;
+
+        let result = r#"
+Syntax(Chunk)@0..90
+  Syntax(Block)@0..90
+    Token(TkEndOfLine)@0..1 "\n"
+    Token(TkWhitespace)@1..9 "        "
+    Syntax(Comment)@9..81
+      Token(TkDocStart)@9..13 "---@"
+      Syntax(DocTagVisibility)@13..29
+        Token(TkTagVisibility)@13..20 "private"
+        Token(TkEndOfLine)@20..21 "\n"
+        Token(TkWhitespace)@21..29 "        "
+        Syntax(DocDescription)@29..29
+      Token(TkDocStart)@29..33 "---@"
+      Syntax(DocTagVisibility)@33..48
+        Token(TkTagVisibility)@33..39 "public"
+        Token(TkEndOfLine)@39..40 "\n"
+        Token(TkWhitespace)@40..48 "        "
+        Syntax(DocDescription)@48..48
+      Token(TkDocStart)@48..52 "---@"
+      Syntax(DocTagVisibility)@52..68
+        Token(TkTagVisibility)@52..59 "package"
+        Token(TkEndOfLine)@59..60 "\n"
+        Token(TkWhitespace)@60..68 "        "
+        Syntax(DocDescription)@68..68
+      Token(TkDocStart)@68..72 "---@"
+      Syntax(DocTagVisibility)@72..81
+        Token(TkTagVisibility)@72..81 "protected"
+    Token(TkEndOfLine)@81..82 "\n"
+    Token(TkWhitespace)@82..90 "        "
+        "#;
+
         assert_ast_eq!(code, result);
     }
 }

crates/emmylua_parser/src/syntax/node/token/tokens.rs

@@ -1,5 +1,8 @@
 use crate::{
-    kind::{BinaryOperator, LuaTokenKind, UnaryOperator}, syntax::traits::LuaAstToken, LuaOpKind, LuaSyntaxToken, LuaTypeBinaryOperator, LuaTypeUnaryOperator, LuaVersionNumber, VisibilityKind
+    kind::{BinaryOperator, LuaTokenKind, UnaryOperator},
+    syntax::traits::LuaAstToken,
+    LuaOpKind, LuaSyntaxToken, LuaTypeBinaryOperator, LuaTypeUnaryOperator, LuaVersionNumber,
+    VisibilityKind,
 };
 
 use super::{float_token_value, int_token_value, string_token_value};
@@ -534,7 +537,7 @@ impl LuaAstToken for LuaDocVisibilityToken {
     where
         Self: Sized,
     {
-        kind == LuaTokenKind::TkDocVisibility
+        kind == LuaTokenKind::TkDocVisibility || kind == LuaTokenKind::TkTagVisibility
     }
 
     fn cast(syntax: LuaSyntaxToken) -> Option<Self>
@@ -699,4 +702,4 @@ impl LuaPathToken {
             text
         }
     }
-}
+}