emmylua_code_analysis 0.23.1

A library for analyzing lua code.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#[cfg(test)]
mod test {
    use std::str::FromStr;

    use lsp_types::Uri;

    use crate::{DbIndex, FileId, LuaTypeDecl, VirtualWorkspace, WorkspaceFolder, WorkspaceId};

    fn find_visible_type_decl<'a>(
        db: &'a DbIndex,
        file_id: FileId,
        name: &str,
    ) -> Option<&'a LuaTypeDecl> {
        db.get_type_index()
            .find_type_decl(file_id, name, db.resolve_workspace_id(file_id))
    }

    #[test]
    fn type_decl_visibility_comes_from_type_flags_instead_of_standalone_visibility_tags() {
        let mut ws = VirtualWorkspace::new();
        ws.analysis.add_library_workspace(&WorkspaceFolder::new(
            ws.virtual_url_generator.new_path("lib"),
            true,
        ));
        ws.def_file(
            "lib/types.lua",
            r#"
                ---@namespace Shared

                ---@internal
                ---@class TaggedInternalType
                local TaggedInternalType = {}

                ---@class PlainPublicType
                local PlainPublicType = {}

                ---@class (public) PublicType
                local PublicType = {}

                ---@class (internal) InternalType
                local InternalType = {}

                ---@class (private) PrivateType
                local PrivateType = {}
            "#,
        );
        let library_consumer = ws.def_file("lib/consumer.lua", "local value = 1");
        let consumer = ws.def_file("main.lua", "local value = 1");

        let db = ws.analysis.compilation.get_db();
        assert!(
            find_visible_type_decl(db, library_consumer, "Shared.TaggedInternalType").is_some()
        );
        assert!(find_visible_type_decl(db, library_consumer, "Shared.PlainPublicType").is_some());
        assert!(find_visible_type_decl(db, library_consumer, "Shared.PublicType").is_some());
        assert!(find_visible_type_decl(db, library_consumer, "Shared.InternalType").is_some());
        assert!(find_visible_type_decl(db, library_consumer, "Shared.PrivateType").is_none());
        assert!(find_visible_type_decl(db, consumer, "Shared.TaggedInternalType").is_some());
        assert!(find_visible_type_decl(db, consumer, "Shared.PlainPublicType").is_some());
        assert!(find_visible_type_decl(db, consumer, "Shared.PublicType").is_some());
        assert!(find_visible_type_decl(db, consumer, "Shared.InternalType").is_none());
        assert!(find_visible_type_decl(db, consumer, "Shared.PrivateType").is_none());
    }

    #[test]
    fn std_workspace_types_are_visible_without_explicit_public() {
        let mut ws = VirtualWorkspace::new();
        let std_root = ws.virtual_url_generator.new_path("std");
        ws.analysis
            .compilation
            .get_db_mut()
            .get_module_index_mut()
            .add_workspace_root(std_root, WorkspaceId::STD);
        ws.def_file(
            "std/types.lua",
            r#"
                ---@namespace Shared
                ---@class StdType
                local StdType = {}
            "#,
        );
        let consumer = ws.def_file("main.lua", "local value = 1");

        let db = ws.analysis.compilation.get_db();
        assert!(find_visible_type_decl(db, consumer, "Shared.StdType").is_some());
    }

    #[test]
    fn remote_workspace_types_are_visible_without_explicit_public() {
        let mut ws = VirtualWorkspace::new();
        ws.analysis.update_remote_file_by_uri(
            &Uri::from_str("https://example.com/remote-types.lua").unwrap(),
            Some(
                r#"
                    ---@namespace Shared
                    ---@class RemoteType
                    local RemoteType = {}
                "#
                .to_string(),
            ),
        );
        let consumer = ws.def_file("main.lua", "local value = 1");

        let db = ws.analysis.compilation.get_db();
        assert!(find_visible_type_decl(db, consumer, "Shared.RemoteType").is_some());
    }
}