omena-scss-eval 0.3.0

Oracle-first SCSS and Less value evaluator rail for Omena CSS
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

use std::collections::BTreeSet;

use omena_parser::LexedToken;

use super::{
    StaticScssControlFlowPruneEvidenceCounts, StaticScssFunctionResolutionContext,
    StaticScssMixinEvaluationEdits, StaticStylesheetEvaluationEdit,
    canonical_static_scss_function_name, collect_static_scss_mixin_include_calls,
    extend_static_scss_used_function_dependencies, render_static_scss_mixin_include_body,
    static_scss_mixin_include_is_inside_declaration_body,
    static_scss_mixin_include_is_inside_function_declaration_body,
    static_stylesheet_position_is_inside_ranges,
};

pub(super) fn collect_static_scss_mixin_evaluation_edits(
    source: &str,
    tokens: &[LexedToken],
    context: StaticScssFunctionResolutionContext<'_>,
    excluded_ranges: &[(usize, usize)],
) -> Option<StaticScssMixinEvaluationEdits> {
    let calls = collect_static_scss_mixin_include_calls(
        source,
        context.dialect,
        tokens,
        context.mixin_declarations,
    )?;
    if calls.is_empty() {
        return Some(StaticScssMixinEvaluationEdits {
            edits: Vec::new(),
            preserved_raw_include_count: 0,
            prune_evidence_counts: StaticScssControlFlowPruneEvidenceCounts::default(),
        });
    }

    let mut edits = Vec::new();
    let mut used_declaration_names = BTreeSet::new();
    let mut preserved_declaration_names = BTreeSet::new();
    let mut used_function_declaration_names = BTreeSet::new();
    let mut preserved_raw_include_count = 0usize;
    let mut prune_evidence_counts = StaticScssControlFlowPruneEvidenceCounts::default();
    for call in calls.iter().filter(|call| {
        !static_scss_mixin_include_is_inside_declaration_body(call, context.mixin_declarations)
            && !static_scss_mixin_include_is_inside_function_declaration_body(
                call,
                context.declarations,
            )
            && !static_stylesheet_position_is_inside_ranges(call.start, excluded_ranges)
    }) {
        let Some(declaration) = context.mixin_declarations.iter().find(|declaration| {
            canonical_static_scss_function_name(declaration.name.as_str())
                == canonical_static_scss_function_name(call.name.as_str())
        }) else {
            continue;
        };
        let Some(rendered) = render_static_scss_mixin_include_body(
            source,
            tokens,
            declaration,
            call,
            call.start,
            context,
        ) else {
            preserved_raw_include_count += 1;
            preserved_declaration_names.insert(canonical_static_scss_function_name(
                declaration.name.as_str(),
            ));
            continue;
        };
        used_declaration_names.extend(rendered.used_mixin_declaration_names);
        used_function_declaration_names.extend(rendered.used_function_declaration_names);
        prune_evidence_counts.add_assign(rendered.prune_evidence_counts);
        edits.push(StaticStylesheetEvaluationEdit {
            start: call.start,
            end: call.end,
            replacement: rendered.body,
        });
    }

    for declaration in context.mixin_declarations.iter().filter(|declaration| {
        let canonical_name = canonical_static_scss_function_name(declaration.name.as_str());
        used_declaration_names.contains(&canonical_name)
            && !preserved_declaration_names.contains(&canonical_name)
    }) {
        edits.push(StaticStylesheetEvaluationEdit {
            start: declaration.span_start,
            end: declaration.span_end,
            replacement: String::new(),
        });
    }
    extend_static_scss_used_function_dependencies(
        &mut used_function_declaration_names,
        context.declarations,
    );
    for declaration in context.declarations.iter().filter(|declaration| {
        used_function_declaration_names.contains(&canonical_static_scss_function_name(
            declaration.name.as_str(),
        ))
    }) {
        edits.push(StaticStylesheetEvaluationEdit {
            start: declaration.span_start,
            end: declaration.span_end,
            replacement: String::new(),
        });
    }

    Some(StaticScssMixinEvaluationEdits {
        edits,
        preserved_raw_include_count,
        prune_evidence_counts,
    })
}