loalang 0.1.20

Loa is a general-purpose, purely immutable, object-oriented programming language.
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

pub mod from_loa {
    use loa;
    use lsp_types as lsp;

    pub fn span_to_location(span: loa::Span) -> lsp::Location {
        lsp::Location {
            uri: uri_to_url(&span.start.uri),
            range: span_to_range(span),
        }
    }

    pub fn uri_to_url(uri: &loa::URI) -> lsp::Url {
        lsp::Url::parse(format!("{}", uri).as_str()).unwrap()
    }

    pub fn span_to_range(span: loa::Span) -> lsp::Range {
        lsp::Range {
            start: location_to_position(span.start),
            end: location_to_position(span.end),
        }
    }

    pub fn location_to_position(location: loa::Location) -> lsp::Position {
        lsp::Position {
            line: (location.line - 1) as u64,
            character: (location.character - 1) as u64,
        }
    }

    pub fn diagnostics_to_diagnostics(diagnostics: Vec<loa::Diagnostic>) -> Vec<lsp::Diagnostic> {
        diagnostics
            .into_iter()
            .map(diagnostic_to_diagnostic)
            .collect()
    }

    pub fn diagnostic_to_diagnostic(diagnostic: loa::Diagnostic) -> lsp::Diagnostic {
        lsp::Diagnostic {
            range: span_to_range(diagnostic.span().clone()),
            severity: Some(level_to_severity(diagnostic.level())),
            code: Some(lsp::NumberOrString::Number(diagnostic.code() as u64)),
            source: None,
            message: diagnostic.to_string(),
            related_information: None,
        }
    }

    pub fn level_to_severity(level: loa::DiagnosticLevel) -> lsp::DiagnosticSeverity {
        match level {
            loa::DiagnosticLevel::Error => lsp::DiagnosticSeverity::Error,
            loa::DiagnosticLevel::Warning => lsp::DiagnosticSeverity::Warning,
            loa::DiagnosticLevel::Info => lsp::DiagnosticSeverity::Information,
        }
    }
}

pub mod from_lsp {
    use loa;
    use lsp_types as lsp;

    pub fn url_to_uri(url: &lsp::Url) -> loa::URI {
        loa::URI::Exact(url.as_str().into())
    }

    pub fn position_params(params: lsp::TextDocumentPositionParams) -> (loa::URI, (usize, usize)) {
        let uri = url_to_uri(&params.text_document.uri);
        (uri, position(params.position))
    }

    pub fn range(range: lsp::Range) -> ((usize, usize), (usize, usize)) {
        (position(range.start), position(range.end))
    }

    pub fn position(position: lsp::Position) -> (usize, usize) {
        (position.line as usize + 1, position.character as usize + 1)
    }

    pub fn diagnostic_to_diagnostic(
        span: loa::Span,
        diagnostic: lsp::Diagnostic,
    ) -> Option<loa::Diagnostic> {
        match diagnostic.code {
            Some(lsp::NumberOrString::Number(2)) => Some(loa::Diagnostic::UndefinedTypeReference(
                span,
                diagnostic.message[1..diagnostic.message.len() - 15].into(),
            )),
            Some(lsp::NumberOrString::Number(3)) => Some(loa::Diagnostic::UndefinedReference(
                span,
                diagnostic.message[1..diagnostic.message.len() - 15].into(),
            )),
            _ => None,
        }
    }
}