php_lsp/analysis/
semantic_diagnostics.rs

1/// Semantic diagnostics bridge.
2///
3/// Delegates all analysis to the `mir-analyzer` crate and converts its `Issue`
4/// type into the `tower-lsp` `Diagnostic` type expected by the LSP backend.
5use tower_lsp_server::ls_types::{
6    Diagnostic, DiagnosticSeverity, NumberOrString, Position, Range, Uri,
7};
8
9use crate::analysis::diagnostics::PHP_LSP_SOURCE;
10use crate::document::ast::ParsedDoc;
11use crate::lang::config::DiagnosticsConfig;
12
13/// Run semantic checks on `doc` against the supplied `AnalysisSession`.
14/// Ingests the current file through mir's diagnostics-only path and returns
15/// LSP diagnostics filtered by `DiagnosticsConfig`.
16///
17/// Used only by `benches/semantic.rs` to measure raw analyzer cost. It is
18/// not on the production request path and skips `DocumentStore`'s salsa
19/// caching, PSR-4 lazy-loading, and `collector_issues` diagnostics — for
20/// that, see `DocumentStore::get_semantic_issues_salsa` and
21/// `compute_open_file_diagnostics`.
22pub fn semantic_diagnostics(
23    uri: &Uri,
24    doc: &ParsedDoc,
25    session: &mut mir_analyzer::AnalysisSession,
26    cfg: &DiagnosticsConfig,
27) -> Vec<Diagnostic> {
28    if !cfg.enabled {
29        return vec![];
30    }
31    let file: std::sync::Arc<str> = std::sync::Arc::from(uri.as_str());
32    let analysis = session.analyze_file_diagnostics(uri.as_str(), doc.source());
33    let class_issues = session.class_issues(std::slice::from_ref(&file));
34    analysis
35        .issues
36        .into_iter()
37        .chain(class_issues)
38        .filter(|i| !i.suppressed)
39        .filter(|i| issue_passes_filter(i, cfg))
40        .map(to_lsp_diagnostic)
41        .collect()
42}
43
44/// Convert pre-computed raw issues (from `db::semantic::semantic_issues`) into
45/// LSP diagnostics, applying the user's `DiagnosticsConfig` filter. Keeping
46/// filter + conversion outside the salsa query preserves memoization across
47/// config toggles (the user flipping a category must not rerun the analyzer).
48///
49/// `ParseError` issues are always excluded here, regardless of which mir API
50/// produced `issues`: php-lsp already surfaces raw parse errors as
51/// `SyntaxError` diagnostics from its own parser pass (see
52/// `crate::analysis::diagnostics::diagnostics_from_doc`), so this is the one
53/// place every issue source funnels through before becoming a `Diagnostic`.
54pub fn issues_to_diagnostics(
55    issues: &[mir_issues::Issue],
56    _uri: &Uri,
57    cfg: &DiagnosticsConfig,
58) -> Vec<Diagnostic> {
59    if !cfg.enabled {
60        return vec![];
61    }
62    issues
63        .iter()
64        .filter(|i| !matches!(i.kind, mir_issues::IssueKind::ParseError { .. }))
65        .filter(|i| issue_passes_filter(i, cfg))
66        .cloned()
67        .map(to_lsp_diagnostic)
68        .collect()
69}
70
71/// Like [`issues_to_diagnostics`], but additionally holds back
72/// workspace-symbol-dependent issues (see [`issue_needs_workspace_index`])
73/// while `index_ready` is `false`. Skips the extra filter/clone pass
74/// entirely once ready — the common case, well past server startup — so
75/// this costs nothing in steady state.
76pub fn issues_to_diagnostics_gated(
77    issues: &[mir_issues::Issue],
78    uri: &Uri,
79    cfg: &DiagnosticsConfig,
80    index_ready: bool,
81) -> Vec<Diagnostic> {
82    if index_ready {
83        return issues_to_diagnostics(issues, uri, cfg);
84    }
85    let filtered: Vec<mir_issues::Issue> = issues
86        .iter()
87        .filter(|i| !issue_needs_workspace_index(&i.kind))
88        .cloned()
89        .collect();
90    issues_to_diagnostics(&filtered, uri, cfg)
91}
92
93/// Whether resolving this issue required looking up a symbol (class,
94/// function, method, or trait) by name against the workspace-wide symbol
95/// table, as opposed to something derivable from the file's own contents.
96///
97/// Before the initial workspace scan finishes, that table only reflects the
98/// subset of files indexed so far, so these specific kinds can misreport a
99/// symbol declared in a not-yet-scanned file as undefined — see issue #242.
100/// Everything else (return-type mismatches, unreachable code, duplicate
101/// declarations within a file, etc.) is safe to report immediately: it's
102/// checked against the file's own text and can't be invalidated by more of
103/// the workspace becoming known.
104pub fn issue_needs_workspace_index(kind: &mir_issues::IssueKind) -> bool {
105    use mir_issues::IssueKind;
106    matches!(
107        kind,
108        IssueKind::UndefinedFunction { .. }
109            | IssueKind::UndefinedMethod { .. }
110            | IssueKind::UndefinedClass { .. }
111            | IssueKind::UndefinedTrait { .. }
112    )
113}
114
115/// Returns `true` if the mir-analyzer issue is allowed through by the config.
116fn issue_passes_filter(issue: &mir_issues::Issue, cfg: &DiagnosticsConfig) -> bool {
117    use mir_issues::IssueKind;
118    let name = issue.kind.name();
119    if cfg.disabled.iter().any(|d| d == name) {
120        return false;
121    }
122    match &issue.kind {
123        IssueKind::UndefinedVariable { .. } | IssueKind::PossiblyUndefinedVariable { .. } => {
124            cfg.undefined_variables
125        }
126        IssueKind::UndefinedFunction { .. } | IssueKind::UndefinedMethod { .. } => {
127            cfg.undefined_functions
128        }
129        IssueKind::UndefinedClass { .. } | IssueKind::UndefinedTrait { .. } => {
130            cfg.undefined_classes
131        }
132        IssueKind::InvalidTraitUse { .. } => cfg.type_errors,
133        IssueKind::TooFewArguments { .. }
134        | IssueKind::TooManyArguments { .. }
135        | IssueKind::InvalidPassByReference { .. }
136        | IssueKind::InvalidNamedArgument { .. } => cfg.arity_errors,
137        // InvalidArgument covers both arity errors and type mismatches in mir-analyzer;
138        // show it if either toggle is on.
139        IssueKind::InvalidArgument { .. } | IssueKind::PossiblyInvalidArgument { .. } => {
140            cfg.arity_errors || cfg.type_errors
141        }
142        IssueKind::InvalidReturnType { .. }
143        | IssueKind::NullMethodCall { .. }
144        | IssueKind::NullPropertyFetch { .. }
145        | IssueKind::NullArrayAccess
146        | IssueKind::NullArgument { .. }
147        | IssueKind::PossiblyNullMethodCall { .. }
148        | IssueKind::PossiblyNullPropertyFetch { .. }
149        | IssueKind::PossiblyNullArrayAccess
150        | IssueKind::PossiblyNullArgument { .. }
151        | IssueKind::NullableReturnStatement { .. }
152        | IssueKind::InvalidPropertyAssignment { .. }
153        | IssueKind::InvalidOperand { .. }
154        | IssueKind::InvalidCast { .. }
155        | IssueKind::AbstractInstantiation { .. }
156        | IssueKind::MixedClone
157        | IssueKind::ReadonlyPropertyAssignment { .. }
158        | IssueKind::ArgumentTypeCoercion { .. } => cfg.type_errors,
159        IssueKind::DeprecatedCall { .. }
160        | IssueKind::DeprecatedMethodCall { .. }
161        | IssueKind::DeprecatedMethod { .. }
162        | IssueKind::DeprecatedClass { .. } => cfg.deprecated_calls,
163        IssueKind::CircularInheritance { .. } => cfg.type_errors,
164        IssueKind::DuplicateClass { .. }
165        | IssueKind::DuplicateInterface { .. }
166        | IssueKind::DuplicateTrait { .. }
167        | IssueKind::DuplicateEnum { .. }
168        | IssueKind::DuplicateFunction { .. } => cfg.duplicate_declarations,
169        IssueKind::UnusedVariable { .. }
170        | IssueKind::UnusedParam { .. }
171        | IssueKind::UnusedMethod { .. }
172        | IssueKind::UnusedProperty { .. }
173        | IssueKind::UnusedFunction { .. } => cfg.unused_symbols,
174        IssueKind::MissingReturnType { .. }
175        | IssueKind::MissingParamType { .. }
176        | IssueKind::MissingPropertyType { .. } => cfg.missing_types,
177        IssueKind::MixedArgument { .. }
178        | IssueKind::MixedAssignment { .. }
179        | IssueKind::MixedMethodCall { .. }
180        | IssueKind::MixedPropertyFetch { .. }
181        | IssueKind::MixedPropertyAssignment { .. }
182        | IssueKind::MixedArrayAccess
183        | IssueKind::MixedArrayOffset
184        | IssueKind::MixedReturnStatement { .. } => cfg.mixed_usage,
185        IssueKind::DocblockTypeContradiction { .. }
186        | IssueKind::UnevaluatedCode { .. }
187        | IssueKind::IfThisIsMismatch { .. } => true,
188        _ => true,
189    }
190}
191
192fn to_lsp_diagnostic(issue: mir_issues::Issue) -> Diagnostic {
193    // mir uses 1-based lines; LSP uses 0-based. Columns are 0-based on both sides.
194    let line = issue.location.line.saturating_sub(1);
195    let col_start = issue.location.col_start as u32;
196    let col_end = issue.location.col_end as u32;
197    Diagnostic {
198        range: Range {
199            start: Position {
200                line,
201                character: col_start,
202            },
203            end: Position {
204                line,
205                character: col_end.max(col_start + 1),
206            },
207        },
208        severity: Some(match issue.severity {
209            mir_issues::Severity::Error => DiagnosticSeverity::ERROR,
210            mir_issues::Severity::Warning => DiagnosticSeverity::WARNING,
211            mir_issues::Severity::Info => DiagnosticSeverity::INFORMATION,
212        }),
213        code: Some(NumberOrString::String(issue.kind.name().to_string())),
214        source: Some(PHP_LSP_SOURCE.to_string()),
215        message: issue.kind.message(),
216        ..Default::default()
217    }
218}
219
220#[cfg(test)]
221mod tests {
222    use super::*;
223
224    #[test]
225    fn to_lsp_diagnostic_sets_code_to_issue_kind_name() {
226        use mir_issues::{Issue, IssueKind, Location};
227        use std::sync::Arc;
228        use tower_lsp_server::ls_types::NumberOrString;
229
230        let location = Location {
231            file: Arc::from("file:///test.php"),
232            line: 1,
233            line_end: 1,
234            col_start: 0,
235            col_end: 3,
236        };
237        let issue = Issue::new(
238            IssueKind::UndefinedClass {
239                name: "Foo".to_string(),
240            },
241            location,
242        );
243        let diag = to_lsp_diagnostic(issue);
244        assert_eq!(
245            diag.code,
246            Some(NumberOrString::String("UndefinedClass".to_string())),
247            "diagnostic code must be the IssueKind name so code actions can match by type"
248        );
249        assert!(
250            diag.message.contains("Foo"),
251            "diagnostic message should mention the class name"
252        );
253    }
254
255    #[test]
256    fn disabled_list_filters_issue_by_name() {
257        use mir_issues::{Issue, IssueKind, Location};
258        use std::sync::Arc;
259
260        let issue = Issue::new(
261            IssueKind::UndefinedClass {
262                name: "Foo".to_string(),
263            },
264            Location {
265                file: Arc::from("file:///test.php"),
266                line: 1,
267                line_end: 1,
268                col_start: 0,
269                col_end: 3,
270            },
271        );
272        let uri: Uri = "file:///test.php".parse().unwrap();
273        let mut cfg = DiagnosticsConfig::default();
274        assert_eq!(
275            issues_to_diagnostics(std::slice::from_ref(&issue), &uri, &cfg).len(),
276            1
277        );
278        cfg.disabled = vec!["UndefinedClass".to_string()];
279        assert!(issues_to_diagnostics(&[issue], &uri, &cfg).is_empty());
280    }
281}
php_lsp/analysis/semantic_diagnostics.rs

php_lsp/analysis/
semantic_diagnostics.rs
