Skip to main content

scarf_syntax/source_text/
class_items.rs

1// =======================================================================
2// class_items.rs
3// =======================================================================
4// CST Nodes from 1800-2023 A.1.9
5use crate::*;
6
7#[derive(Clone, Debug, PartialEq)]
8pub enum ClassItem<'a> {
9    Property(Box<(Vec<AttributeInstance<'a>>, ClassProperty<'a>)>),
10    Method(Box<(Vec<AttributeInstance<'a>>, ClassMethod<'a>)>),
11    Constraint(Box<(Vec<AttributeInstance<'a>>, ClassConstraint<'a>)>),
12    Declaration(Box<(Vec<AttributeInstance<'a>>, ClassDeclaration<'a>)>),
13    InterfaceDeclaration(
14        Box<(Vec<AttributeInstance<'a>>, InterfaceClassDeclaration<'a>)>,
15    ),
16    Covergroup(Box<(Vec<AttributeInstance<'a>>, CovergroupDeclaration<'a>)>),
17    LocalParameter(
18        Box<(
19            LocalParameterDeclaration<'a>,
20            Metadata<'a>, // ;
21        )>,
22    ),
23    Parameter(
24        Box<(
25            ParameterDeclaration<'a>,
26            Metadata<'a>, // ;
27        )>,
28    ),
29    Null(Box<Metadata<'a>>),
30}
31
32#[derive(Clone, Debug, PartialEq)]
33pub enum ClassProperty<'a> {
34    Data(Box<(Vec<PropertyQualifier<'a>>, DataDeclaration<'a>)>),
35    Const(
36        Box<(
37            Metadata<'a>, // const
38            Vec<ClassItemQualifier<'a>>,
39            DataType<'a>,
40            ConstIdentifier<'a>,
41            Option<(
42                Metadata<'a>, // =
43                ConstantExpression<'a>,
44            )>,
45            Metadata<'a>, // ;
46        )>,
47    ),
48}
49
50#[derive(Clone, Debug, PartialEq)]
51pub enum ClassMethod<'a> {
52    Task(Box<(Vec<MethodQualifier<'a>>, TaskDeclaration<'a>)>),
53    Function(Box<(Vec<MethodQualifier<'a>>, FunctionDeclaration<'a>)>),
54    PureVirtualMethod(
55        Box<(
56            Metadata<'a>, // pure
57            Metadata<'a>, // virtual
58            Vec<ClassItemQualifier<'a>>,
59            MethodPrototype<'a>,
60            Metadata<'a>, // ;
61        )>,
62    ),
63    ExternMethod(
64        Box<(
65            Metadata<'a>, // extern
66            Vec<MethodQualifier<'a>>,
67            MethodPrototype<'a>,
68            Metadata<'a>, // ;
69        )>,
70    ),
71    ConstructorDeclaration(
72        Box<(Vec<MethodQualifier<'a>>, ClassConstructorDeclaration<'a>)>,
73    ),
74    ConstructorPrototype(
75        Box<(
76            Metadata<'a>, // extern
77            Vec<MethodQualifier<'a>>,
78            ClassConstructorPrototype<'a>,
79        )>,
80    ),
81}
82
83#[derive(Clone, Debug, PartialEq)]
84pub enum ListOfArgumentsOrDefault<'a> {
85    ListOfArguments(Box<ListOfArguments<'a>>),
86    Default(Box<Metadata<'a>>),
87}
88
89#[derive(Clone, Debug, PartialEq)]
90pub struct ClassConstructorDeclaration<'a>(
91    pub Metadata<'a>, // function
92    pub Option<ClassScope<'a>>,
93    pub Metadata<'a>, // new
94    pub  Option<(
95        Metadata<'a>, // (
96        Option<ClassConstructorArgList<'a>>,
97        Metadata<'a>, // )
98    )>,
99    pub Metadata<'a>, // ;
100    pub Vec<BlockItemDeclaration<'a>>,
101    pub  Option<(
102        Metadata<'a>, // super
103        Metadata<'a>, // .
104        Metadata<'a>, // new
105        Option<(
106            Metadata<'a>, // (
107            Option<ListOfArgumentsOrDefault<'a>>,
108            Metadata<'a>, // )
109        )>,
110        Metadata<'a>, // ;
111    )>,
112    pub Vec<FunctionStatementOrNull<'a>>,
113    pub Metadata<'a>, // endfunction
114    pub  Option<(
115        Metadata<'a>, // :
116        Metadata<'a>, // new
117    )>,
118);
119
120#[derive(Clone, Debug, PartialEq)]
121pub struct ClassConstructorPrototype<'a>(
122    pub Metadata<'a>, // function
123    pub Metadata<'a>, // new
124    pub  Option<(
125        Metadata<'a>, // (
126        Option<ClassConstructorArgList<'a>>,
127        Metadata<'a>, // )
128    )>,
129    pub Metadata<'a>, // ;
130);
131
132#[derive(Clone, Debug, PartialEq)]
133pub struct ClassConstructorArgList<'a>(
134    pub ClassConstructorArg<'a>,
135    pub  Vec<(
136        Metadata<'a>, // ,
137        ClassConstructorArg<'a>,
138    )>,
139);
140
141#[derive(Clone, Debug, PartialEq)]
142pub enum ClassConstructorArg<'a> {
143    TfPort(Box<TfPortItem<'a>>),
144    Default(Box<Metadata<'a>>),
145}
146
147#[derive(Clone, Debug, PartialEq)]
148pub enum InterfaceClassItem<'a> {
149    Type(Box<TypeDeclaration<'a>>),
150    InterfaceClass(Box<(Vec<AttributeInstance<'a>>, InterfaceClassMethod<'a>)>),
151    LocalParameter(
152        Box<(
153            LocalParameterDeclaration<'a>,
154            Metadata<'a>, // ;
155        )>,
156    ),
157    Parameter(
158        Box<(
159            ParameterDeclaration<'a>,
160            Metadata<'a>, // ;
161        )>,
162    ),
163    Null(Box<Metadata<'a>>),
164}
165
166#[derive(Clone, Debug, PartialEq)]
167pub struct InterfaceClassMethod<'a>(
168    pub Metadata<'a>, // pure
169    pub Metadata<'a>, // virtual
170    pub MethodPrototype<'a>,
171    pub Metadata<'a>, // ;
172);
173
174#[derive(Clone, Debug, PartialEq)]
175pub enum ClassConstraint<'a> {
176    Prototype(Box<ConstraintPrototype<'a>>),
177    Declaration(Box<ConstraintDeclaration<'a>>),
178}
179
180#[derive(Clone, Debug, PartialEq)]
181pub enum ClassItemQualifier<'a> {
182    Static(Metadata<'a>),
183    Protected(Metadata<'a>),
184    Local(Metadata<'a>),
185}
186
187#[derive(Clone, Debug, PartialEq)]
188pub enum PropertyQualifier<'a> {
189    Random(Box<RandomQualifier<'a>>),
190    ClassItem(Box<ClassItemQualifier<'a>>),
191}
192
193#[derive(Clone, Debug, PartialEq)]
194pub enum RandomQualifier<'a> {
195    Rand(Metadata<'a>),
196    Randc(Metadata<'a>),
197}
198
199#[derive(Clone, Debug, PartialEq)]
200pub enum MethodQualifier<'a> {
201    PureVirtual(
202        Box<(
203            Option<Metadata<'a>>, // pure
204            Metadata<'a>,         // virtual
205        )>,
206    ),
207    ClassItem(Box<ClassItemQualifier<'a>>),
208}
209
210#[derive(Clone, Debug, PartialEq)]
211pub enum MethodPrototype<'a> {
212    Task(Box<TaskPrototype<'a>>),
213    Function(Box<FunctionPrototype<'a>>),
214}