lisette-semantics 0.2.13

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

//! Newtype-related invariants. A newtype (single-field, non-generic tuple
//! struct) compiles to a Go named scalar. `.0` is a cast, not a field — so
//! it's read-only (can't assign to) and non-addressable (can't take `&`).

use diagnostics::LocalSink;
use syntax::ast::{Expression, Span, UnaryOperator};
use syntax::types::{Type, unqualified_name};

use crate::store::Store;

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

fn visit_expression(expression: &Expression, store: &Store, sink: &LocalSink) {
    match expression {
        Expression::Assignment { target, span, .. } => {
            check_newtype_field_assignment(target, *span, store, sink);
            if has_map_field_in_chain(target) {
                sink.push(diagnostics::infer::map_field_chain_assignment(*span));
            }
        }
        Expression::Reference {
            expression, span, ..
        } if targets_newtype_field(expression, store) => {
            sink.push(diagnostics::infer::reference_through_newtype(*span));
        }
        _ => {}
    }
    for child in expression.children() {
        visit_expression(child, store, sink);
    }
}

fn check_newtype_field_assignment(
    target: &Expression,
    span: Span,
    store: &Store,
    sink: &LocalSink,
) {
    match target {
        Expression::DotAccess {
            expression, member, ..
        } => {
            if member == "0"
                && let Type::Nominal { id, .. } = expression.get_type().strip_refs()
                && let Some(def) = store.get_definition(id.as_str())
                && def.is_newtype()
            {
                let type_name = unqualified_name(&id);
                sink.push(diagnostics::infer::newtype_field_assignment(
                    type_name, span,
                ));
                return;
            }
            check_newtype_field_assignment(expression, span, store, sink);
        }
        Expression::IndexedAccess { expression, .. } => {
            check_newtype_field_assignment(expression, span, store, sink);
        }
        Expression::Unary {
            operator: UnaryOperator::Deref,
            expression,
            ..
        } => {
            check_newtype_field_assignment(expression, span, store, sink);
        }
        _ => {}
    }
}

fn targets_newtype_field(expression: &Expression, store: &Store) -> bool {
    let mut current = expression.unwrap_parens();
    while let Expression::DotAccess {
        expression: inner,
        member,
        ..
    } = current
    {
        if member.parse::<usize>().is_ok()
            && let Type::Nominal { id, .. } = inner.get_type().strip_refs()
            && let Some(def) = store.get_definition(id.as_str())
            && def.is_newtype()
        {
            return true;
        }
        current = inner.unwrap_parens();
    }
    false
}

fn has_map_field_in_chain(expression: &Expression) -> bool {
    match expression.unwrap_parens() {
        Expression::DotAccess { expression, .. } => {
            is_map_indexed_access(expression) || has_map_field_in_chain(expression)
        }
        _ => false,
    }
}

fn is_map_indexed_access(expression: &Expression) -> bool {
    match expression.unwrap_parens() {
        Expression::IndexedAccess { expression, .. } => expression.get_type().has_name("Map"),
        _ => false,
    }
}