1 files changed, 20 insertions, 0 deletions
diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java
index c5301ee..d4c5e56 100644
--- a/src/ast/nodes/ForStmtNode.java
+++ b/src/ast/nodes/ForStmtNode.java
@@ -18,18 +18,38 @@ public class ForStmtNode implements Node {
         this.block = block;
     }
 
+    /**
+     * This methods check the semantics of the operation `for i in list: block`.
+     *
+     * After the `for` keyword, it's parsed as a list of expression. We verified
+     * that the last expression is always gonna be `expr comp_op expr`. We
+     * comp_op must be the `in` keyword. `i` could be of any lenght (e.g. `a, b,
+     * c`).
+     *
+     * In this function we define the following approch: we save in the
+     * SymbolTable every atom until the last expression in the expression's
+     * list. For the last element, we know that is in the `expr comp_op expr`
+     * format, so we take the left element and save it in the SymbolicTable as
+     * an atom.
+     */
     @Override
     public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
         ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
 
+        // Save every atom in the expression's list, except the last one
         var l = (ExprListNode) exprList;
         for (int i = 0; i < l.getSize() - 1; ++i) {
             var e = (ExprNode) l.getElem(i);
             ST.insert(e.getId(), e.typeCheck(), _nesting, "");
         }
 
+        // Manage the last expression of expression's list
+        // Get the ExprNode
         var left = (ExprNode) l.getElem(l.getSize() - 1);
+        // Get the left side expression of the operation, that
+        // corresponds to the first element of the expression list.
         var atomLeft = (ExprNode) left.getExpr(0);
+        // ENHANCE: check that the comp_op is the `in` keyword
         ST.insert(atomLeft.getId(), atomLeft.typeCheck(), _nesting, "");
 
         errors.addAll(exprList.checkSemantics(ST, _nesting));