lisette-semantics 0.1.26

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

use diagnostics::LocalSink;
use syntax::ast::Expression;
use syntax::program::UnusedInfo;

use crate::context::AnalysisContext;
use crate::facts::Facts;

mod ast_lints;
mod duplicate_bindings;
mod enum_variant_value;
mod generics;
mod irrefutable_patterns;
mod lints;
mod native_value_usage;
mod newtype;
pub mod pattern_analysis;
mod post_inference;
mod prelude_shadowing;
mod receivers;
mod ref_lints;
pub(crate) mod replaceable_with_zero_fill;
mod stringer_signature;
pub(crate) mod temp_producing;
mod unused_expressions;
mod visibility;

pub use lints::Lint;

pub(crate) struct ValidatorContext<'a> {
    pub typed_ast: &'a [Expression],
    pub module_id: &'a str,
    pub analysis: &'a AnalysisContext<'a>,
    pub facts: &'a mut Facts,
    pub sink: &'a LocalSink,
}

pub fn run(
    analysis: &AnalysisContext,
    facts: &mut Facts,
    sink: &LocalSink,
    unused: &mut UnusedInfo,
    run_lints: bool,
) {
    let store = analysis.store;

    for module in store.modules.values() {
        visibility::run_module(&module.id, store, sink);
        for file in module.files.values() {
            let mut ctx = ValidatorContext {
                typed_ast: &file.items,
                module_id: &module.id,
                analysis,
                facts,
                sink,
            };
            run_per_file(&mut ctx);
        }
    }

    let pattern_ctx = pattern_analysis::Context::new(analysis, &facts.or_pattern_error_spans);
    for module in store.modules.values() {
        for file in module.files.values() {
            for expression in &file.items {
                pattern_analysis::check(expression, &pattern_ctx, sink);
            }
        }
    }
    facts.pattern_issues = pattern_ctx.take_issues();

    if run_lints {
        lints::lint_all_facts(facts, unused, sink);
        lints::lint_all_modules(analysis, facts, sink, unused);
    }
}

fn run_per_file(ctx: &mut ValidatorContext<'_>) {
    let store = ctx.analysis.store;
    duplicate_bindings::run(ctx.typed_ast, ctx.sink);
    irrefutable_patterns::run(ctx.typed_ast, ctx.sink);
    receivers::run(ctx.typed_ast, ctx.sink);
    stringer_signature::run(ctx.typed_ast, ctx.sink);
    prelude_shadowing::run(ctx.typed_ast, store, ctx.sink);
    generics::run(ctx.typed_ast, ctx.module_id, store, ctx.facts, ctx.sink);
    newtype::run(ctx.typed_ast, store, ctx.sink);
    native_value_usage::run(ctx.typed_ast, ctx.module_id, store, ctx.sink);
    enum_variant_value::run(ctx.typed_ast, store, ctx.sink);
    temp_producing::run(ctx.typed_ast, ctx.sink);
    unused_expressions::run(ctx.typed_ast, ctx.module_id, store, ctx.facts);
    post_inference::run(ctx.facts, ctx.sink);
}