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

//! Reject user type declarations and generic parameters named after the Go
//! predeclared identifiers `any` and `comparable`. The emitter prints those
//! names directly for `Unknown` and for unconstrained / map-key generic
//! constraints, so a user declaration of the same name shadows the builtin and
//! the generated Go fails to compile.

use diagnostics::LocalSink;
use syntax::ast::{Expression, Generic};

pub(crate) fn run(typed_ast: &[Expression], sink: &LocalSink) {
    for item in typed_ast {
        visit(item, sink);
    }
}

fn visit(expression: &Expression, sink: &LocalSink) {
    check_type_name(expression, sink);
    for generic in generics_of(expression) {
        if is_reserved(&generic.name) {
            sink.push(diagnostics::infer::predeclared_type_shadowed(
                &generic.name,
                generic.span,
            ));
        }
    }
    for child in expression.children() {
        visit(child, sink);
    }
}

fn check_type_name(expression: &Expression, sink: &LocalSink) {
    let (name, name_span) = match expression {
        Expression::Enum {
            name, name_span, ..
        }
        | Expression::ValueEnum {
            name, name_span, ..
        }
        | Expression::Struct {
            name, name_span, ..
        }
        | Expression::TypeAlias {
            name, name_span, ..
        }
        | Expression::Interface {
            name, name_span, ..
        } => (name, name_span),
        _ => return,
    };
    if is_reserved(name) {
        sink.push(diagnostics::infer::predeclared_type_shadowed(
            name, *name_span,
        ));
    }
}

fn generics_of(expression: &Expression) -> &[Generic] {
    match expression {
        Expression::Function { generics, .. }
        | Expression::ImplBlock { generics, .. }
        | Expression::Enum { generics, .. }
        | Expression::Struct { generics, .. }
        | Expression::TypeAlias { generics, .. }
        | Expression::Interface { generics, .. } => generics,
        _ => &[],
    }
}

fn is_reserved(name: &str) -> bool {
    matches!(name, "any" | "comparable")
}