sqparse/ast/
type_.rs

1use crate::ast::{
2    Expression, FunctionRefParam, Identifier, SeparatedListTrailing0, SeparatedListTrailing1,
3    StructDefinition,
4};
5use crate::token::Token;
6
7/// A type.
8///
9/// Many types are recursive, containing other types. Unlike [expressions] types do not have
10/// precedence, and are all left-associative.
11///
12/// This means you can always decompose a type like this:
13/// ```text
14/// table<int>& ornull
15/// ^    ^^^^^^^^^^^^^ modifier types
16/// | base type
17/// ```
18///
19/// [expressions]: Expression
20#[derive(Debug, Clone)]
21pub enum Type<'s> {
22    Local(LocalType<'s>),
23    Plain(PlainType<'s>),
24    Array(ArrayType<'s>),
25    Generic(GenericType<'s>),
26    FunctionRef(FunctionRefType<'s>),
27    Struct(StructType<'s>),
28    Reference(ReferenceType<'s>),
29    Nullable(NullableType<'s>),
30}
31
32/// A `local` type.
33///
34/// Grammar: `local`
35#[derive(Debug, Clone)]
36pub struct LocalType<'s> {
37    pub local: &'s Token<'s>,
38}
39
40/// A named type.
41///
42/// Grammar: [Identifier]
43#[derive(Debug, Clone)]
44pub struct PlainType<'s> {
45    pub name: Identifier<'s>,
46}
47
48/// An anonymous struct type.
49///
50/// Grammar: `struct` [StructDefinition]
51#[derive(Debug, Clone)]
52pub struct StructType<'s> {
53    pub struct_: &'s Token<'s>,
54    pub definition: StructDefinition<'s>,
55}
56
57/// An array type.
58///
59/// Grammar: [Type] `[` [Expression] `]`
60#[derive(Debug, Clone)]
61pub struct ArrayType<'s> {
62    pub base: Box<Type<'s>>,
63    pub open: &'s Token<'s>,
64    pub len: Box<Expression<'s>>,
65    pub close: &'s Token<'s>,
66}
67
68/// A generic type.
69///
70/// Grammar: [Type] `<` [SeparatedListTrailing1]<[Type] `,`> `>`
71#[derive(Debug, Clone)]
72pub struct GenericType<'s> {
73    pub base: Box<Type<'s>>,
74    pub open: &'s Token<'s>,
75    pub params: SeparatedListTrailing1<'s, Type<'s>>,
76    pub close: &'s Token<'s>,
77}
78
79/// A function reference type.
80///
81/// Grammar: [Type]? `functionref` `(` [SeparatedListTrailing0]<[FunctionRefParam] `,`> `)`
82#[derive(Debug, Clone)]
83pub struct FunctionRefType<'s> {
84    pub return_type: Option<Box<Type<'s>>>,
85    pub functionref: &'s Token<'s>,
86    pub open: &'s Token<'s>,
87    pub params: SeparatedListTrailing0<'s, FunctionRefParam<'s>>,
88    pub close: &'s Token<'s>,
89}
90
91/// A reference type.
92///
93/// Grammar: [Type] `&`
94#[derive(Debug, Clone)]
95pub struct ReferenceType<'s> {
96    pub base: Box<Type<'s>>,
97    pub reference: &'s Token<'s>,
98}
99
100/// A nullable type.
101///
102/// Grammar: [Type] `ornull`
103#[derive(Debug, Clone)]
104pub struct NullableType<'s> {
105    pub base: Box<Type<'s>>,
106    pub ornull: &'s Token<'s>,
107}