wat_service 0.10.2

WebAssembly Text Format language service.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::{LanguageService, uri::InternUri};
use serde::{Deserialize, Serialize};
use std::sync::Arc;

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(default)]
/// Language service configuration. This can be different for each document.
pub struct ServiceConfig {
    /// Configuration about formatting.
    pub format: wat_formatter::config::LanguageOptions,
    /// Configuration about linting.
    pub lint: Lints,
    #[serde(alias = "inlayHint")]
    /// Configuration about inlay hints.
    pub inlay_hint: InlayHintOptions,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default)]
/// Configuration about linting.
pub struct Lints {
    /// Lint for detecting unused items.
    pub unused: LintLevel,

    /// Lint for detecting unread locals.
    pub unread: LintLevel,

    /// Lint for detecting shadowing.
    pub shadow: LintLevel,

    #[serde(alias = "implicitModule")]
    /// Lint for top-level module fields without declaring a module.
    pub implicit_module: LintLevel,

    #[serde(alias = "multiModules")]
    /// Lint for detecting multiple modules in a single file.
    pub multi_modules: LintLevel,

    /// Lint for detecting unreachable code.
    pub unreachable: LintLevel,

    /// Lint for deprecated usage.
    pub deprecated: LintLevel,

    #[serde(alias = "needlessMut")]
    /// Lint for detecting mutable globals that are never mutated.
    pub needless_mut: LintLevel,

    #[serde(alias = "needlessTryTable")]
    /// Lint for detecting `try_table` block without catch clauses.
    pub needless_try_table: LintLevel,

    #[serde(alias = "uselessCatch")]
    /// Lint for detecting useless catch clauses.
    pub useless_catch: LintLevel,
}

impl Default for Lints {
    fn default() -> Self {
        Self {
            unused: LintLevel::Warn,
            unread: LintLevel::Warn,
            shadow: LintLevel::Warn,
            implicit_module: LintLevel::Allow,
            multi_modules: LintLevel::Deny,
            unreachable: LintLevel::Hint,
            deprecated: LintLevel::Warn,
            needless_mut: LintLevel::Warn,
            needless_try_table: LintLevel::Warn,
            useless_catch: LintLevel::Warn,
        }
    }
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
/// Severity level when lint reports.
pub enum LintLevel {
    #[serde(alias = "allow")]
    Allow,
    #[serde(alias = "hint")]
    Hint,
    #[serde(alias = "warn")]
    Warn,
    #[serde(alias = "deny")]
    Deny,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default)]
/// Configuration about inlay hints.
pub struct InlayHintOptions {
    /// Inlay hints for indicating types.
    pub types: bool,

    /// Inlay hints that show at the end of blocks and functions.
    pub ending: bool,

    /// Inlay hints for showing idx.
    pub index: bool,
}

impl Default for InlayHintOptions {
    fn default() -> Self {
        Self {
            types: true,
            ending: true,
            index: true,
        }
    }
}

#[derive(Debug)]
pub(crate) enum ConfigState {
    Inherit,
    Override(ServiceConfig),
}
impl ConfigState {
    pub fn unwrap_or_global<'a>(&'a self, service: &'a LanguageService) -> &'a ServiceConfig {
        match self {
            ConfigState::Inherit => &service.global_config,
            ConfigState::Override(config) => config,
        }
    }
}

impl LanguageService {
    #[inline]
    /// Update or insert configuration of a specific document.
    ///
    /// Set `config` to `None` to inherit global configuration.
    pub fn set_config(&mut self, uri: impl AsRef<str>, config: Option<ServiceConfig>) {
        self.configs.write().insert(
            InternUri::new(self, uri.as_ref()),
            config.map_or(ConfigState::Inherit, ConfigState::Override),
        );
    }

    #[inline]
    /// Update global configuration.
    pub fn set_global_config(&mut self, config: ServiceConfig) {
        self.global_config = Arc::new(config);
    }
}