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
116

use super::StatementsAnalyzer;
use crate::context::Context;
use std::sync::Arc;

impl<'a> StatementsAnalyzer<'a> {
    pub(super) fn analyze_function_decl_stmt<'arena, 'src>(
        &mut self,
        decl: &php_ast::ast::FunctionDecl<'arena, 'src>,
        ctx: &mut Context,
    ) {
        let params: Vec<mir_codebase::FnParam> = decl
            .params
            .iter()
            .map(|p| mir_codebase::FnParam {
                name: Arc::from(p.name.to_string().trim_start_matches('$')),
                ty: None,
                has_default: p.default.is_some(),
                is_variadic: p.variadic,
                is_byref: p.by_ref,
                is_optional: p.default.is_some() || p.variadic,
            })
            .collect();
        let mut fn_ctx = Context::for_function(
            &params,
            None,
            Arc::from([]),
            None,
            None,
            None,
            ctx.strict_types,
            true,
        );
        let mut sa = StatementsAnalyzer::new(
            self.db,
            self.file.clone(),
            self.source,
            self.source_map,
            self.issues,
            self.symbols,
            self.php_version,
            self.inference_only,
        );
        sa.analyze_stmts(&decl.body, &mut fn_ctx);
    }

    pub(super) fn analyze_class_decl_stmt<'arena, 'src>(
        &mut self,
        decl: &php_ast::ast::ClassDecl<'arena, 'src>,
        ctx: &mut Context,
    ) {
        let class_name_owned = decl
            .name
            .map(|n| n.to_string())
            .unwrap_or_else(|| "<anonymous>".to_string());
        let class_name = class_name_owned.as_str();
        let resolved = crate::db::resolve_name_via_db(self.db, &self.file, class_name);
        let fqcn: Arc<str> = Arc::from(resolved.as_str());
        let parent_fqcn = self
            .db
            .lookup_class_node(fqcn.as_ref())
            .and_then(|node| node.parent(self.db));

        for member in decl.members.iter() {
            let php_ast::ast::ClassMemberKind::Method(method) = &member.kind else {
                continue;
            };
            let Some(body) = &method.body else { continue };
            let (params, return_ty) =
                crate::db::lookup_method_in_chain(self.db, fqcn.as_ref(), &method.name.to_string())
                    .map(|n| {
                        (
                            n.params(self.db).to_vec(),
                            n.return_type(self.db).map(|t| (*t).clone()),
                        )
                    })
                    .unwrap_or_else(|| {
                        let ast_params = method
                            .params
                            .iter()
                            .map(|p| mir_codebase::FnParam {
                                name: Arc::from(p.name.to_string().trim_start_matches('$')),
                                ty: None,
                                has_default: p.default.is_some(),
                                is_variadic: p.variadic,
                                is_byref: p.by_ref,
                                is_optional: p.default.is_some() || p.variadic,
                            })
                            .collect();
                        (ast_params, None)
                    });
            let is_ctor = method.name == "__construct";
            let mut method_ctx = Context::for_method(
                &params,
                return_ty,
                Arc::from([]),
                Some(fqcn.clone()),
                parent_fqcn.clone(),
                Some(fqcn.clone()),
                ctx.strict_types,
                is_ctor,
                method.is_static,
            );
            let mut sa = StatementsAnalyzer::new(
                self.db,
                self.file.clone(),
                self.source,
                self.source_map,
                self.issues,
                self.symbols,
                self.php_version,
                self.inference_only,
            );
            sa.analyze_stmts(body, &mut method_ctx);
        }
    }
}