vize_croquis 0.76.0

Croquis - Semantic analysis layer for Vize. Quick sketches of meaning from Vue templates.
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

//! Template AST visiting and analysis.
//!
//! Provides methods for traversing the template AST and collecting:
//! - v-for/v-slot scope variables
//! - Component and directive usage
//! - Undefined reference detection
//! - Template expressions for type checking
//! - Element IDs for cross-file uniqueness checking

mod components;
mod directives;
mod ids;
mod visit_element;

#[cfg(test)]
mod tests;

use super::Analyzer;
use vize_carton::{profile, CompactString};
use vize_relief::ast::{ExpressionNode, RootNode, TemplateChildNode};

impl Analyzer {
    /// Analyze template AST.
    pub fn analyze_template(&mut self, root: &RootNode<'_>) -> &mut Self {
        if !self.options.analyze_template_scopes && !self.options.track_usage {
            return self;
        }

        // Count root-level elements
        let root_element_count = profile!("croquis.template.root_count", {
            let mut root_element_count = 0;
            for child in root.children.iter() {
                if Self::is_element_child(child) {
                    root_element_count += 1;
                }
            }
            root_element_count
        });
        self.summary.template_info.root_element_count = root_element_count;

        // Store template content range
        self.summary.template_info.content_start = root.loc.start.offset;
        self.summary.template_info.content_end = root.loc.end.offset;

        // Single-pass template traversal
        profile!("croquis.template.traverse", {
            for child in root.children.iter() {
                self.visit_template_child(child, &mut Vec::new());
            }
        });

        self
    }

    /// Check if a template child is an actual element.
    pub(super) fn is_element_child(node: &TemplateChildNode<'_>) -> bool {
        match node {
            TemplateChildNode::Element(_) => true,
            TemplateChildNode::If(if_node) => if_node
                .branches
                .first()
                .map(|b| b.children.iter().any(Self::is_element_child))
                .unwrap_or(false),
            TemplateChildNode::For(_) => true,
            _ => false,
        }
    }

    /// Visit template child node.
    pub(super) fn visit_template_child(
        &mut self,
        node: &TemplateChildNode<'_>,
        scope_vars: &mut Vec<CompactString>,
    ) {
        match node {
            TemplateChildNode::Element(el) => {
                profile!(
                    "croquis.template.visit_element",
                    self.visit_element(el, scope_vars)
                )
            }
            TemplateChildNode::If(if_node) => {
                profile!(
                    "croquis.template.visit_if",
                    self.visit_if(if_node, scope_vars)
                )
            }
            TemplateChildNode::For(for_node) => {
                profile!(
                    "croquis.template.visit_for",
                    self.visit_for(for_node, scope_vars)
                )
            }
            TemplateChildNode::Interpolation(interp) => {
                profile!("croquis.template.interpolation", {
                    let content = match &interp.content {
                        ExpressionNode::Simple(s) => s.content.as_str(),
                        ExpressionNode::Compound(c) => c.loc.source.as_str(),
                    };

                    // Track $attrs usage
                    if content.contains("$attrs") {
                        self.summary.template_info.uses_attrs = true;
                    }

                    if self.options.collect_template_expressions {
                        let loc = interp.content.loc();
                        let scope_id = self.summary.scopes.current_id();
                        self.summary.template_expressions.push(
                            crate::analysis::TemplateExpression {
                                content: CompactString::new(content),
                                kind: crate::analysis::TemplateExpressionKind::Interpolation,
                                start: loc.start.offset,
                                end: loc.end.offset,
                                scope_id,
                                vif_guard: self.current_vif_guard(),
                            },
                        );
                    }
                    if self.options.detect_undefined && self.script_analyzed {
                        self.check_expression_refs(
                            &interp.content,
                            scope_vars,
                            interp.content.loc().start.offset,
                        );
                    }
                })
            }
            _ => {}
        }
    }
}