slang_solidity 1.3.5

A modular set of compiler APIs empowering the next generation of Solidity code analysis and developer tooling. Written in Rust and distributed in multiple languages.
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

use std::fmt;

use crate::cst::{TerminalKind, TextRange};
#[cfg(feature = "__private_ariadne_errors")]
use crate::diagnostic::{self, Diagnostic};

/// Represents an error that occurred during parsing.
///
/// This could have been caused by a syntax error, or by reaching the end of the file when more tokens were expected.
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ParseError {
    text_range: TextRange,
    terminals_that_would_have_allowed_more_progress: Vec<TerminalKind>,
}

impl ParseError {
    /// The text range at which the error occurred.
    pub fn text_range(&self) -> &TextRange {
        &self.text_range
    }

    /// Renders the message for this error.
    pub fn message(&self) -> String {
        // Uses the impl from `Display` above.
        self.to_string()
    }
}

impl ParseError {
    pub(crate) fn create(
        text_range: TextRange,
        mut terminals_that_would_have_allowed_more_progress: Vec<TerminalKind>,
    ) -> Self {
        terminals_that_would_have_allowed_more_progress.sort_unstable();
        terminals_that_would_have_allowed_more_progress.dedup();

        Self {
            text_range,
            terminals_that_would_have_allowed_more_progress,
        }
    }
}

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self
            .terminals_that_would_have_allowed_more_progress
            .is_empty()
        {
            return write!(f, "Expected end of file.");
        }

        let mut expected = self.terminals_that_would_have_allowed_more_progress.iter();

        let first = expected
            .next()
            .expect("we just checked that it's not empty");

        write!(f, "Expected {first}")?;

        for kind in expected {
            write!(f, " or {kind}")?;
        }

        write!(f, ".")
    }
}

#[cfg(feature = "__private_ariadne_errors")]
impl Diagnostic for ParseError {
    fn text_range(&self) -> TextRange {
        self.text_range.clone()
    }

    fn severity(&self) -> diagnostic::Severity {
        diagnostic::Severity::Error
    }

    fn message(&self) -> String {
        // Uses the impl from `Display` above.
        self.to_string()
    }
}