fallow-core 3.36.0

Internal detector backend for fallow-engine and fallow-api
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use super::*;

/// Whether `export` has a class method `name` that returns `this`.
fn is_self_returning_method(export: &crate::extract::ExportInfo, name: &str) -> bool {
    export.members.iter().any(|member| {
        member.kind == MemberKind::ClassMethod && member.name == name && member.is_self_returning
    })
}

/// How many leading `steps` a chain credits on one class export: each step
/// up to and including the first step that does not return `this`. A step is
/// used when every earlier step returns `this`.
fn credited_step_count(export: &crate::extract::ExportInfo, steps: &[String]) -> usize {
    steps
        .iter()
        .position(|step| !is_self_returning_method(export, step))
        .map_or(steps.len(), |index| index + 1)
}

/// The steps a factory-rooted chain credits on a single class export.
fn factory_chain_credits(
    export: &crate::extract::ExportInfo,
    origin: &ExportKey,
    root_method: &str,
    steps: &[String],
) -> usize {
    if !export.name.matches_str(origin.export_name.as_str()) {
        return 0;
    }
    let has_factory = export.members.iter().any(|member| {
        member.is_instance_returning_static
            && member.kind == MemberKind::ClassMethod
            && member.name == root_method
    });
    if !has_factory {
        return 0;
    }
    credited_step_count(export, steps)
}

/// Credit member accesses produced by fluent-builder chain calls.
pub(super) fn propagate_fluent_chain_accesses(
    graph: &ModuleGraph,
    resolved_modules: &[ResolvedModule],
    indexes: &MemberPassIndexes<'_>,
    accessed_members: &mut FxHashMap<ExportKey, FxHashSet<String>>,
) {
    for resolved in resolved_modules {
        let local_to_export_keys = indexes.local_keys(resolved.file_id);
        for access in fluent_chain_member_accesses(resolved) {
            let Some(seed_keys) = local_to_export_keys.get(access.root_object.as_str()) else {
                continue;
            };
            for seed_key in seed_keys {
                for origin in
                    walk_re_export_origins(graph, seed_key.file_id, seed_key.export_name.as_str())
                {
                    let Some(origin_module) = indexes.module_by_id.get(&origin.file_id) else {
                        continue;
                    };
                    let credited = origin_module
                        .exports
                        .iter()
                        .map(|export| {
                            factory_chain_credits(
                                export,
                                &origin,
                                access.root_method.as_str(),
                                &access.steps,
                            )
                        })
                        .max()
                        .unwrap_or(0);
                    if credited == 0 {
                        continue;
                    }
                    accessed_members
                        .entry(origin)
                        .or_default()
                        .extend(access.steps[..credited].iter().cloned());
                }
            }
        }
    }
}

/// The steps a constructor-rooted chain credits on a single class export.
fn new_chain_credits(
    export: &crate::extract::ExportInfo,
    origin: &ExportKey,
    first_method: &str,
    steps: &[String],
) -> usize {
    if !export.name.matches_str(origin.export_name.as_str())
        || !is_self_returning_method(export, first_method)
    {
        return 0;
    }
    credited_step_count(export, steps)
}

/// Credit member accesses produced by fluent chains rooted at `new`.
pub(super) fn propagate_fluent_chain_new_accesses(
    graph: &ModuleGraph,
    resolved_modules: &[ResolvedModule],
    indexes: &MemberPassIndexes<'_>,
    accessed_members: &mut FxHashMap<ExportKey, FxHashSet<String>>,
) {
    for resolved in resolved_modules {
        let local_to_export_keys = indexes.local_keys(resolved.file_id);
        for access in fluent_chain_new_member_accesses(resolved) {
            let Some(seed_keys) = local_to_export_keys.get(access.class_name.as_str()) else {
                continue;
            };
            for seed_key in seed_keys {
                for origin in
                    walk_re_export_origins(graph, seed_key.file_id, seed_key.export_name.as_str())
                {
                    let Some(origin_module) = indexes.module_by_id.get(&origin.file_id) else {
                        continue;
                    };
                    let credited = origin_module
                        .exports
                        .iter()
                        .map(|export| {
                            new_chain_credits(
                                export,
                                &origin,
                                access.first_method.as_str(),
                                &access.steps,
                            )
                        })
                        .max()
                        .unwrap_or(0);
                    if credited == 0 {
                        continue;
                    }
                    accessed_members
                        .entry(origin)
                        .or_default()
                        .extend(access.steps[..credited].iter().cloned());
                }
            }
        }
    }
}