mir-analyzer 0.19.0

Analysis engine for the mir PHP static analyzer
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

use super::helpers::extract_simple_var;
use super::ExpressionAnalyzer;
use crate::context::Context;
use crate::symbol::SymbolKind;
use mir_issues::{IssueKind, Severity};
use mir_types::{Atomic, Union};
use php_ast::ast::Expr;

impl<'a> ExpressionAnalyzer<'a> {
    pub(super) fn analyze_variable<'arena, 'src>(
        &mut self,
        name: &php_ast::ast::NameStr<'arena, 'src>,
        expr: &Expr<'arena, 'src>,
        ctx: &mut Context,
    ) -> Union {
        let name_str = name.as_str().trim_start_matches('$');
        if !ctx.var_is_defined(name_str) {
            if ctx.var_possibly_defined(name_str) {
                self.emit(
                    IssueKind::PossiblyUndefinedVariable {
                        name: name_str.to_string(),
                    },
                    Severity::Warning,
                    expr.span,
                );
            } else if name_str == "this" {
                self.emit(
                    IssueKind::InvalidScope {
                        in_class: ctx.self_fqcn.is_some(),
                    },
                    Severity::Error,
                    expr.span,
                );
            } else {
                self.emit(
                    IssueKind::UndefinedVariable {
                        name: name_str.to_string(),
                    },
                    Severity::Error,
                    expr.span,
                );
            }
        }
        ctx.read_vars.insert(name_str.to_string());
        let ty = if name_str == "this" && !ctx.var_is_defined("this") {
            Union::never()
        } else {
            ctx.get_var(name_str)
        };
        self.record_symbol(
            expr.span,
            SymbolKind::Variable(name_str.to_string()),
            ty.clone(),
        );
        ty
    }

    pub(super) fn analyze_variable_variable<'arena, 'src>(
        &mut self,
        inner: &Expr<'arena, 'src>,
        ctx: &mut Context,
    ) -> Union {
        let inner_ty = self.analyze(inner, ctx);
        if let Some(var_name) = extract_simple_var(inner) {
            ctx.read_vars.insert(var_name.clone());
            for atomic in &inner_ty.types {
                if let Atomic::TLiteralString(accessed_var_name) = atomic {
                    ctx.read_vars.insert(accessed_var_name.to_string());
                }
            }
        }
        Union::mixed()
    }

    pub(super) fn analyze_identifier<'arena, 'src>(
        &mut self,
        name: &php_ast::ast::NameStr<'arena, 'src>,
        expr: &Expr<'arena, 'src>,
        _ctx: &mut Context,
    ) -> Union {
        let name_str: &str = name.as_str();
        let name_str = name_str.strip_prefix('\\').unwrap_or(name_str);
        let ns_qualified = self
            .db
            .file_namespace(self.file.as_ref())
            .map(|ns| format!("{}\\{}", ns, name_str));

        // Try to look up the constant in namespace-qualified form first, then globally
        let const_node = ns_qualified
            .as_deref()
            .and_then(|fqn| {
                self.db
                    .lookup_global_constant_node(fqn)
                    .filter(|n| n.active(self.db))
            })
            .or_else(|| {
                self.db
                    .lookup_global_constant_node(name_str)
                    .filter(|n| n.active(self.db))
            });

        if let Some(node) = const_node {
            node.ty(self.db)
        } else {
            self.emit(
                IssueKind::UndefinedConstant {
                    name: name_str.to_string(),
                },
                Severity::Error,
                expr.span,
            );
            Union::mixed()
        }
    }
}