SplitScript/src/type_display.rs at master · LiveSplit/SplitScript · GitHub

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
//! Canonical source spelling for resolved semantic types used by editor tooling.

use crate::{
    database::SemanticSnapshot,
    types::{TypeId, TypeKind},
};

pub(crate) fn display_type(ty: TypeId, snapshot: &SemanticSnapshot) -> String {
    let types = snapshot.semantics().types();
    match types.kind(ty) {
        TypeKind::Error => "<unknown>".to_owned(),
        TypeKind::Builtin(builtin) => builtin.to_string(),
        TypeKind::Standard(standard) => snapshot
            .context()
            .standard_library()
            .type_decl(*standard)
            .name
            .to_owned(),
        TypeKind::StateSnapshot => "StateSnapshot".to_owned(),
        TypeKind::SettingsView => "SettingsView".to_owned(),
        TypeKind::Struct(id) => snapshot
            .syntax()
            .structs
            .iter()
            .find(|structure| structure.id == *id)
            .map(|structure| structure.name.clone())
            .unwrap_or_else(|| format!("struct#{}", id.index())),
        TypeKind::Enum(id) => snapshot
            .enum_types()
            .iter()
            .find(|enumeration| enumeration.id == *id)
            .map(|enumeration| enumeration.name.clone())
            .unwrap_or_else(|| format!("enum#{}", id.index())),
        TypeKind::ManagedClass(id) => snapshot
            .syntax()
            .managed_class(*id)
            .map(|class| class.name.clone())
            .unwrap_or_else(|| format!("class#{}", id.index())),
        TypeKind::ManagedReference(id) => snapshot
            .syntax()
            .managed_class(*id)
            .map(|class| format!("{}.Ref", class.name))
            .unwrap_or_else(|| format!("class#{}.Ref", id.index())),
        TypeKind::GenericParameter { index, .. } => snapshot
            .semantics()
            .associated_projection_for_output(ty)
            .map(|projection| {
                format!(
                    "{}.{}",
                    display_type(projection.receiver, snapshot),
                    projection.name
                )
            })
            .unwrap_or_else(|| crate::types::generic_parameter_name(*index)),
        TypeKind::Array {
            element, length, ..
        } => match length {
            Some(length) => format!("[{}; {length}]", display_type(*element, snapshot)),
            None => format!("[{}]", display_type(*element, snapshot)),
        },
        TypeKind::Option { value, .. } => format!("{}?", display_type(*value, snapshot)),
        TypeKind::Result { value, .. } => format!("{}!", display_type(*value, snapshot)),
        TypeKind::Async { value, .. } => format!("async {}", display_type(*value, snapshot)),
        TypeKind::Iterator { item, .. } => {
            format!("iterator {}", display_type(*item, snapshot))
        }
        TypeKind::Callable {
            parameters, result, ..
        } => {
            let parameters = parameters
                .iter()
                .map(|parameter| display_type(*parameter, snapshot))
                .collect::<Vec<_>>()
                .join(", ");
            format!("({parameters}) -> {}", display_type(*result, snapshot))
        }
        TypeKind::Set { element, .. } => format!("Set<{}>", display_type(*element, snapshot)),
        TypeKind::Application {
            constructor,
            arguments,
            ..
        } => {
            let name = snapshot
                .context()
                .standard_library()
                .type_constructor(*constructor)
                .name;
            let arguments = arguments
                .iter()
                .map(|argument| display_type(*argument, snapshot))
                .collect::<Vec<_>>()
                .join(", ");
            format!("{name}<{arguments}>")
        }
        TypeKind::Range { bound, kind, .. } => {
            let bound = display_type(*bound, snapshot);
            format!("{bound}{}{bound}", kind.operator())
        }
    }
}