refactor declaration grammar

crates/lsp/src/handler/goto_definition.rs

@@ -189,7 +189,7 @@ mod tests {
         pragma circom 2.0.0;
 
         template X() {
-            signal x = 10;
+            signal x[100];
             signal input x = 10;
            component x = Multiplier2();
            component y = X();
@@ -230,9 +230,7 @@ template Y() {
         let syntax_node = SyntaxTreeBuilder::syntax_tree(&source);
 
         if let Some(program_ast) = AstCircomProgram::cast(syntax_node) {
-            for template in program_ast.template_list() {
-                println!("{template:?}");
-            }
+            println!("program: {}", program_ast.syntax().text().to_string());
 
             let inputs = program_ast.template_list()[0]
                 .func_body()

crates/parser/src/grammar/block.rs

@@ -11,11 +11,13 @@ use super::*;
 pub fn block(p: &mut Parser) {
     p.inc_rcurly();
 
+    // TODO: why do not use expect for { and }
     if !p.at(LCurly) {
         p.advance_with_error("Miss {");
     } else {
         let m = p.open();
         p.expect(LCurly);
+
         let stmt_marker = p.open();
         while !p.at(RCurly) && !p.eof() {
             let kind = p.current();

crates/parser/src/grammar/declaration.rs

@@ -1,121 +1,188 @@
 use super::{
-    expression::{tuple, tuple_init},
+    expression::{expression, tuple, tuple_init},
     *,
 };
 
-// "signal" --> None
-// "signal input" --> Some(true)
-// "signal output" --> Some(false)
+// [N][M-1]
+fn array(p: &mut Parser) -> bool {
+    let is_array = p.at(LBracket);
+
+    while p.at(LBracket) {
+        p.expect(LBracket);
+        expression(p);
+        p.expect(RBracket);
+    }
+
+    is_array
+}
+
+/*
+"signal" --> None
+"signal input" --> Some(true)
+"signal output" --> Some(false)
+*/
 fn signal_header(p: &mut Parser) -> Option<bool> {
-    let mut res = None;
     let m = p.open();
     p.expect(SignalKw);
-    if p.at_any(&[InputKw, OutputKw]) {
-        if p.at(InputKw) {
-            res = Some(true);
-        } else {
-            res = Some(false);
-        }
+
+    let res = if p.at(InputKw) {
+        Some(true)
+    } else if p.at(OutputKw) {
+        Some(false)
+    } else {
+        None
+    };
+
+    if res.is_some() {
         p.advance();
+    }
 
-        if p.at(LCurly) {
-            p.expect(Identifier);
-            p.expect(RCurly);
-        }
+    // signal tags
+    // {tag1, tag2, tag2}
+    // TODO: support list of tags
+    if p.at(LCurly) {
+        p.expect(Identifier);
+        p.expect(RCurly);
     }
+
     p.close(m, SignalHeader);
     res
 }
 
+pub(crate) fn var_init(p: &mut Parser) {
+    // name of variable
+    p.expect(Identifier);
+
+    // eg: [N - 1][M]
+    array(p);
+
+    // assign for variable
+    // eg: = 10
+    if p.at_var_assign() {
+        p.advance();
+        expression(p);
+    }
+}
+
+// eg: in[N - 1] <== c.in;
+pub(crate) fn signal_init(p: &mut Parser, assign_able: bool) {
+    // name of signal
+    p.expect(Identifier);
+
+    // eg: [N][M-1]
+    array(p);
+
+    // assign for  intermediate and outputs signals
+    // eg: <== Multiplier2().out
+    if assign_able && p.at_inline_assign_signal() {
+        p.advance();
+        expression(p);
+    }
+}
+
 /**
  * Declaration := "var" (SimpleSymbol, ..., SimpleSymbol) TupleInitialization |
- *               
- *             
+ *                "var" iden1 = init1, iden2 = init2, iden3         
  */
 pub(super) fn var_declaration(p: &mut Parser) {
     let m = p.open();
     p.expect(VarKw);
 
+    // tuple of variables
+    // eg: var (in1, in2, in3) = (1, 2, 3);
     if p.at(LParen) {
         tuple(p);
-        if p.at(Assign) {
+        if p.at_var_assign() {
             tuple_init(p);
         }
     } else {
-        p.expect(Identifier);
-        if p.at(Assign) {
-            p.expect(Assign);
-            expression::expression(p);
-        }
-        // list of var
+        // list of variables
+        // var in1[N], in2 = 5;
+        var_init(p);
         while p.at(Comma) && !p.eof() {
-            p.expect(Comma);
-            p.expect(Identifier);
-            if p.at(Assign) {
-                p.expect(Assign);
-                expression::expression(p);
-            }
+            p.skip();
+            var_init(p);
         }
     }
+
     p.close(m, VarDecl);
 }
 
+/*
+* signal are immutable (can not modify after init value)
+* can not initialize value for input signal
+* since circom 2.0.4, it is also allowed to initialize
+intermediate and outputs signals right after their declaration
+*/
 pub(super) fn signal_declaration(p: &mut Parser) {
+    // TODO: can we remove that?
     if !p.at(SignalKw) {
         p.advance_with_error("Signal error");
         return;
     }
 
     let m = p.open();
     let io_signal = signal_header(p);
+    let assign_able = io_signal != Some(true);
 
+    // tuple of signal
+    // eg: signal (in1, in2, in3) <== tuple_value;
     if p.at(LParen) {
         tuple(p);
-        if p.at_any(&[Assign, RAssignSignal, RAssignConstraintSignal]) {
+        // can not assign for input signal
+        if assign_able && p.at_inline_assign_signal() {
             tuple_init(p);
         }
     } else {
-        p.expect(Identifier);
-        // list of var
+        // list of signals
+        // signal in1[N], in2 <== signal_value;
+        signal_init(p, assign_able);
         while p.at(Comma) && !p.eof() {
             p.skip();
-            p.expect(Identifier);
+            signal_init(p, assign_able);
         }
     }
 
-    if let Some(is_input) = io_signal {
-        if is_input {
-            p.close(m, InputSignalDecl);
-        } else {
-            p.close(m, OutputSignalDecl);
-        }
-    } else {
-        p.close(m, SignalDecl);
-    }
+    let close_kind = match io_signal {
+        Some(true) => InputSignalDecl,
+        Some(false) => OutputSignalDecl,
+        None => SignalDecl,
+    };
+
+    p.close(m, close_kind);
 }
 
+/*
+* initialization in the definition of arrays of components is not allowed
+*/
 pub(super) fn component_declaration(p: &mut Parser) {
     let m = p.open();
     p.expect(ComponentKw);
+
+    // TODO: why do we need `ComponentIdentifier` kind here?
     let m_c = p.open();
     p.expect(Identifier);
     p.close(m_c, ComponentIdentifier);
 
-    p.expect(Assign);
-    let m_c = p.open();
-    p.expect(Identifier);
-    p.close(m_c, TemplateName);
-    p.expect(LParen);
-
-    if p.at(Identifier) {
-        expression::expression(p);
-        while !p.at(RParen) && !p.eof() {
-            p.expect(Comma);
-            expression::expression(p);
-        }
-    }
+    // support array component
+    // eg: comp[N - 1][10]
+    let is_array = array(p);
+
+    // do not assign for array components
+    if !is_array && p.at(Assign) {
+        p.expect(Assign);
 
-    p.expect(RParen);
+        // TODO: support `parallel` tag
+        // eg: component comp = parallel NameTemplate(...){...}
+
+        // template name
+        let m_c = p.open();
+        p.expect(Identifier);
+        p.close(m_c, TemplateName);
+
+        // template params
+        tuple(p);
+    }
 
     p.close(m, ComponentDecl);
 }

crates/parser/src/grammar/expression.rs

@@ -8,17 +8,39 @@ pub(super) fn expression(p: &mut Parser) {
     p.close(m, Expression);
 }
 
+/**
+ * grammar: "(param1, param2,..., paramn)"
+ * can be an empty ()
+ */
+pub(super) fn function_params(p: &mut Parser) {
+    let m = p.open();
+    p.expect(LParen);
+
+    while !p.at(RParen) && !p.eof() {
+        expression(p);
+        if p.at(Comma) {
+            p.expect(Comma)
+        } else {
+            break;
+        }
+    }
+
+    p.expect(RParen);
+    // TODO: what kind of it?
+    p.close(m, Tuple);
+}
+
 /**
  * grammar: "(Symbol_1, Symbol_2,..., Symbol_n)"
+ * can be an empty tuple (for function cal: Mul())
  */
 pub(super) fn tuple(p: &mut Parser) {
     let m = p.open();
     p.expect(LParen);
-    p.expect(Identifier);
-    while p.at(Comma) && !p.eof() {
-        p.expect(Comma);
-        p.expect(Identifier);
-    }
+
+    // iden1, iden2, iden3
+    list_identity::parse(p);
+
     p.expect(RParen);
     p.close(m, Tuple);
 }
@@ -85,7 +107,8 @@ pub fn expression_rec(p: &mut Parser, pb: u16) -> Option<Marker> {
     // TODO: function call
     if p.at(LParen) {
         let m = p.open_before(lhs);
-        tuple(p);
+        // tuple(p);
+        function_params(p);
         lhs = p.close(m, Call);
     }