Set up visitor (#3)

Co-authored-by: geno <gabriele.genovese2@studio.unibo.it>

29 files changed, 1876 insertions, 0 deletions

diff --git a/src/ast/Python3VisitorImpl.java b/src/ast/Python3VisitorImpl.java
new file mode 100644
index 0000000..0783409
--- /dev/null
+++ b/src/ast/Python3VisitorImpl.java
@@ -0,0 +1,530 @@
+package com.clp.project.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.clp.project.ast.*;
+import com.clp.project.ast.nodes.*;
+import com.clp.project.ast.types.*;
+import com.clp.project.parser.Python3ParserBaseVisitor;
+import com.clp.project.parser.Python3Parser.*;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * Implementation for the `Python3ParserBaseVisitor` class for the `Node` type.
+ * 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;
+     * ```
+     */
+    public Node visitRoot(RootContext ctx) {
+        ArrayList<Node> stmts = new ArrayList<Node>();
+        ArrayList<Node> compStmts = 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));
+        }
+
+        return new RootNode(stmts, compStmts);
+    }
+
+    /**
+     * Returns a `SimpleStmtsNode`, made by an array of SimpleStmtNode
+     *
+     * ```
+     * simple_stmts : simple_stmt (';' simple_stmt)* ';'? NEWLINE ;
+     * ```
+     */
+    public Node visitSimple_stmts(Simple_stmtsContext ctx) {
+        ArrayList<Node> stmts = new ArrayList<Node>();
+
+        for (Simple_stmtContext stm : ctx.simple_stmt()) {
+            stmts.add(visit(stm));
+        }
+
+        return new SimpleStmtsNode(stmts);
+    }
+
+    /**
+     * 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 ;
+     * ```
+     */
+    public Node visitCompound_stmt(Compound_stmtContext ctx) {
+        Node ifStmt = null;
+        Node funcDef = null;
+        Node forStmt = null;
+        Node whileStmt = null;
+
+        if (ctx.if_stmt() != null) {
+            ifStmt = visit(ctx.if_stmt());
+        }
+
+        if (ctx.funcdef() != null) {
+            funcDef = visit(ctx.funcdef());
+        }
+
+        if (ctx.for_stmt() != null) {
+            forStmt = visit(ctx.for_stmt());
+        }
+
+        if (ctx.while_stmt() != null) {
+            whileStmt = visit(ctx.while_stmt());
+        }
+
+        return new CompoundNode(ifStmt, funcDef, forStmt, whileStmt);
+    }
+
+    /**
+     * 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 ;
+     * ```
+     */
+    public Node visitSimple_stmt(Simple_stmtContext ctx) {
+        Node assignment = null;
+        Node expr = null;
+        Node returnStmt = null;
+        Node importStmt = null;
+
+        if (ctx.assignment() != null) {
+            assignment = visit(ctx.assignment());
+        }
+
+        if (ctx.expr() != null) {
+            expr = visit(ctx.expr());
+        }
+
+        if (ctx.return_stmt() != null) {
+            returnStmt = visit(ctx.return_stmt());
+        }
+
+        if (ctx.import_stm() != null) {
+            importStmt = visit(ctx.import_stm());
+        }
+
+        return new SimpleStmtNode(assignment, expr, returnStmt, importStmt);
+    }
+
+    /**
+     * Returns an `AssignmentNode`. It's made by left side, an assignment and a
+     * right side.
+     * 
+     * ```
+     * assignment : exprlist augassign exprlist ;
+     * ```
+     */
+    public Node visitAssignment(AssignmentContext ctx) {
+        Node lhr = visit(ctx.exprlist(0));
+        Node assign = visit(ctx.augassign());
+        Node rhr = visit(ctx.exprlist(1));
+
+        return new AssignmentNode(lhr, assign, rhr);
+    }
+
+    /**
+     * Returns a `ReturnStmtNode`. The returned exprlist can be null.
+     *
+     * ```
+     * return_stmt : 'return' exprlist? ;
+     * ```
+     */
+    public Node visitReturn_stmt(Return_stmtContext ctx) {
+        Node exprList = null;
+        if (ctx.exprlist() != null) {
+            exprList = visit(ctx.exprlist());
+        }
+
+        return new ReturnStmtNode(exprList);
+    }
+
+    /**
+     * 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)* | '*') ;
+     * ```
+     */
+    public Node visitImport_stm(Import_stmContext ctx) {
+        boolean isFrom = ctx.FROM() != null;
+        boolean importAs = ctx.AS() != null;
+        boolean importAll = ctx.STAR() != null;
+
+        Node dottedName = visit(ctx.dotted_name());
+
+        ArrayList<String> names = new ArrayList<String>();
+
+        for (var s : ctx.NAME()) {
+            names.add(s.toString());
+        }
+
+        return new ImportNode(dottedName, isFrom, importAs, importAll, names);
+    }
+
+    /**
+     * Returns a `DottedNameNode` used in `import_stm`.
+     *
+     * ```
+     * dotted_name : NAME ('.' NAME)* ;
+     * ```
+     */
+    public Node visitDotted_name(Dotted_nameContext ctx) {
+        ArrayList<TerminalNode> names = new ArrayList<TerminalNode>();
+
+        for (var name : ctx.NAME()) {
+            names.add(name);
+        }
+
+        return new DottedNameNode(names);
+    }
+
+    /**
+     * Returns a `FuncdefNode`. A paramlist can be null.
+     *
+     * ```
+     * funcdef : 'def' NAME '(' paramlist? ')' ':' block ;
+     * ```
+     */
+    public Node visitFuncdef(FuncdefContext ctx) {
+        Node paramlist = null;
+
+        if (ctx.paramlist() != null) {
+            paramlist = visit(ctx.paramlist());
+        }
+
+        Node block = visit(ctx.block());
+
+        return new FuncdefNode(ctx.NAME(), paramlist, block);
+    }
+
+    /**
+     * 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)?)* ;
+     * 
+     * ```
+     */
+    public Node visitParamlist(ParamlistContext ctx) {
+        ArrayList<Node> params = new ArrayList<Node>();
+
+        for (ParamdefContext s : ctx.paramdef()) {
+            params.add(visit(s));
+        }
+
+        return new ParamlistNode(params);
+    }
+
+    /**
+     * 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)? ;
+     * ```
+     */
+    public Node visitParamdef(ParamdefContext ctx) {
+        return new ParamdefNode(ctx.NAME().toString());
+    }
+
+    /**
+     * Returns an `AugassignNode`. We don't provide all kinds of assignment
+     * below.
+     *
+     * ```
+     * augassign : '=' | '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' |
+     * '^=' | '<<=' | '>>=' | '**=' | '//='
+     * ;
+     * ```
+     */
+    public Node visitAugassign(AugassignContext ctx) {
+        Node x = null;
+
+        if (ctx.ASSIGN() != null) {
+            x = new AugassignNode(ctx.ASSIGN());
+        } else if (ctx.ADD_ASSIGN() != null) {
+            x = new AugassignNode(ctx.ADD_ASSIGN());
+        } else if (ctx.SUB_ASSIGN() != null) {
+            x = new AugassignNode(ctx.SUB_ASSIGN());
+        } else if (ctx.MULT_ASSIGN() != null) {
+            x = new AugassignNode(ctx.MULT_ASSIGN());
+        } else if (ctx.DIV_ASSIGN() != null) {
+            x = new AugassignNode(ctx.DIV_ASSIGN());
+        }
+
+        return x;
+    }
+
+    /**
+     * Returns a `IfNode`.
+     * FIXME: add support for elif statement.
+     *
+     * ```
+     * if_stmt : 'if' expr ':' block ('elif' expr ':' block)* ('else' ':' block)? ;
+     * ```
+     */
+    public Node visitIf_stmt(If_stmtContext ctx) {
+        var blocks = ctx.block();
+        Node condExp = visit(ctx.expr(0));
+        Node thenExp = visit(blocks.get(0));
+        Node elseExp = null;
+        if (blocks.size() > 1) {
+            elseExp = visit(blocks.get(1));
+        }
+
+        return new IfNode(condExp, thenExp, elseExp);
+    }
+
+    /**
+     * Returns a `WhileStmtNode`. We do not provide 'else' branch.
+     *
+     * ```
+     * while_stmt : 'while' expr ':' block ('else' ':' block)? ;
+     * ```
+     */
+    public Node visitWhile_stmt(While_stmtContext ctx) {
+        Node expr = visit(ctx.expr());
+
+        // Block 1 is for the while-else statement
+        Node block = visit(ctx.block(0));
+
+        return new WhileStmtNode(expr, block);
+    }
+
+    /**
+     * Returns a `ForSmtNode`. We do not provide 'else' branch.
+     *
+     * ```
+     * for_stmt : 'for' exprlist ':' block ('else' ':' block)? ;
+     * ```
+     */
+    public Node visitFor_stmt(For_stmtContext ctx) {
+        Node exprList = visit(ctx.exprlist());
+
+        // Block 1 is for the for-else statement
+        Node block = visit(ctx.block(0));
+
+        return new ForStmtNode(exprList, block);
+    }
+
+    /**
+     * 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 ;
+     * ```
+     */
+    public Node visitBlock(BlockContext ctx) {
+        ArrayList<Node> stmts = new ArrayList<Node>();
+        ArrayList<Node> compStmts = 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));
+        }
+
+        return new BlockNode(stmts, compStmts);
+    }
+
+    /**
+     * Returns a `CompNode`. It should never be null.
+     *
+     * ```
+     * comp_op : '<' | '>' | '==' | '>=' | '<=' | '<>' | '!=' | 'in' | 'not' 'in' |
+     * 'is' | 'is' 'not' ;
+     * ```
+     */
+    public Node visitComp_op(Comp_opContext ctx) {
+        Node comp = null;
+        if (ctx.LESS_THAN() != null) {
+            comp = new CompNode(ctx.LESS_THAN());
+        } else if (ctx.GREATER_THAN() != null) {
+            comp = new CompNode(ctx.GREATER_THAN());
+        } else if (ctx.EQUALS() != null) {
+            comp = new CompNode(ctx.EQUALS());
+        } else if (ctx.GT_EQ() != null) {
+            comp = new CompNode(ctx.GT_EQ());
+        } else if (ctx.LT_EQ() != null) {
+            comp = new CompNode(ctx.LT_EQ());
+        } else if (ctx.NOT_EQ_2() != null) {
+            // We're ignoring NOT_EQ_1() because no one uses `<>`
+            comp = new CompNode(ctx.NOT_EQ_2());
+        } else if (ctx.IN() != null) {
+            comp = new CompNode(ctx.IN());
+        } else if (ctx.NOT() != null) {
+            comp = new CompNode(ctx.NOT());
+        } else if (ctx.IS() != null) {
+            comp = new CompNode(ctx.IS());
+        }
+
+        return comp;
+    }
+
+    /**
+     * 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
+     * ;
+     * ```
+     */
+    public Node visitExpr(ExprContext ctx) {
+        Node atom = null;
+        Node compOp = null;
+        ArrayList<Node> exprs = new ArrayList<Node>();
+        ArrayList<Node> trailers = new ArrayList<Node>();
+        String op = null;
+
+        if (ctx.ADD(0) != null) {
+            op = ctx.ADD(0).toString();
+        }
+
+        if (ctx.MINUS(0) != null) {
+            op = ctx.MINUS(0).toString();
+        }
+
+        if (ctx.NOT() != null) {
+            op = ctx.NOT().toString();
+        }
+
+        if (ctx.STAR() != null) {
+            op = ctx.STAR().toString();
+        }
+
+        if (ctx.DIV() != null) {
+            op = ctx.DIV().toString();
+        }
+
+        if (ctx.atom() != null) {
+            atom = visit(ctx.atom());
+        }
+
+        if (ctx.comp_op() != null) {
+            compOp = visit(ctx.comp_op());
+        }
+
+        for (ExprContext s : ctx.expr()) {
+            exprs.add(visit(s));
+        }
+
+        for (TrailerContext s : ctx.trailer()) {
+            trailers.add(visit(s));
+        }
+
+        return new ExprNode(atom, compOp, exprs, op, trailers);
+    }
+
+    /**
+     * Returns an `AtomNode`.
+     * FIXME: add support for testlist_comp
+     *
+     * ```
+     * atom : '(' testlist_comp? ')' | '[' testlist_comp? ']' | '{' testlist_comp?
+     * '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False' ;
+     * ```
+     */
+    public Node visitAtom(AtomContext ctx) {
+        if (ctx.NUMBER() != null) {
+            return new AtomNode(ctx.NUMBER().toString());
+        } else if (ctx.TRUE() != null) {
+            return new AtomNode(ctx.TRUE().toString());
+        } else if (ctx.FALSE() != null) {
+            return new AtomNode(ctx.FALSE().toString());
+        } else if (ctx.NAME() != null) {
+            return new AtomNode(ctx.NAME().toString());
+        } else if (ctx.STRING() != null) {
+
+            var varName = "";
+            for (var x : ctx.STRING()) {
+                varName += x;
+            }
+
+            return new AtomNode(varName);
+        }
+        return new AtomNode(ctx.NONE().toString());
+    }
+
+    /**
+     * Returns an `TrailerNode`.
+     *
+     * ```
+     * trailer : '(' arglist? ')' | '[' expr (',' expr)* ','? ']' | '.' NAME | '['
+     * expr? ':' expr? (':' expr? )? ']' ;
+     * ```
+     */
+    public Node visitTrailer(TrailerContext ctx) {
+        Node arglist = null;
+        if (ctx.arglist() != null) {
+            arglist = visit(ctx.arglist());
+        }
+
+        ArrayList<Node> exprs = new ArrayList<Node>();
+        for (ExprContext expr : ctx.expr()) {
+            exprs.add(visit(expr));
+        }
+
+        // A trailer could be `.methodName()`.
+        TerminalNode methodCall = null;
+        if (ctx.DOT() != null) {
+            methodCall = ctx.NAME();
+        }
+
+        return new TrailerNode(arglist, exprs, methodCall);
+    }
+
+    /**
+     * Returns a `Node`.
+     * FIXME: what to do in case of list??
+     *
+     * ```
+     * exprlist : expr (',' expr )* ','? ;
+     * ```
+     */
+    public Node visitExprlist(ExprlistContext ctx) {
+        Node exp = visit(ctx.expr(0));
+
+        return exp;
+    }
+
+    /**
+     * Returns a `ArglistNode`.
+     *
+     * ```
+     * arglist : argument (',' argument)* ','? ;
+     * ```
+     */
+    public Node visitArglist(ArglistContext ctx) {
+        ArrayList<Node> arguments = new ArrayList<Node>();
+
+        for (ArgumentContext c : ctx.argument()) {
+            arguments.add(visit(c));
+        }
+
+        return new ArglistNode(arguments);
+    }
+}
diff --git a/src/ast/nodes/ArglistNode.java b/src/ast/nodes/ArglistNode.java
new file mode 100644
index 0000000..8a5b4b9
--- /dev/null
+++ b/src/ast/nodes/ArglistNode.java
@@ -0,0 +1,53 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `arglist` statement of the grammar.
+ */
+public class ArglistNode implements Node {
+    protected ArrayList<Node> arguments;
+
+    public ArglistNode(ArrayList<Node> arguments) {
+        this.arguments = arguments;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        for (var arg : arguments) {
+            errors.addAll(arg.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for arglist node
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "ArglistNode\n";
+
+        prefix += "  ";
+        for (Node arg : arguments) {
+            str += arg.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/AssignmentNode.java b/src/ast/nodes/AssignmentNode.java
new file mode 100644
index 0000000..d722f41
--- /dev/null
+++ b/src/ast/nodes/AssignmentNode.java
@@ -0,0 +1,52 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `assignment` statement of the grammar.
+ */
+public class AssignmentNode implements Node {
+    private Node lhr;
+    private Node assign;
+    private Node rhr;
+
+    public AssignmentNode(Node lhr, Node assign, Node rhr) {
+        this.lhr = lhr;
+        this.assign = assign;
+        this.rhr = rhr;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        errors.addAll(lhr.checkSemantics(ST, _nesting));
+        errors.addAll(assign.checkSemantics(ST, _nesting));
+        errors.addAll(rhr.checkSemantics(ST, _nesting));
+
+        return errors;
+    }
+
+    // TODO: check it out for this type
+    @Override
+    public Type typeCheck() {
+        return rhr.typeCheck();
+    }
+
+    // TODO: add code generation for assignment
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        return prefix + "Assignment\n" + lhr.toPrint(prefix + "  ") + assign.toPrint(prefix + "  ")
+                + rhr.toPrint(prefix + "  ");
+    }
+
+}
diff --git a/src/ast/nodes/AtomNode.java b/src/ast/nodes/AtomNode.java
new file mode 100644
index 0000000..fa81f92
--- /dev/null
+++ b/src/ast/nodes/AtomNode.java
@@ -0,0 +1,45 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `atom` statement of the grammar.
+ */
+public class AtomNode implements Node {
+    protected String val;
+
+    public AtomNode(String val) {
+        this.val = val;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        return new ArrayList<SemanticError>();
+    }
+
+    // FIXME: this type for atom
+    @Override
+    public Type typeCheck() {
+        return new AtomType();
+    }
+
+    // TODO: add code generation for atom node
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        if (val != null) {
+            return prefix + "Atom(" + val + ")\n";
+        }
+
+        return prefix + "Atom(null)\n";
+
+    }
+}
diff --git a/src/ast/nodes/AugassignNode.java b/src/ast/nodes/AugassignNode.java
new file mode 100644
index 0000000..3519b50
--- /dev/null
+++ b/src/ast/nodes/AugassignNode.java
@@ -0,0 +1,42 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+
+import com.clp.project.ast.types.*;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * Node for the `augassign` statement of the grammar.
+ */
+public class AugassignNode implements Node {
+    private TerminalNode val;
+
+    public AugassignNode(TerminalNode val) {
+        this.val = val;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        return new ArrayList<SemanticError>();
+    }
+
+    // FIXME: use the right type
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for augassign node
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        return prefix + "Augassign(" + val + ")\n";
+    }
+}
diff --git a/src/ast/nodes/BlockNode.java b/src/ast/nodes/BlockNode.java
new file mode 100644
index 0000000..1fdfcc3
--- /dev/null
+++ b/src/ast/nodes/BlockNode.java
@@ -0,0 +1,38 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for `block` statement of the grammar.
+ * It extends the `RootNode`.
+ */
+public class BlockNode extends RootNode implements Node {
+    public BlockNode(ArrayList<Node> stmts, ArrayList<Node> compoundStmts) {
+        super(stmts, compoundStmts);
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "Block\n";
+
+        prefix += "  ";
+        for (Node stmt : stmts) {
+            str += stmt.toPrint(prefix);
+        }
+        for (Node stmt : compoundStmts) {
+            str += stmt.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/CompNode.java b/src/ast/nodes/CompNode.java
new file mode 100644
index 0000000..6deb51c
--- /dev/null
+++ b/src/ast/nodes/CompNode.java
@@ -0,0 +1,41 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * Node for the `comp_op` statement of the grammar.
+ */
+public class CompNode implements Node {
+    private TerminalNode op;
+
+    public CompNode(TerminalNode op) {
+        this.op = op;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        return new ArrayList<SemanticError>();
+    }
+
+    // TODO: it should be boolean, right?
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for CompNode
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        return prefix + "CompNode(" + op + ")\n";
+    }
+}
diff --git a/src/ast/nodes/CompoundNode.java b/src/ast/nodes/CompoundNode.java
new file mode 100644
index 0000000..bfa0523
--- /dev/null
+++ b/src/ast/nodes/CompoundNode.java
@@ -0,0 +1,84 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `compound_node` statement of the grammar.
+ */
+public class CompoundNode implements Node {
+    private Node ifNode;
+    private Node funcDef;
+    private Node forStmt;
+    private Node whileStmt;
+
+    public CompoundNode(Node ifNode, Node funcDef, Node forStmt, Node whileStmt) {
+        this.ifNode = ifNode;
+        this.funcDef = funcDef;
+        this.forStmt = forStmt;
+        this.whileStmt = whileStmt;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        if (ifNode != null) {
+            errors.addAll(ifNode.checkSemantics(ST, _nesting));
+        }
+
+        if (funcDef != null) {
+            errors.addAll(funcDef.checkSemantics(ST, _nesting));
+        }
+
+        if (forStmt != null) {
+            errors.addAll(forStmt.checkSemantics(ST, _nesting));
+        }
+
+        if (whileStmt != null) {
+            errors.addAll(whileStmt.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for CompoundNode
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "CompoundNode\n";
+
+        prefix += "  ";
+
+        if (ifNode != null) {
+            str += ifNode.toPrint(prefix);
+        }
+
+        if (funcDef != null) {
+            str += funcDef.toPrint(prefix);
+        }
+
+        if (forStmt != null) {
+            str += forStmt.toPrint(prefix);
+        }
+
+        if (whileStmt != null) {
+            str += whileStmt.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/DottedNameNode.java b/src/ast/nodes/DottedNameNode.java
new file mode 100644
index 0000000..342950a
--- /dev/null
+++ b/src/ast/nodes/DottedNameNode.java
@@ -0,0 +1,51 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * Node for the `dooted_name` statement of the grammar.
+ */
+public class DottedNameNode implements Node {
+    protected ArrayList<TerminalNode> names;
+
+    public DottedNameNode(ArrayList<TerminalNode> names) {
+        this.names = names;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // NOTE: we do not provide code generation for this node in the same way
+    // we do not want to do this for the import stm.
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "DottedName\n";
+
+        prefix += "  ";
+        for (var name : names) {
+            str += prefix + name.toString() + "\n";
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/ExprNode.java b/src/ast/nodes/ExprNode.java
new file mode 100644
index 0000000..3aa112f
--- /dev/null
+++ b/src/ast/nodes/ExprNode.java
@@ -0,0 +1,90 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `expr` statement of the grammar.
+ */
+public class ExprNode implements Node {
+    private Node atom;
+    private Node compOp;
+    private String op;
+    private ArrayList<Node> exprs;
+    private ArrayList<Node> trailers;
+
+    public ExprNode(Node atom, Node compOp, ArrayList<Node> exprs, String op, ArrayList<Node> trailers) {
+        this.atom = atom;
+        this.compOp = compOp;
+        this.exprs = exprs;
+        this.op = op;
+        this.trailers = trailers;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        if (atom != null) {
+            errors.addAll(atom.checkSemantics(ST, _nesting));
+        }
+
+        if (compOp != null) {
+            errors.addAll(compOp.checkSemantics(ST, _nesting));
+        }
+
+        for (var expr : exprs) {
+            errors.addAll(expr.checkSemantics(ST, _nesting));
+        }
+
+        for (var trailer : trailers) {
+            errors.addAll(trailer.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    // FIXME: type for the expr
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for expr
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "Expr\n";
+
+        prefix += "  ";
+        if (atom != null) {
+            str += atom.toPrint(prefix);
+        }
+
+        if (compOp != null) {
+            str += compOp.toPrint(prefix);
+        }
+
+        for (var expr : exprs) {
+            str += expr.toPrint(prefix);
+        }
+
+        for (var trailer : trailers) {
+            str += trailer.toPrint(prefix);
+        }
+
+        if (op != null) {
+            str += prefix + "Op(" + op + ")\n";
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/ForStmtNode.java b/src/ast/nodes/ForStmtNode.java
new file mode 100644
index 0000000..69dee74
--- /dev/null
+++ b/src/ast/nodes/ForStmtNode.java
@@ -0,0 +1,47 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `for_stmt` statement of the grammar.
+ */
+public class ForStmtNode implements Node {
+    private Node exprList;
+    private Node block;
+
+    public ForStmtNode(Node exprList, Node block) {
+        this.exprList = exprList;
+        this.block = block;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        errors.addAll(exprList.checkSemantics(ST, _nesting));
+        errors.addAll(block.checkSemantics(ST, _nesting));
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for while
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        return prefix + "For\n" + exprList.toPrint(prefix + "  ") + block.toPrint(prefix + "  ");
+    }
+
+}
diff --git a/src/ast/nodes/FuncdefNode.java b/src/ast/nodes/FuncdefNode.java
new file mode 100644
index 0000000..c48eb1c
--- /dev/null
+++ b/src/ast/nodes/FuncdefNode.java
@@ -0,0 +1,63 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * Node for the `funcdef` statement of the grammar.
+ */
+public class FuncdefNode implements Node {
+    private TerminalNode name;
+    private Node paramlist;
+    private Node block;
+
+    public FuncdefNode(TerminalNode name, Node paramlist, Node block) {
+        this.name = name;
+        this.paramlist = paramlist;
+        this.block = block;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        if (paramlist != null) {
+            errors.addAll(paramlist.checkSemantics(ST, _nesting));
+        }
+
+        errors.addAll(block.checkSemantics(ST, _nesting));
+
+        return errors;
+    }
+
+    // FIXME: this type must be the same of the return stmt variable
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: code generation for funcdef
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    public String toPrint(String prefix) {
+        String str = prefix + "Funcdef(" + name + ")\n";
+
+        prefix += "  ";
+
+        if (paramlist != null) {
+            str += paramlist.toPrint(prefix);
+        }
+
+        str += block.toPrint(prefix);
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/IfNode.java b/src/ast/nodes/IfNode.java
new file mode 100644
index 0000000..a4f160d
--- /dev/null
+++ b/src/ast/nodes/IfNode.java
@@ -0,0 +1,71 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `if` statement of the grammar.
+ */
+public class IfNode implements Node {
+    private Node guard;
+    private Node thenbranch;
+    private Node elsebranch;
+
+    public IfNode(Node guard, Node thenbranch, Node elsebranch) {
+        this.guard = guard;
+        this.thenbranch = thenbranch;
+        this.elsebranch = elsebranch;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        errors.addAll(guard.checkSemantics(ST, _nesting));
+        errors.addAll(thenbranch.checkSemantics(ST, _nesting));
+        if (elsebranch != null) {
+            errors.addAll(elsebranch.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    // FIXME: fix the if statement
+    @Override
+    public Type typeCheck() {
+        if (guard.typeCheck() instanceof BoolType) {
+            Type thenexp = thenbranch.typeCheck();
+            Type elseexp = elsebranch.typeCheck();
+            if (thenexp.getClass().equals(elseexp.getClass()))
+                return thenexp;
+            else {
+                System.out.println("Type Error: incompatible types in then and else branches");
+                return new ErrorType();
+            }
+        } else {
+            System.out.println("Type Error: non boolean condition in if");
+            return new ErrorType();
+        }
+    }
+
+    // TODO: add code generation for if
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "If\n" + guard.toPrint(prefix + "  ") + thenbranch.toPrint(prefix + "  ");
+
+        if (elsebranch != null) {
+            str += elsebranch.toPrint(prefix + "  ");
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/ImportNode.java b/src/ast/nodes/ImportNode.java
new file mode 100644
index 0000000..e6ac8c7
--- /dev/null
+++ b/src/ast/nodes/ImportNode.java
@@ -0,0 +1,76 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `import_stmt` statement of the grammar.
+ */
+public class ImportNode implements Node {
+    private Node dottedName;
+    private boolean isFrom;
+    private boolean importAs;
+    private boolean importAll;
+    private ArrayList<String> names;
+
+    public ImportNode(Node dottedName, boolean isFrom, boolean importAs, boolean importAll,
+            ArrayList<String> names) {
+        this.dottedName = dottedName;
+        this.isFrom = isFrom;
+        this.importAs = importAs;
+        this.importAll = importAll;
+        this.names = names;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // NOTE: we do not want to provide a code generation for this statement
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "Import\n";
+
+        prefix += "  ";
+        if (isFrom) {
+            str += prefix + "  From\n" + dottedName.toPrint(prefix + "  ");
+        } else {
+            str += dottedName.toPrint(prefix);
+        }
+
+        if (importAs) {
+            str += prefix + "  As " + names.get(0) + "\n";
+        }
+
+        if (importAll) {
+            str += prefix + "  All\n";
+        }
+
+        for (int i = 0; i < names.size(); ++i) {
+            if (i == 0 && importAs)
+                continue;
+
+            str += prefix + names.get(i) + "\n";
+        }
+
+        str += "\n";
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/Node.java b/src/ast/nodes/Node.java
new file mode 100644
index 0000000..f807745
--- /dev/null
+++ b/src/ast/nodes/Node.java
@@ -0,0 +1,36 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Base interface for a Node.
+ */
+public interface Node {
+    /**
+     * Checks semantics for a given node for a SymbolTable ST and a level of
+     * nesting.
+     * Returns a list of `SemanticError`.
+     */
+    ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting);
+
+    /**
+     * Checks the type for a given node. If there's any error, returns an
+     * `ErrorType`.
+     */
+    Type typeCheck();
+
+    /**
+     * Returns a string for the Python Virtual Machine.
+     */
+    String codeGeneration();
+
+    /**
+     * Returns a string for a given node with a prefix.
+     * It used when an AST wants to be visualized on screen.
+     */
+    String toPrint(String prefix);
+}
diff --git a/src/ast/nodes/ParamdefNode.java b/src/ast/nodes/ParamdefNode.java
new file mode 100644
index 0000000..d8e04f7
--- /dev/null
+++ b/src/ast/nodes/ParamdefNode.java
@@ -0,0 +1,29 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `paramdef` statement of the grammar. Extends the `AtomNode`
+ * class.
+ */
+public class ParamdefNode extends AtomNode implements Node {
+    public ParamdefNode(String val) {
+        super(val);
+    }
+
+    // FIXME: it should returns the param' type
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        return prefix + "Paramdef(" + val + ")\n";
+    }
+}
diff --git a/src/ast/nodes/ParamlistNode.java b/src/ast/nodes/ParamlistNode.java
new file mode 100644
index 0000000..d4f40b8
--- /dev/null
+++ b/src/ast/nodes/ParamlistNode.java
@@ -0,0 +1,53 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `param_list` statement of the grammar.
+ */
+public class ParamlistNode implements Node {
+    private ArrayList<Node> params;
+
+    public ParamlistNode(ArrayList<Node> _params) {
+        params = _params;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        for (var param : params) {
+            errors.addAll(param.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: code generation for param list
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "Paramlist\n";
+
+        prefix += "  ";
+        for (var param : params) {
+            str += param.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/ReturnStmtNode.java b/src/ast/nodes/ReturnStmtNode.java
new file mode 100644
index 0000000..0cfd2b4
--- /dev/null
+++ b/src/ast/nodes/ReturnStmtNode.java
@@ -0,0 +1,57 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `return_stmt` statement of the grammar.
+ */
+public class ReturnStmtNode implements Node {
+    private Node exprList;
+
+    public ReturnStmtNode(Node exprList) {
+        this.exprList = exprList;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        if (this.exprList != null) {
+            errors.addAll(this.exprList.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        if (this.exprList != null) {
+            return this.exprList.typeCheck();
+        }
+
+        return new VoidType();
+    }
+
+    // TODO: add code generation for return stmt
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "ReturnStmt\n";
+
+        prefix += "  ";
+        if (this.exprList != null) {
+            str += this.exprList.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/RootNode.java b/src/ast/nodes/RootNode.java
new file mode 100644
index 0000000..12d2f22
--- /dev/null
+++ b/src/ast/nodes/RootNode.java
@@ -0,0 +1,64 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `root` statement of the grammar.
+ */
+public class RootNode implements Node {
+    // stms and compundStmts are protected because they are reused for a
+    // BlockNode
+    protected ArrayList<Node> stmts;
+    protected ArrayList<Node> compoundStmts;
+
+    public RootNode(ArrayList<Node> stmts, ArrayList<Node> compoundStmts) {
+        this.stmts = stmts;
+        this.compoundStmts = compoundStmts;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        for (Node stmt : stmts) {
+            errors.addAll(stmt.checkSemantics(ST, _nesting));
+        }
+        for (Node stmt : compoundStmts) {
+            errors.addAll(stmt.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: Code generation for RootNode
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = "Root\n";
+
+        prefix += "  ";
+
+        for (Node stmt : stmts) {
+            str += stmt.toPrint(prefix);
+        }
+        for (Node stmt : compoundStmts) {
+            str += stmt.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/SimpleStmtNode.java b/src/ast/nodes/SimpleStmtNode.java
new file mode 100644
index 0000000..3f4dec3
--- /dev/null
+++ b/src/ast/nodes/SimpleStmtNode.java
@@ -0,0 +1,84 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `simple_stmt` statement of the grammar.
+ */
+public class SimpleStmtNode implements Node {
+    private Node assignment;
+    private Node expr;
+    private Node returnStmt;
+    private Node importStmt;
+
+    public SimpleStmtNode(Node assignment, Node expr, Node returnStmt, Node importStmt) {
+        this.assignment = assignment;
+        this.expr = expr;
+        this.returnStmt = returnStmt;
+        this.importStmt = importStmt;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        if (assignment != null) {
+            errors.addAll(assignment.checkSemantics(ST, _nesting));
+        }
+
+        if (expr != null) {
+            errors.addAll(expr.checkSemantics(ST, _nesting));
+        }
+
+        if (returnStmt != null) {
+            errors.addAll(returnStmt.checkSemantics(ST, _nesting));
+        }
+
+        if (importStmt != null) {
+            errors.addAll(importStmt.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for SimpleStmtNode
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "SimpleStmt\n";
+
+        prefix += "  ";
+
+        if (assignment != null) {
+            str += assignment.toPrint(prefix);
+        }
+
+        if (expr != null) {
+            str += expr.toPrint(prefix);
+        }
+
+        if (returnStmt != null) {
+            str += returnStmt.toPrint(prefix);
+        }
+
+        if (importStmt != null) {
+            str += importStmt.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/SimpleStmtsNode.java b/src/ast/nodes/SimpleStmtsNode.java
new file mode 100644
index 0000000..c8013a3
--- /dev/null
+++ b/src/ast/nodes/SimpleStmtsNode.java
@@ -0,0 +1,54 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `simple_stmts` statement of the grammar.
+ */
+public class SimpleStmtsNode implements Node {
+    private ArrayList<Node> stmts;
+
+    public SimpleStmtsNode(ArrayList<Node> stmts) {
+        this.stmts = stmts;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        for (Node stmt : stmts) {
+            errors.addAll(stmt.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: Code generation for SimpleStmtsNode
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "SimpleStmts\n";
+
+        prefix += "  ";
+
+        for (Node stmt : stmts) {
+            str += stmt.toPrint(prefix);
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/TrailerNode.java b/src/ast/nodes/TrailerNode.java
new file mode 100644
index 0000000..fa7e1ed
--- /dev/null
+++ b/src/ast/nodes/TrailerNode.java
@@ -0,0 +1,78 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * Node for the `trailer` statement of the grammar.
+ */
+public class TrailerNode implements Node {
+    private Node arglist;
+    private ArrayList<Node> exprs;
+    private TerminalNode methodCall;
+    private boolean isEmpty;
+
+    public TrailerNode(Node arglist, ArrayList<Node> exprs, TerminalNode methodCall) {
+        this.arglist = arglist;
+        this.exprs = exprs;
+        this.methodCall = methodCall;
+
+        this.isEmpty = (this.arglist == null && this.exprs.size() == 0 && this.methodCall == null);
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        if (arglist != null) {
+            errors.addAll(arglist.checkSemantics(ST, _nesting));
+        }
+
+        for (var expr : exprs) {
+            errors.addAll(expr.checkSemantics(ST, _nesting));
+        }
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for trailer node
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        String str = prefix + "TrailerNode\n";
+
+        prefix += "  ";
+
+        if (arglist != null) {
+            str += arglist.toPrint(prefix);
+        }
+
+        for (var expr : exprs) {
+            str += expr.toPrint(prefix);
+        }
+
+        if (methodCall != null) {
+            str += prefix + "Method(" + methodCall + ")\n";
+        }
+
+        if (isEmpty) {
+            str += prefix + "()\n";
+        }
+
+        return str;
+    }
+
+}
diff --git a/src/ast/nodes/WhileStmtNode.java b/src/ast/nodes/WhileStmtNode.java
new file mode 100644
index 0000000..a84d60e
--- /dev/null
+++ b/src/ast/nodes/WhileStmtNode.java
@@ -0,0 +1,46 @@
+package com.clp.project.ast.nodes;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.types.*;
+
+/**
+ * Node for the `while_stmt` statement of the grammar.
+ */
+public class WhileStmtNode implements Node {
+    private Node expr;
+    private Node block;
+
+    public WhileStmtNode(Node expr, Node block) {
+        this.expr = expr;
+        this.block = block;
+    }
+
+    @Override
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        ArrayList<SemanticError> errors = new ArrayList<SemanticError>();
+
+        errors.addAll(expr.checkSemantics(ST, _nesting));
+        errors.addAll(block.checkSemantics(ST, _nesting));
+
+        return errors;
+    }
+
+    @Override
+    public Type typeCheck() {
+        return new VoidType();
+    }
+
+    // TODO: add code generation for while
+    @Override
+    public String codeGeneration() {
+        return "";
+    }
+
+    @Override
+    public String toPrint(String prefix) {
+        return prefix + "While\n" + expr.toPrint(prefix + "  ") + block.toPrint(prefix + "  ");
+    }
+}
diff --git a/src/ast/types/AtomType.java b/src/ast/types/AtomType.java
new file mode 100644
index 0000000..a44a06c
--- /dev/null
+++ b/src/ast/types/AtomType.java
@@ -0,0 +1,11 @@
+package com.clp.project.ast.types;
+
+/**
+ * An tom type.
+ * TODO: do I need to use this one?
+ */
+public class AtomType extends Type {
+    public String toPrint(String prefix) {
+        return prefix + "Atom\n";
+    }
+}
diff --git a/src/ast/types/BoolType.java b/src/ast/types/BoolType.java
new file mode 100644
index 0000000..7fc28ee
--- /dev/null
+++ b/src/ast/types/BoolType.java
@@ -0,0 +1,10 @@
+package com.clp.project.ast.types;
+
+/**
+ * A boolean type. A bool is True or False.
+ */
+public class BoolType extends Type {
+    public String toPrint(String prefix) {
+        return prefix + "Bool\n";
+    }
+}
diff --git a/src/ast/types/ErrorType.java b/src/ast/types/ErrorType.java
new file mode 100644
index 0000000..30cb70e
--- /dev/null
+++ b/src/ast/types/ErrorType.java
@@ -0,0 +1,10 @@
+package com.clp.project.ast.types;
+
+/**
+ * Error type.
+ */
+public class ErrorType extends Type {
+    public String toPrint(String prefix) {
+        return prefix + "Error\n";
+    }
+}
diff --git a/src/ast/types/IntType.java b/src/ast/types/IntType.java
new file mode 100644
index 0000000..9f4b250
--- /dev/null
+++ b/src/ast/types/IntType.java
@@ -0,0 +1,10 @@
+package com.clp.project.ast.types;
+
+/**
+ * An integer type.
+ */
+public class IntType extends Type {
+    public String toPrint(String prefix) {
+        return prefix + "Int\n";
+    }
+}
diff --git a/src/ast/types/Type.java b/src/ast/types/Type.java
new file mode 100644
index 0000000..4756255
--- /dev/null
+++ b/src/ast/types/Type.java
@@ -0,0 +1,41 @@
+package com.clp.project.ast.types;
+
+import java.util.ArrayList;
+
+import com.clp.project.semanticanalysis.SemanticError;
+import com.clp.project.semanticanalysis.SymbolTable;
+import com.clp.project.ast.nodes.*;
+
+/**
+ * A node which represents a type class.
+ */
+public class Type implements Node {
+    public boolean isEqual(Type A, Type B) {
+        if (A.getClass().equals(B.getClass()))
+            return true;
+        else
+            return false;
+    }
+
+    public String toPrint(String s) {
+        return s;
+    }
+
+    public ArrayList<SemanticError> checkSemantics(SymbolTable ST, int _nesting) {
+        // It is never invoked
+        return null;
+    }
+
+    @Override
+    public Type typeCheck() {
+        // It is never invoked
+        return null;
+    }
+
+    @Override
+    public String codeGeneration() {
+        // It is never invoked
+        return "";
+    }
+
+}
diff --git a/src/ast/types/VoidType.java b/src/ast/types/VoidType.java
new file mode 100644
index 0000000..766aee2
--- /dev/null
+++ b/src/ast/types/VoidType.java
@@ -0,0 +1,10 @@
+package com.clp.project.ast.types;
+
+/**
+ * A void type. Voids return nothing.
+ */
+public class VoidType extends Type {
+    public String toPrint(String prefix) {
+        return prefix + "Void\n";
+    }
+}