mago-codex 1.15.2

PHP type system representation, comparison logic, and codebase metadata for static analysis.
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

use mago_span::HasSpan;
use mago_span::Span;
use serde::Serialize;

use mago_type_syntax::error::ParseError;

#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
pub enum TypeError {
    ParseError(ParseError),
    UnsupportedType(String, Span),
    InvalidType(String, String, Span),
}

impl std::fmt::Display for TypeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TypeError::ParseError(err) => write!(f, "{err}"),
            TypeError::UnsupportedType(ty, _) => {
                write!(f, "The type `{ty}` is not supported.")
            }
            TypeError::InvalidType(_, message, _) => {
                write!(f, "{message}")
            }
        }
    }
}

impl TypeError {
    #[must_use]
    pub fn note(&self) -> String {
        match self {
            TypeError::ParseError(err) => err.note(),
            TypeError::UnsupportedType(ty, _) => {
                format!("The type `{ty}` is syntactically valid but is not yet supported.")
            }
            TypeError::InvalidType(ty, _, _) => {
                format!("The type declaration `{ty}` is not valid or could not be resolved.")
            }
        }
    }

    #[must_use]
    pub fn help(&self) -> String {
        match self {
            TypeError::ParseError(err) => err.help(),
            TypeError::UnsupportedType(_, _) => "Try using a simpler or more standard type declaration.".to_string(),
            TypeError::InvalidType(_, _, _) => {
                "Check for typos or ensure the type is a valid class, interface, or built-in type.".to_string()
            }
        }
    }
}

// Ensure HasSpan is implemented for TypeError to get the location of the error
impl HasSpan for TypeError {
    fn span(&self) -> Span {
        match self {
            TypeError::ParseError(err) => err.span(),
            TypeError::UnsupportedType(_, span) | TypeError::InvalidType(_, _, span) => *span,
        }
    }
}

impl From<ParseError> for TypeError {
    fn from(err: ParseError) -> Self {
        TypeError::ParseError(err)
    }
}