repl_core/dsl/
ast.rs

1//! Abstract Syntax Tree definitions for the Symbiont DSL
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::time::Duration;
6
7/// Source location information for error reporting and debugging
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9pub struct SourceLocation {
10    pub line: usize,
11    pub column: usize,
12    pub offset: usize,
13}
14
15/// Span of source code
16#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
17pub struct Span {
18    pub start: SourceLocation,
19    pub end: SourceLocation,
20}
21
22/// Root AST node representing a complete DSL program
23#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
24pub struct Program {
25    pub declarations: Vec<Declaration>,
26    pub span: Span,
27}
28
29/// Top-level declarations in the DSL
30#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
31pub enum Declaration {
32    Agent(AgentDefinition),
33    Behavior(BehaviorDefinition),
34    Function(FunctionDefinition),
35    EventHandler(EventHandler),
36    Struct(StructDefinition),
37}
38
39/// Agent definition
40#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
41pub struct AgentDefinition {
42    pub name: String,
43    pub metadata: AgentMetadata,
44    pub resources: Option<ResourceConfig>,
45    pub security: Option<SecurityConfig>,
46    pub policies: Option<PolicyConfig>,
47    pub span: Span,
48}
49
50/// Agent metadata
51#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
52pub struct AgentMetadata {
53    pub name: Option<String>,
54    pub version: Option<String>,
55    pub author: Option<String>,
56    pub description: Option<String>,
57}
58
59/// Resource configuration
60#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
61pub struct ResourceConfig {
62    pub memory: Option<SizeValue>,
63    pub cpu: Option<DurationValue>,
64    pub network: Option<bool>,
65    pub storage: Option<SizeValue>,
66}
67
68/// Security configuration
69#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
70pub struct SecurityConfig {
71    pub tier: Option<SecurityTier>,
72    pub capabilities: Vec<String>,
73    pub sandbox: Option<SandboxMode>,
74}
75
76/// Security tier levels
77#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
78pub enum SecurityTier {
79    Tier1,
80    Tier2,
81    Tier3,
82    Tier4,
83}
84
85/// Sandbox modes
86#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
87pub enum SandboxMode {
88    Strict,
89    Moderate,
90    Permissive,
91}
92
93/// Policy configuration
94#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
95pub struct PolicyConfig {
96    pub execution_timeout: Option<DurationValue>,
97    pub retry_count: Option<u32>,
98    pub failure_action: Option<FailureAction>,
99}
100
101/// Failure actions
102#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
103pub enum FailureAction {
104    Terminate,
105    Restart,
106    Escalate,
107    Ignore,
108}
109
110/// Behavior definition
111#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
112pub struct BehaviorDefinition {
113    pub name: String,
114    pub input: Option<ParameterList>,
115    pub output: Option<ParameterList>,
116    pub steps: Block,
117    pub span: Span,
118}
119
120/// Function definition
121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
122pub struct FunctionDefinition {
123    pub name: String,
124    pub parameters: ParameterList,
125    pub return_type: Option<Type>,
126    pub body: Block,
127    pub span: Span,
128}
129
130/// Event handler definition
131#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
132pub struct EventHandler {
133    pub event_name: String,
134    pub parameters: ParameterList,
135    pub body: Block,
136    pub span: Span,
137}
138
139/// Struct definition
140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
141pub struct StructDefinition {
142    pub name: String,
143    pub fields: Vec<StructField>,
144    pub span: Span,
145}
146
147/// Struct field
148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
149pub struct StructField {
150    pub name: String,
151    pub field_type: Type,
152    pub span: Span,
153}
154
155/// Parameter list for functions and behaviors
156#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
157pub struct ParameterList {
158    pub parameters: Vec<Parameter>,
159}
160
161/// Parameter definition
162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
163pub struct Parameter {
164    pub name: String,
165    pub param_type: Type,
166    pub default_value: Option<Expression>,
167    pub span: Span,
168}
169
170/// Type definitions
171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
172pub enum Type {
173    String,
174    Number,
175    Boolean,
176    DateTime,
177    Duration,
178    Size,
179    List(Box<Type>),
180    Map(Box<Type>, Box<Type>),
181    Optional(Box<Type>),
182    Custom(String),
183    Any,
184}
185
186/// Block of statements
187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
188pub struct Block {
189    pub statements: Vec<Statement>,
190    pub span: Span,
191}
192
193/// Statement types
194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
195pub enum Statement {
196    Let(LetStatement),
197    If(IfStatement),
198    Match(MatchStatement),
199    For(ForStatement),
200    While(WhileStatement),
201    Try(TryStatement),
202    Return(ReturnStatement),
203    Emit(EmitStatement),
204    Require(RequireStatement),
205    Check(CheckStatement),
206    Expression(Expression),
207}
208
209/// Let statement for variable binding
210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
211pub struct LetStatement {
212    pub name: String,
213    pub var_type: Option<Type>,
214    pub value: Expression,
215    pub span: Span,
216}
217
218/// If statement
219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
220pub struct IfStatement {
221    pub condition: Expression,
222    pub then_block: Block,
223    pub else_ifs: Vec<ElseIf>,
224    pub else_block: Option<Block>,
225    pub span: Span,
226}
227
228/// Else-if clause
229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
230pub struct ElseIf {
231    pub condition: Expression,
232    pub block: Block,
233    pub span: Span,
234}
235
236/// Match statement for pattern matching
237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
238pub struct MatchStatement {
239    pub expression: Expression,
240    pub arms: Vec<MatchArm>,
241    pub span: Span,
242}
243
244/// Match arm
245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
246pub struct MatchArm {
247    pub pattern: Pattern,
248    pub body: Expression,
249    pub span: Span,
250}
251
252/// Pattern for matching
253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
254pub enum Pattern {
255    Literal(Literal),
256    Wildcard,
257    Identifier(String),
258}
259
260/// For loop statement
261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
262pub struct ForStatement {
263    pub variable: String,
264    pub iterable: Expression,
265    pub body: Block,
266    pub span: Span,
267}
268
269/// While loop statement
270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
271pub struct WhileStatement {
272    pub condition: Expression,
273    pub body: Block,
274    pub span: Span,
275}
276
277/// Try-catch statement
278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
279pub struct TryStatement {
280    pub try_block: Block,
281    pub catch_variable: Option<String>,
282    pub catch_block: Block,
283    pub span: Span,
284}
285
286/// Return statement
287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
288pub struct ReturnStatement {
289    pub value: Option<Expression>,
290    pub span: Span,
291}
292
293/// Emit statement for events
294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
295pub struct EmitStatement {
296    pub event_name: String,
297    pub data: Option<Expression>,
298    pub span: Span,
299}
300
301/// Require statement for capabilities
302#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
303pub struct RequireStatement {
304    pub requirement: RequirementType,
305    pub span: Span,
306}
307
308/// Requirement types
309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
310pub enum RequirementType {
311    Capability(String),
312    Capabilities(Vec<String>),
313}
314
315/// Check statement for policies
316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
317pub struct CheckStatement {
318    pub policy_name: String,
319    pub span: Span,
320}
321
322/// Expression types
323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
324pub enum Expression {
325    Literal(Literal),
326    Identifier(Identifier),
327    FieldAccess(FieldAccess),
328    IndexAccess(IndexAccess),
329    FunctionCall(FunctionCall),
330    MethodCall(MethodCall),
331    BinaryOp(BinaryOperation),
332    UnaryOp(UnaryOperation),
333    Assignment(Assignment),
334    List(ListExpression),
335    Map(MapExpression),
336    Invoke(InvokeExpression),
337    Lambda(LambdaExpression),
338    Conditional(ConditionalExpression),
339}
340
341/// Literal values
342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
343pub enum Literal {
344    String(String),
345    Number(f64),
346    Integer(i64),
347    Boolean(bool),
348    Null,
349    Duration(DurationValue),
350    Size(SizeValue),
351}
352
353/// Duration value with unit
354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
355pub struct DurationValue {
356    pub value: u64,
357    pub unit: DurationUnit,
358}
359
360/// Duration units
361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
362pub enum DurationUnit {
363    Seconds,
364    Minutes,
365    Hours,
366    Days,
367    Milliseconds,
368}
369
370/// Size value with unit
371#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
372pub struct SizeValue {
373    pub value: u64,
374    pub unit: SizeUnit,
375}
376
377/// Size units
378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
379pub enum SizeUnit {
380    Bytes,
381    KB,
382    MB,
383    GB,
384    TB,
385}
386
387/// Identifier
388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
389pub struct Identifier {
390    pub name: String,
391    pub span: Span,
392}
393
394/// Field access (e.g., obj.field)
395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
396pub struct FieldAccess {
397    pub object: Box<Expression>,
398    pub field: String,
399    pub span: Span,
400}
401
402/// Index access (e.g., arr[0])
403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
404pub struct IndexAccess {
405    pub object: Box<Expression>,
406    pub index: Box<Expression>,
407    pub span: Span,
408}
409
410/// Function call
411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
412pub struct FunctionCall {
413    pub function: String,
414    pub arguments: Vec<Expression>,
415    pub span: Span,
416}
417
418/// Method call (e.g., obj.method(args))
419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
420pub struct MethodCall {
421    pub object: Box<Expression>,
422    pub method: String,
423    pub arguments: Vec<Expression>,
424    pub span: Span,
425}
426
427/// Binary operation
428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
429pub struct BinaryOperation {
430    pub left: Box<Expression>,
431    pub operator: BinaryOperator,
432    pub right: Box<Expression>,
433    pub span: Span,
434}
435
436/// Binary operators
437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
438pub enum BinaryOperator {
439    Add,
440    Subtract,
441    Multiply,
442    Divide,
443    Modulo,
444    Equal,
445    NotEqual,
446    LessThan,
447    LessThanOrEqual,
448    GreaterThan,
449    GreaterThanOrEqual,
450    And,
451    Or,
452    BitwiseAnd,
453    BitwiseOr,
454    BitwiseXor,
455    LeftShift,
456    RightShift,
457}
458
459/// Unary operation
460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
461pub struct UnaryOperation {
462    pub operator: UnaryOperator,
463    pub operand: Box<Expression>,
464    pub span: Span,
465}
466
467/// Unary operators
468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
469pub enum UnaryOperator {
470    Not,
471    Negate,
472    BitwiseNot,
473}
474
475/// Assignment expression
476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
477pub struct Assignment {
478    pub target: Box<Expression>,
479    pub value: Box<Expression>,
480    pub span: Span,
481}
482
483/// List expression
484#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
485pub struct ListExpression {
486    pub elements: Vec<Expression>,
487    pub span: Span,
488}
489
490/// Map expression
491#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
492pub struct MapExpression {
493    pub entries: Vec<MapEntry>,
494    pub span: Span,
495}
496
497/// Map entry
498#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
499pub struct MapEntry {
500    pub key: Expression,
501    pub value: Expression,
502    pub span: Span,
503}
504
505/// Invoke expression for behavior invocation
506#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
507pub struct InvokeExpression {
508    pub behavior: String,
509    pub arguments: HashMap<String, Expression>,
510    pub span: Span,
511}
512
513/// Lambda expression
514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
515pub struct LambdaExpression {
516    pub parameters: Vec<String>,
517    pub body: Box<Expression>,
518    pub span: Span,
519}
520
521/// Conditional expression (ternary operator)
522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
523pub struct ConditionalExpression {
524    pub condition: Box<Expression>,
525    pub if_true: Box<Expression>,
526    pub if_false: Box<Expression>,
527    pub span: Span,
528}
529
530impl DurationValue {
531    /// Convert to standard Duration
532    pub fn to_duration(&self) -> Duration {
533        match self.unit {
534            DurationUnit::Milliseconds => Duration::from_millis(self.value),
535            DurationUnit::Seconds => Duration::from_secs(self.value),
536            DurationUnit::Minutes => Duration::from_secs(self.value * 60),
537            DurationUnit::Hours => Duration::from_secs(self.value * 3600),
538            DurationUnit::Days => Duration::from_secs(self.value * 86400),
539        }
540    }
541}
542
543impl SizeValue {
544    /// Convert to bytes
545    pub fn to_bytes(&self) -> u64 {
546        match self.unit {
547            SizeUnit::Bytes => self.value,
548            SizeUnit::KB => self.value * 1024,
549            SizeUnit::MB => self.value * 1024 * 1024,
550            SizeUnit::GB => self.value * 1024 * 1024 * 1024,
551            SizeUnit::TB => self.value * 1024 * 1024 * 1024 * 1024,
552        }
553    }
554}
555
556/// Visitor trait for traversing the AST
557pub trait AstVisitor {
558    type Output;
559
560    fn visit_program(&mut self, program: &Program) -> Self::Output;
561    fn visit_declaration(&mut self, declaration: &Declaration) -> Self::Output;
562    fn visit_statement(&mut self, statement: &Statement) -> Self::Output;
563    fn visit_expression(&mut self, expression: &Expression) -> Self::Output;
564}
565
566/// Mutable visitor trait for transforming the AST
567pub trait AstVisitorMut {
568    fn visit_program_mut(&mut self, program: &mut Program);
569    fn visit_declaration_mut(&mut self, declaration: &mut Declaration);
570    fn visit_statement_mut(&mut self, statement: &mut Statement);
571    fn visit_expression_mut(&mut self, expression: &mut Expression);
572}
repl_core/dsl/ast.rs

repl_core/dsl/
ast.rs
