circom_lsp_program_structure/abstract_syntax_tree/
ast_shortcuts.rs

1use super::ast::*;
2use super::expression_builders::*;
3use super::statement_builders::*;
4use crate::ast::{Access, Expression, VariableType};
5use num_bigint::BigInt;
6
7#[derive(Clone)]
8pub struct Symbol {
9    pub name: String,
10    pub is_array: Vec<Expression>,
11    pub init: Option<Expression>,
12}
13
14pub struct TupleInit{
15    pub tuple_init : (AssignOp,Expression)
16}
17
18pub fn assign_with_op_shortcut(
19    op: ExpressionInfixOpcode,
20    meta: Meta,
21    variable: (String, Vec<Access>),
22    rhe: Expression,
23) -> Statement {
24    let (var, access) = variable;
25    let variable = build_variable(meta.clone(), var.clone(), access.clone());
26    let infix = build_infix(meta.clone(), variable, op, rhe);
27    build_substitution(meta, var, access, AssignOp::AssignVar, infix)
28}
29
30pub fn plusplus(meta: Meta, variable: (String, Vec<Access>)) -> Statement {
31    let one = build_number(meta.clone(), BigInt::from(1));
32    assign_with_op_shortcut(ExpressionInfixOpcode::Add, meta, variable, one)
33}
34
35pub fn subsub(meta: Meta, variable: (String, Vec<Access>)) -> Statement {
36    let one = build_number(meta.clone(), BigInt::from(1));
37    assign_with_op_shortcut(ExpressionInfixOpcode::Sub, meta, variable, one)
38}
39
40pub fn for_into_while(
41    meta: Meta,
42    init: Statement,
43    cond: Expression,
44    step: Statement,
45    body: Statement,
46) -> Statement {
47    let while_body = build_block(body.get_meta().clone(), vec![body, step]);
48    let while_statement = build_while_block(meta.clone(), cond, while_body);
49    build_block(meta, vec![init, while_statement])
50}
51
52pub fn split_declaration_into_single_nodes(
53    meta: Meta,
54    xtype: VariableType,
55    symbols: Vec<Symbol>,
56    op: AssignOp,
57) -> Statement {
58    use crate::ast_shortcuts::VariableType::Var;
59
60    let mut initializations = Vec::new();
61
62    for symbol in symbols {
63        let with_meta = meta.clone();
64        let has_type = xtype.clone();
65        let name = symbol.name.clone();
66        let dimensions = symbol.is_array;
67        let possible_init = symbol.init;
68        let single_declaration = build_declaration(with_meta, has_type, name, dimensions.clone());
69        initializations.push(single_declaration);
70        if let Option::Some(init) = possible_init {
71            let substitution =
72                build_substitution(meta.clone(), symbol.name, vec![], op, init);
73            initializations.push(substitution);
74        }
75        else if xtype == Var {
76            let mut value = Expression:: Number(meta.clone(), BigInt::from(0));
77            for dim_expr in dimensions.iter().rev(){
78                value = build_uniform_array(meta.clone(), value, dim_expr.clone());
79            }
80
81            let substitution = 
82                build_substitution(meta.clone(), symbol.name, vec![], op, value);
83            initializations.push(substitution);
84        }
85    }
86    build_initialization_block(meta, xtype, initializations)
87}
88
89pub fn split_declaration_into_single_nodes_and_multisubstitution(
90    meta: Meta,
91    xtype: VariableType,
92    symbols: Vec<Symbol>,
93    init: Option<TupleInit>,
94) -> Statement {
95    use crate::ast_shortcuts::VariableType::Var;
96
97    let mut initializations = Vec::new();
98    let mut values = Vec::new();
99    for symbol in symbols {
100        let with_meta = meta.clone();
101        let has_type = xtype.clone();
102        let name = symbol.name.clone();
103        let dimensions = symbol.is_array;
104        debug_assert!(symbol.init.is_none());
105        let single_declaration = build_declaration(with_meta.clone(), has_type, name.clone(), dimensions.clone());
106        initializations.push(single_declaration);
107        if xtype == Var && init.is_none() {
108            let mut value = Expression:: Number(meta.clone(), BigInt::from(0));
109            for dim_expr in dimensions.iter().rev(){
110                value = build_uniform_array(meta.clone(), value, dim_expr.clone());
111            }
112
113            let substitution = 
114                build_substitution(meta.clone(), symbol.name, vec![], AssignOp::AssignVar, value);
115            initializations.push(substitution);
116        }
117        values.push(Expression::Variable { meta: with_meta.clone(), name: name, access: Vec::new() })
118    }
119    if let Some( tuple) = init {
120        let (op,expression) = tuple.tuple_init;
121        let multi_sub = build_mult_substitution(meta.clone(), build_tuple(meta.clone(), values), op, expression);
122        initializations.push(multi_sub);
123    }
124    build_initialization_block(meta, xtype, initializations)
125}
circom_lsp_program_structure/abstract_syntax_tree/ast_shortcuts.rs

circom_lsp_program_structure/abstract_syntax_tree/
ast_shortcuts.rs
