wat_service 0.9.0

WebAssembly Text Format language service.
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

use super::{Diagnostic, FastPlainInstr, RelatedInformation};
use crate::{
    binder::{Symbol, SymbolKey, SymbolTable},
    document::Document,
    types_analyzer::{self, CompositeType, DefTypes, FieldType, Fields, StorageType},
};

const DIAGNOSTIC_CODE: &str = "packing";

pub fn check(
    db: &dyn salsa::Database,
    document: Document,
    symbol_table: &SymbolTable,
    instr: &FastPlainInstr,
) -> Option<Diagnostic> {
    match instr.name {
        "struct.get" => {
            let def_types = types_analyzer::get_def_types(db, document);
            if let Some((_, symbol)) =
                find_struct_field(symbol_table, def_types, instr).filter(|(ty, _)| ty.is_packed())
            {
                Some(Diagnostic {
                    range: symbol.key.text_range(),
                    code: DIAGNOSTIC_CODE.into(),
                    message: format!("field `{}` is packed", symbol.idx.render(db)),
                    related_information: Some(vec![RelatedInformation {
                        range: instr.name_range,
                        message: "use `struct.get_s` or `struct.get_u` instead".into(),
                    }]),
                    ..Default::default()
                })
            } else {
                None
            }
        }
        "struct.get_s" | "struct.get_u" => {
            let def_types = types_analyzer::get_def_types(db, document);
            if let Some((_, symbol)) =
                find_struct_field(symbol_table, def_types, instr).filter(|(ty, _)| !ty.is_packed())
            {
                Some(Diagnostic {
                    range: symbol.key.text_range(),
                    code: DIAGNOSTIC_CODE.into(),
                    message: format!("field `{}` is unpacked", symbol.idx.render(db)),
                    related_information: Some(vec![RelatedInformation {
                        range: instr.name_range,
                        message: "use `struct.get` instead".into(),
                    }]),
                    ..Default::default()
                })
            } else {
                None
            }
        }
        "array.get" => {
            let def_types = types_analyzer::get_def_types(db, document);
            if let Some((_, symbol)) = find_array(symbol_table, def_types, instr).filter(|(ty, _)| ty.is_packed()) {
                Some(Diagnostic {
                    range: symbol.key.text_range(),
                    code: DIAGNOSTIC_CODE.into(),
                    message: format!("array `{}` is packed", symbol.idx.render(db)),
                    related_information: Some(vec![RelatedInformation {
                        range: instr.name_range,
                        message: "use `array.get_s` or `array.get_u` instead".into(),
                    }]),
                    ..Default::default()
                })
            } else {
                None
            }
        }
        "array.get_s" | "array.get_u" => {
            let def_types = types_analyzer::get_def_types(db, document);
            if let Some((_, symbol)) = find_array(symbol_table, def_types, instr).filter(|(ty, _)| !ty.is_packed()) {
                Some(Diagnostic {
                    range: symbol.key.text_range(),
                    code: DIAGNOSTIC_CODE.into(),
                    message: format!("array `{}` is unpacked", symbol.idx.render(db)),
                    related_information: Some(vec![RelatedInformation {
                        range: instr.name_range,
                        message: "use `array.get` instead".into(),
                    }]),
                    ..Default::default()
                })
            } else {
                None
            }
        }
        _ => None,
    }
}

fn find_struct_field<'db>(
    symbol_table: &'db SymbolTable<'db>,
    def_types: &'db DefTypes<'db>,
    instr: &FastPlainInstr,
) -> Option<(&'db StorageType<'db>, &'db Symbol<'db>)> {
    let struct_def_key = symbol_table.resolved.get(&instr.immediates.first().copied()?.into())?;
    let field_ref_symbol = symbol_table
        .symbols
        .get(&SymbolKey::from(instr.immediates.get(1).copied()?))?;
    if let Some(CompositeType::Struct(Fields(fields))) = def_types.get(struct_def_key).map(|def_type| &def_type.comp) {
        fields
            .iter()
            .find(|(_, idx)| field_ref_symbol.idx.is_defined_by(idx))
            .map(|(ty, _)| (&ty.storage, field_ref_symbol))
    } else {
        None
    }
}

fn find_array<'db>(
    symbol_table: &'db SymbolTable<'db>,
    def_types: &'db DefTypes<'db>,
    instr: &FastPlainInstr,
) -> Option<(&'db StorageType<'db>, &'db Symbol<'db>)> {
    let ref_key = instr.immediates.first().copied()?.into();
    let ref_symbol = symbol_table.symbols.get(&ref_key)?;
    if let Some(CompositeType::Array(Some(FieldType { storage, .. }))) = def_types
        .get(symbol_table.resolved.get(&ref_key)?)
        .map(|def_type| &def_type.comp)
    {
        Some((storage, ref_symbol))
    } else {
        None
    }
}