Merge pull request #10 from boozec/check-semantics

Co-Authored-By: geno <gabriele.genovese2@studio.unibo.it>
Co-Authored-By: L0P0P <grassoemanuele@live.com> 

1 files changed, 164 insertions, 110 deletions

diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java
index 604c8d2..1cf15b7 100644
--- a/src/ast/Python3VisitorImpl.java
+++ b/src/ast/Python3VisitorImpl.java
@@ -12,34 +12,33 @@ import org.antlr.v4.runtime.tree.TerminalNode;
  * Overrides each `visitNODE` method from the base class.
  */
 public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
+
     /**
      * Since a root can be a simple_stmts or a compound_stmt, this method
      * returns a new `RootNode` with a list of them.
      *
-     * ```
-     * root : NEWLINE* (simple_stmts | compound_stmt)* EOF;
-     * ```
+     * ``` root : NEWLINE* (simple_stmts | compound_stmt)* EOF; ```
      */
     public Node visitRoot(RootContext ctx) {
-        ArrayList<Node> stmts = new ArrayList<Node>();
-        ArrayList<Node> compStmts = new ArrayList<Node>();
+        ArrayList<Node> childs = new ArrayList<Node>();
 
-        for (Simple_stmtsContext stm : ctx.simple_stmts()) {
-            stmts.add(visit(stm));
-        }
-        for (Compound_stmtContext stm : ctx.compound_stmt()) {
-            compStmts.add(visit(stm));
+        for (int i = 0; i < ctx.getChildCount(); i++) {
+            var child = ctx.getChild(i);
+
+            if (child instanceof Simple_stmtsContext) {
+                childs.add(visit((Simple_stmtsContext) child));
+            } else if (child instanceof Compound_stmtContext) {
+                childs.add(visit((Compound_stmtContext) child));
+            }
         }
 
-        return new RootNode(stmts, compStmts);
+        return new RootNode(childs);
     }
 
     /**
      * Returns a `SimpleStmtsNode`, made by an array of SimpleStmtNode
      *
-     * ```
-     * simple_stmts : simple_stmt (';' simple_stmt)* ';'? NEWLINE ;
-     * ```
+     * ``` simple_stmts : simple_stmt (';' simple_stmt)* ';'? NEWLINE ; ```
      */
     public Node visitSimple_stmts(Simple_stmtsContext ctx) {
         ArrayList<Node> stmts = new ArrayList<Node>();
@@ -55,9 +54,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns a `CompoundNode`. It can be built by a different kind of
      * statements, so only one of theme won't be null.
      *
-     * ```
-     * compound_stmt : if_stmt | while_stmt | for_stmt | funcdef ;
-     * ```
+     * ``` compound_stmt : if_stmt | while_stmt | for_stmt | funcdef ; ```
      */
     public Node visitCompound_stmt(Compound_stmtContext ctx) {
         Node ifStmt = null;
@@ -88,9 +85,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns a `SimpleStmtNode`. It can be built by a different kind of
      * statements, so only one of theme won't be null.
      *
-     * ```
-     * simple_stmt : assignment | expr | return_stmt | import_stm ;
-     * ```
+     * ``` simple_stmt : assignment | expr | return_stmt | import_stm ; ```
      */
     public Node visitSimple_stmt(Simple_stmtContext ctx) {
         Node assignment = null;
@@ -120,10 +115,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
     /**
      * Returns an `AssignmentNode`. It's made by left side, an assignment and a
      * right side.
-     * 
-     * ```
-     * assignment : exprlist augassign exprlist ;
-     * ```
+     *
+     * ``` assignment : exprlist augassign exprlist ; ```
      */
     public Node visitAssignment(AssignmentContext ctx) {
         Node lhr = visit(ctx.exprlist(0));
@@ -136,9 +129,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
     /**
      * Returns a `ReturnStmtNode`. The returned exprlist can be null.
      *
-     * ```
-     * return_stmt : 'return' exprlist? ;
-     * ```
+     * ``` return_stmt : 'return' exprlist? ; ```
      */
     public Node visitReturn_stmt(Return_stmtContext ctx) {
         Node exprList = null;
@@ -153,10 +144,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns a `ImportNode`. An import can be made in different ways so we
      * check the way in a module is imported (by from, by alias or by star).
      *
-     * ```
-     * import_stm : 'import' dotted_name ('as' NAME)?
-     * | 'from' dotted_name 'import' (NAME (',' NAME)* | '*') ;
-     * ```
+     * ``` import_stm : 'import' dotted_name ('as' NAME)? | 'from' dotted_name
+     * 'import' (NAME (',' NAME)* | '*') ; ```
      */
     public Node visitImport_stm(Import_stmContext ctx) {
         boolean isFrom = ctx.FROM() != null;
@@ -177,9 +166,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
     /**
      * Returns a `DottedNameNode` used in `import_stm`.
      *
-     * ```
-     * dotted_name : NAME ('.' NAME)* ;
-     * ```
+     * ``` dotted_name : NAME ('.' NAME)* ; ```
      */
     public Node visitDotted_name(Dotted_nameContext ctx) {
         ArrayList<TerminalNode> names = new ArrayList<TerminalNode>();
@@ -194,9 +181,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
     /**
      * Returns a `FuncdefNode`. A paramlist can be null.
      *
-     * ```
-     * funcdef : 'def' NAME '(' paramlist? ')' ':' block ;
-     * ```
+     * ``` funcdef : 'def' NAME '(' paramlist? ')' ':' block ; ```
      */
     public Node visitFuncdef(FuncdefContext ctx) {
         Node paramlist = null;
@@ -214,9 +199,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns a `ParamlistNode`. We ignore the paramdef with default values
      * (eg: is_used=False) because there is no test which uses this feature.
      *
-     * ```
-     * paramlist : paramdef ('=' expr)? (',' paramdef ('=' expr)?)* ;
-     * 
+     * ``` paramlist : paramdef ('=' expr)? (',' paramdef ('=' expr)?)* ;
+     *
      * ```
      */
     public Node visitParamlist(ParamlistContext ctx) {
@@ -233,9 +217,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns a `ParamdefNode`. We ignore the paramdef with type annotation
      * (eg: x : int) because there is no test which uses this feature.
      *
-     * ```
-     * paramdef : NAME (':' expr)? ;
-     * ```
+     * ``` paramdef : NAME (':' expr)? ; ```
      */
     public Node visitParamdef(ParamdefContext ctx) {
         return new ParamdefNode(ctx.NAME().toString());
@@ -245,11 +227,8 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns an `AugassignNode`. We don't provide all kinds of assignment
      * below.
      *
-     * ```
-     * augassign : '=' | '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' |
-     * '^=' | '<<=' | '>>=' | '**=' | '//='
-     * ;
-     * ```
+     * ``` augassign : '=' | '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' |
+     * '|=' | '^=' | '<<=' | '>>=' | '**=' | '//=' ; ```
      */
     public Node visitAugassign(AugassignContext ctx) {
         Node x = null;
@@ -262,20 +241,36 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
             x = new AugassignNode(ctx.SUB_ASSIGN());
         } else if (ctx.MULT_ASSIGN() != null) {
             x = new AugassignNode(ctx.MULT_ASSIGN());
+        } else if (ctx.AT_ASSIGN() != null) {
+            x = new AugassignNode(ctx.AT_ASSIGN());
         } else if (ctx.DIV_ASSIGN() != null) {
             x = new AugassignNode(ctx.DIV_ASSIGN());
+        } else if (ctx.MOD_ASSIGN() != null) {
+            x = new AugassignNode(ctx.MOD_ASSIGN());
+        } else if (ctx.AND_ASSIGN() != null) {
+            x = new AugassignNode(ctx.AND_ASSIGN());
+        } else if (ctx.OR_ASSIGN() != null) {
+            x = new AugassignNode(ctx.OR_ASSIGN());
+        } else if (ctx.XOR_ASSIGN() != null) {
+            x = new AugassignNode(ctx.XOR_ASSIGN());
+        } else if (ctx.LEFT_SHIFT_ASSIGN() != null) {
+            x = new AugassignNode(ctx.LEFT_SHIFT_ASSIGN());
+        } else if (ctx.RIGHT_SHIFT_ASSIGN() != null) {
+            x = new AugassignNode(ctx.RIGHT_SHIFT_ASSIGN());
+        } else if (ctx.POWER_ASSIGN() != null) {
+            x = new AugassignNode(ctx.POWER_ASSIGN());
+        } else if (ctx.IDIV_ASSIGN() != null) {
+            x = new AugassignNode(ctx.IDIV_ASSIGN());
         }
 
         return x;
     }
 
     /**
-     * Returns a `IfNode`.
-     * FIXME: add support for elif statement.
+     * Returns a `IfNode`. FIXME: add support for elif statement.
      *
-     * ```
-     * if_stmt : 'if' expr ':' block ('elif' expr ':' block)* ('else' ':' block)? ;
-     * ```
+     * ``` if_stmt : 'if' expr ':' block ('elif' expr ':' block)* ('else' ':'
+     * block)? ; ```
      */
     public Node visitIf_stmt(If_stmtContext ctx) {
         var blocks = ctx.block();
@@ -292,9 +287,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
     /**
      * Returns a `WhileStmtNode`. We do not provide 'else' branch.
      *
-     * ```
-     * while_stmt : 'while' expr ':' block ('else' ':' block)? ;
-     * ```
+     * ``` while_stmt : 'while' expr ':' block ('else' ':' block)? ; ```
      */
     public Node visitWhile_stmt(While_stmtContext ctx) {
         Node expr = visit(ctx.expr());
@@ -308,9 +301,7 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
     /**
      * Returns a `ForSmtNode`. We do not provide 'else' branch.
      *
-     * ```
-     * for_stmt : 'for' exprlist ':' block ('else' ':' block)? ;
-     * ```
+     * ``` for_stmt : 'for' exprlist ':' block ('else' ':' block)? ; ```
      */
     public Node visitFor_stmt(For_stmtContext ctx) {
         Node exprList = visit(ctx.exprlist());
@@ -325,32 +316,30 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns a `BlockNode`. A block can be be a simple_stmts or a list of
      * simple_stms and/or compound_stmt, so we just use a list for each kind.
      *
-     * ```
-     * block : simple_stmts
-     * | NEWLINE INDENT (simple_stmts | compound_stmt)+ DEDENT ;
-     * ```
+     * ``` block : simple_stmts | NEWLINE INDENT (simple_stmts | compound_stmt)+
+     * DEDENT ; ```
      */
     public Node visitBlock(BlockContext ctx) {
-        ArrayList<Node> stmts = new ArrayList<Node>();
-        ArrayList<Node> compStmts = new ArrayList<Node>();
+        ArrayList<Node> childs = new ArrayList<Node>();
 
-        for (Simple_stmtsContext s : ctx.simple_stmts()) {
-            stmts.add(visit(s));
-        }
-        for (Compound_stmtContext s : ctx.compound_stmt()) {
-            compStmts.add(visit(s));
+        for (int i = 0; i < ctx.getChildCount(); i++) {
+            var child = ctx.getChild(i);
+
+            if (child instanceof Simple_stmtsContext) {
+                childs.add(visit((Simple_stmtsContext) child));
+            } else if (child instanceof Compound_stmtContext) {
+                childs.add(visit((Compound_stmtContext) child));
+            }
         }
 
-        return new BlockNode(stmts, compStmts);
+        return new BlockNode(childs);
     }
 
     /**
      * Returns a `CompNode`. It should never be null.
      *
-     * ```
-     * comp_op : '<' | '>' | '==' | '>=' | '<=' | '<>' | '!=' | 'in' | 'not' 'in' |
-     * 'is' | 'is' 'not' ;
-     * ```
+     * ``` comp_op : '<' | '>' | '==' | '>=' | '<=' | '<>' | '!=' | 'in' | 'not'
+     * 'in' | 'is' | 'is' 'not' ; ```
      */
     public Node visitComp_op(Comp_opContext ctx) {
         Node comp = null;
@@ -382,13 +371,11 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
      * Returns an `ExprNode`. An expession can be a different kind of
      * sub-expression. We do not provide all kinds of expr(s).
      *
-     * ```
-     * expr : atom trailer* | expr '**' expr | ('+' | '-' | '~')+ expr | expr ('*' |
-     * '@' | '/' | '%' | '//') expr | expr ('+' | '-') expr | expr ('<<' | '>>')
-     * expr | expr '&' expr | expr '^' expr | expr '|' expr | 'not' expr | expr
-     * comp_op expr | expr 'and' expr | expr 'or' expr | expr 'if' expr 'else' expr
-     * ;
-     * ```
+     * ``` expr : atom trailer* | expr '**' expr | ('+' | '-' | '~')+ expr |
+     * expr ('*' | '@' | '/' | '%' | '//') expr | expr ('+' | '-') expr | expr
+     * ('<<' | '>>') expr | expr '&' expr | expr '^' expr | expr '|' expr |
+     * 'not' expr | expr comp_op expr | expr 'and' expr | expr 'or' expr | expr
+     * 'if' expr 'else' expr ; ```
      */
     public Node visitExpr(ExprContext ctx) {
         Node atom = null;
@@ -438,41 +425,57 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
 
     /**
      * Returns an `AtomNode`.
-     * FIXME: add support for testlist_comp
      *
-     * ```
-     * atom : '(' testlist_comp? ')' | '[' testlist_comp? ']' | '{' testlist_comp?
-     * '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False' ;
-     * ```
+     * ``` atom : '(' testlist_comp? ')' | '[' testlist_comp? ']' | '{'
+     * testlist_comp? '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' |
+     * 'False' ; ```
      */
     public Node visitAtom(AtomContext ctx) {
+        Testlist_compContext tlc = ctx.testlist_comp();
         if (ctx.NUMBER() != null) {
-            return new AtomNode(ctx.NUMBER().toString());
+            return new AtomNode(ctx.NUMBER().toString(), null);
+        } else if (ctx.NONE() != null) {
+            return new AtomNode(ctx.NONE().toString(), null);
         } else if (ctx.TRUE() != null) {
-            return new AtomNode(ctx.TRUE().toString());
+            return new AtomNode(ctx.TRUE().toString(), null);
         } else if (ctx.FALSE() != null) {
-            return new AtomNode(ctx.FALSE().toString());
+            return new AtomNode(ctx.FALSE().toString(), null);
         } else if (ctx.NAME() != null) {
-            return new AtomNode(ctx.NAME().toString());
-        } else if (ctx.STRING() != null) {
-
+            return new AtomNode(ctx.NAME().toString(), null);
+        } else if (!ctx.STRING().isEmpty()) {
             var varName = "";
             for (var x : ctx.STRING()) {
                 varName += x;
             }
+            return new AtomNode(varName, null);
+        } else if (ctx.OPEN_BRACE() != null && ctx.CLOSE_BRACE() != null) {
+            return manageCompListContext(tlc);
+        } else if (ctx.OPEN_BRACK() != null && ctx.CLOSE_BRACK() != null) {
+            return manageCompListContext(tlc);
+        } else if (ctx.OPEN_PAREN() != null && ctx.CLOSE_PAREN() != null) {
+            return manageCompListContext(tlc);
+        }
+        return new AtomNode(null, null);
+    }
 
-            return new AtomNode(varName);
+    /**
+     * Supporting function for `visitAtom`. Returns an `AtomNode` with
+     * `testlist_comp` set if the context is not null. Otherwise, returns an
+     * `AtomNode` with nulls.
+     */
+    public AtomNode manageCompListContext(Testlist_compContext tlc) {
+        if (tlc != null) {
+            Node testlist_comp = visit(tlc);
+            return new AtomNode(null, testlist_comp);
         }
-        return new AtomNode(ctx.NONE().toString());
+        return new AtomNode(null, null);
     }
 
     /**
      * Returns an `TrailerNode`.
      *
-     * ```
-     * trailer : '(' arglist? ')' | '[' expr (',' expr)* ','? ']' | '.' NAME | '['
-     * expr? ':' expr? (':' expr? )? ']' ;
-     * ```
+     * ``` trailer : '(' arglist? ')' | '[' expr (',' expr)* ','? ']' | '.' NAME
+     * | '[' expr? ':' expr? (':' expr? )? ']' ; ```
      */
     public Node visitTrailer(TrailerContext ctx) {
         Node arglist = null;
@@ -491,29 +494,28 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
             methodCall = ctx.NAME();
         }
 
-        return new TrailerNode(arglist, exprs, methodCall);
+        return new TrailerNode(arglist, exprs, methodCall, ctx.OPEN_PAREN() != null);
     }
 
     /**
-     * Returns a `Node`.
-     * FIXME: what to do in case of list??
+     * Returns a `Node`. FIXME: what to do in case of list??
      *
-     * ```
-     * exprlist : expr (',' expr )* ','? ;
-     * ```
+     * ``` exprlist : expr (',' expr )* ','? ; ```
      */
     public Node visitExprlist(ExprlistContext ctx) {
-        Node exp = visit(ctx.expr(0));
+        ArrayList<Node> exprlist = new ArrayList<Node>();
+
+        for (ExprContext c : ctx.expr()) {
+            exprlist.add(visit(c));
+        }
 
-        return exp;
+        return new ExprListNode(exprlist);
     }
 
     /**
      * Returns a `ArglistNode`.
      *
-     * ```
-     * arglist : argument (',' argument)* ','? ;
-     * ```
+     * ``` arglist : argument (',' argument)* ','? ; ```
      */
     public Node visitArglist(ArglistContext ctx) {
         ArrayList<Node> arguments = new ArrayList<Node>();
@@ -524,4 +526,56 @@ public class Python3VisitorImpl extends Python3ParserBaseVisitor<Node> {
 
         return new ArglistNode(arguments);
     }
+
+    /**
+     * Returns a `TestlistCompNode`.
+     *
+     * ``` testlist_comp : expr (comp_for | (',' expr)* ','?) ; ```
+     */
+    public Node visitTestlist_comp(Testlist_compContext ctx) {
+        ArrayList<Node> exprlist = new ArrayList<Node>();
+
+        for (ExprContext c : ctx.expr()) {
+            exprlist.add(visit(c));
+        }
+        Comp_forContext cfc = ctx.comp_for();
+        Node comp = null;
+        if (cfc != null) {
+            comp = visit(ctx.comp_for());
+        }
+        return new TestlistCompNode(exprlist, comp);
+    }
+
+    /**
+     * Returns a `CompForNode`.
+     *
+     * ``` comp_for : 'for' exprlist 'in' expr comp_iter? ;```
+     */
+    public Node visitComp_for(Comp_forContext ctx) {
+        Node exprlist = visit(ctx.exprlist());
+        Node expr = visit(ctx.expr());
+        Comp_iterContext cic = ctx.comp_iter();
+
+        if (cic != null) {
+            Node comp = visit(ctx.comp_iter());
+            return new CompForNode(exprlist, expr, comp);
+        }
+        return new CompForNode(exprlist, expr, null);
+    }
+
+    /**
+     * Returns a `CompIterNode`.
+     *
+     * ``` comp_iter : comp_for | comp_if ; ;```
+     */
+    public Node visitComp_iter(Comp_iterContext ctx) {
+        // TODO: Implement comp_if
+        // Node iter = visit(ctx.comp_if());
+        Comp_forContext cfc = ctx.comp_for();
+        Node forNode = null;
+        if (cfc != null) {
+            forNode = visit(ctx.comp_for());
+        }
+        return new CompIterNode(forNode);
+    }
 }