lisette-semantics 0.2.12

Little language inspired by Rust that compiles to Go
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

use deps::{BindgenFailure, DeclarationStatus, TypedefLocatorResult};
use diagnostics::LocalSink;
use stdlib::Target;
use syntax::ast::Span;

pub fn emit_for_locator_result(
    result: &TypedefLocatorResult,
    import_name: &str,
    go_pkg: &str,
    name_span: Option<Span>,
    target: Target,
    standalone_mode: bool,
    sink: &LocalSink,
) -> bool {
    let span = name_span.unwrap_or_else(|| Span::new(0, 0, 0));
    match result {
        TypedefLocatorResult::Found { .. } => return true,
        TypedefLocatorResult::UnknownStdlib => {
            emit_unknown_stdlib(import_name, go_pkg, span, target, standalone_mode, sink);
        }
        TypedefLocatorResult::UndeclaredImport => {
            emit_undeclared(import_name, go_pkg, span, standalone_mode, sink);
        }
        TypedefLocatorResult::MissingTypedef { module, version } => {
            sink.push(diagnostics::module_graph::missing_go_typedef(
                go_pkg, module, version, span,
            ));
        }
        TypedefLocatorResult::UnreadableTypedef { path, error } => {
            sink.push(diagnostics::module_graph::unreadable_go_typedef(
                path, error, span,
            ));
        }
        TypedefLocatorResult::BindgenFailed {
            module,
            version,
            kind,
            ..
        } => match kind {
            BindgenFailure::GoToolchainMissing => {
                sink.push(diagnostics::module_graph::go_toolchain_missing(
                    go_pkg, span,
                ));
            }
            BindgenFailure::InvocationFailed { stderr } => {
                sink.push(diagnostics::module_graph::bindgen_failed(
                    go_pkg, module, version, stderr, span,
                ));
            }
        },
    }
    false
}

/// Emit a diagnostic for a non-OK `DeclarationStatus`; returns `true` if OK.
pub fn emit_for_declaration_status(
    status: &DeclarationStatus,
    import_name: &str,
    go_pkg: &str,
    name_span: Span,
    target: Target,
    standalone_mode: bool,
    sink: &LocalSink,
) -> bool {
    match status {
        DeclarationStatus::Stdlib | DeclarationStatus::DeclaredThirdParty { .. } => true,
        DeclarationStatus::UnknownStdlib => {
            emit_unknown_stdlib(
                import_name,
                go_pkg,
                name_span,
                target,
                standalone_mode,
                sink,
            );
            false
        }
        DeclarationStatus::UndeclaredImport => {
            emit_undeclared(import_name, go_pkg, name_span, standalone_mode, sink);
            false
        }
    }
}

fn emit_unknown_stdlib(
    import_name: &str,
    go_pkg: &str,
    span: Span,
    target: Target,
    standalone_mode: bool,
    sink: &LocalSink,
) {
    if let Some(targets) = stdlib::get_go_stdlib_package_targets(go_pkg) {
        sink.push(diagnostics::module_graph::go_stdlib_unavailable_on_target(
            go_pkg,
            &target.to_string(),
            &stdlib::format_targets(targets),
            span,
        ));
    } else {
        sink.push(diagnostics::module_graph::module_not_found(
            import_name,
            span,
            false,
            standalone_mode,
            None,
        ));
    }
}

fn emit_undeclared(
    import_name: &str,
    go_pkg: &str,
    span: Span,
    standalone_mode: bool,
    sink: &LocalSink,
) {
    if standalone_mode {
        sink.push(diagnostics::module_graph::module_not_found(
            import_name,
            span,
            false,
            true,
            None,
        ));
    } else {
        sink.push(diagnostics::module_graph::undeclared_go_import(
            go_pkg, span,
        ));
    }
}