mir-analyzer 0.18.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
116
117

use super::ExpressionAnalyzer;
use crate::context::Context;
use mir_types::Union;
use php_ast::ast::{ExprKind, MatchExpr, NullCoalesceExpr, TernaryExpr};

impl<'a> ExpressionAnalyzer<'a> {
    pub(super) fn analyze_ternary<'arena, 'src>(
        &mut self,
        t: &TernaryExpr<'arena, 'src>,
        ctx: &mut Context,
    ) -> Union {
        let cond_ty = self.analyze(t.condition, ctx);
        match &t.then_expr {
            Some(then_expr) => {
                let mut then_ctx = ctx.fork();
                crate::narrowing::narrow_from_condition(
                    t.condition,
                    &mut then_ctx,
                    true,
                    self.db,
                    &self.file,
                );
                let then_ty = self.analyze(then_expr, &mut then_ctx);

                let mut else_ctx = ctx.fork();
                crate::narrowing::narrow_from_condition(
                    t.condition,
                    &mut else_ctx,
                    false,
                    self.db,
                    &self.file,
                );
                let else_ty = self.analyze(t.else_expr, &mut else_ctx);

                for name in then_ctx.read_vars.iter().chain(else_ctx.read_vars.iter()) {
                    ctx.read_vars.insert(name.clone());
                }
                Union::merge(&then_ty, &else_ty)
            }
            None => {
                let else_ty = self.analyze(t.else_expr, ctx);
                let truthy_ty = cond_ty.narrow_to_truthy();
                if truthy_ty.is_empty() {
                    else_ty
                } else {
                    Union::merge(&truthy_ty, &else_ty)
                }
            }
        }
    }

    pub(super) fn analyze_null_coalesce<'arena, 'src>(
        &mut self,
        nc: &NullCoalesceExpr<'arena, 'src>,
        ctx: &mut Context,
    ) -> Union {
        let left_ty = self.analyze(nc.left, ctx);
        let right_ty = self.analyze(nc.right, ctx);
        let non_null_left = left_ty.remove_null();
        if non_null_left.is_empty() {
            right_ty
        } else {
            Union::merge(&non_null_left, &right_ty)
        }
    }

    pub(super) fn analyze_match<'arena, 'src>(
        &mut self,
        m: &MatchExpr<'arena, 'src>,
        ctx: &mut Context,
    ) -> Union {
        let subject_ty = self.analyze(m.subject, ctx);
        let subject_var = match &m.subject.kind {
            ExprKind::Variable(name) => Some(name.as_str().trim_start_matches('$').to_string()),
            _ => None,
        };

        let mut result = Union::empty();
        for arm in m.arms.iter() {
            let mut arm_ctx = ctx.fork();
            if let (Some(var), Some(conditions)) = (&subject_var, &arm.conditions) {
                let mut arm_ty = Union::empty();
                for cond in conditions.iter() {
                    let cond_ty = self.analyze(cond, ctx);
                    arm_ty = Union::merge(&arm_ty, &cond_ty);
                }
                if !arm_ty.is_empty() && !arm_ty.is_mixed() {
                    let narrowed = subject_ty.intersect_with(&arm_ty);
                    if !narrowed.is_empty() {
                        arm_ctx.set_var(var, narrowed);
                    }
                }
            }
            if let Some(conditions) = &arm.conditions {
                for cond in conditions.iter() {
                    crate::narrowing::narrow_from_condition(
                        cond,
                        &mut arm_ctx,
                        true,
                        self.db,
                        &self.file,
                    );
                }
            }
            let arm_body_ty = self.analyze(&arm.body, &mut arm_ctx);
            result = Union::merge(&result, &arm_body_ty);
            for name in &arm_ctx.read_vars {
                ctx.read_vars.insert(name.clone());
            }
        }
        if result.is_empty() {
            Union::mixed()
        } else {
            result
        }
    }
}