mago-type-syntax 1.7.0

Provides core utilities useful for building lexers and parsers within Mago.
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

use serde::Serialize;

use mago_span::HasSpan;
use mago_span::Span;

use crate::ast::generics::GenericParameters;
use crate::ast::identifier::Identifier;

#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord)]
pub struct ReferenceType<'input> {
    pub identifier: Identifier<'input>,
    pub parameters: Option<GenericParameters<'input>>,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord)]
pub enum MemberReferenceSelector<'input> {
    Wildcard(Span),
    Identifier(Identifier<'input>),
    StartsWith(Identifier<'input>, Span),
    EndsWith(Span, Identifier<'input>),
}

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Serialize, PartialOrd, Ord)]
pub struct MemberReferenceType<'input> {
    pub class: Identifier<'input>,
    pub double_colon: Span,
    pub member: MemberReferenceSelector<'input>,
}

impl HasSpan for ReferenceType<'_> {
    fn span(&self) -> Span {
        match &self.parameters {
            Some(parameters) => self.identifier.span.join(parameters.span()),
            None => self.identifier.span,
        }
    }
}

impl HasSpan for MemberReferenceSelector<'_> {
    fn span(&self) -> Span {
        match self {
            MemberReferenceSelector::Wildcard(span) => *span,
            MemberReferenceSelector::Identifier(identifier) => identifier.span,
            MemberReferenceSelector::StartsWith(identifier, span) => identifier.span.join(*span),
            MemberReferenceSelector::EndsWith(span, identifier) => span.join(identifier.span),
        }
    }
}

impl HasSpan for MemberReferenceType<'_> {
    fn span(&self) -> Span {
        self.class.span.join(self.member.span())
    }
}

impl std::fmt::Display for ReferenceType<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(parameters) = &self.parameters {
            write!(f, "{}{}", self.identifier, parameters)
        } else {
            write!(f, "{}", self.identifier)
        }
    }
}

impl std::fmt::Display for MemberReferenceSelector<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MemberReferenceSelector::Wildcard(_) => write!(f, "*"),
            MemberReferenceSelector::Identifier(identifier) => write!(f, "{identifier}"),
            MemberReferenceSelector::StartsWith(identifier, _) => write!(f, "{identifier}*"),
            MemberReferenceSelector::EndsWith(_, identifier) => write!(f, "*{identifier}"),
        }
    }
}

impl std::fmt::Display for MemberReferenceType<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}::{}", self.class, self.member)
    }
}