Merge remote-tracking branch 'origin/johns-branch' into code-generator

src/main/java/CompilerInput.txt

@@ -5,9 +5,7 @@ public class Example {
     public static int testMethod(char b){
 
          int a;
-         boolean b;
+         int a;
-         char c;
-         b = 3;
 
 
     }

src/main/java/ast/ClassNode.java

@@ -11,7 +11,7 @@ import java.util.List;
 import bytecode.visitor.ClassVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public class ClassNode implements ASTNode, Visitable {
     public String identifier;

src/main/java/ast/ProgramNode.java

@@ -6,7 +6,7 @@ import java.util.List;
 import bytecode.visitor.ProgramVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public class ProgramNode implements ASTNode, Visitable{
     public List<ClassNode> classes = new ArrayList<>();

src/main/java/ast/VarNode.java

@@ -2,7 +2,7 @@ package ast;
 
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public class VarNode implements ASTNode, Visitable {
 

src/main/java/ast/expression/BinaryExpressionNode.java

@@ -2,8 +2,9 @@ package ast.expression;
 
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
+import visitor.Visitable;
 
-public class BinaryExpressionNode implements ExpressionNode {
+public class BinaryExpressionNode implements ExpressionNode, Visitable {
     public ExpressionNode left;
     public ExpressionNode right;
     public String operator;  // Stores the operator as a string (e.g., "+", "-", "&&")
@@ -16,6 +17,6 @@ public class BinaryExpressionNode implements ExpressionNode {
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
+        return visitor.analyze(this);
     }
 }

src/main/java/ast/expression/ExpressionNode.java

@@ -1,7 +1,7 @@
 package ast.expression;
 
 import ast.ASTNode;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public interface ExpressionNode extends ASTNode, Visitable {
 

src/main/java/ast/expression/IdentifierExpressionNode.java

@@ -1,11 +1,15 @@
 package ast.expression;
 
+import ast.type.TypeNode;
 import semantic.SemanticVisitor;
-import typechecker.TypeCheckResult;
-import typechecker.Visitable;
 
-public class IdentifierExpressionNode implements ExpressionNode {
+import typechecker.TypeCheckResult;
+import visitor.Visitable;
+
+public class IdentifierExpressionNode implements ExpressionNode, Visitable {
     public String name;
+    public TypeNode type;
+
 
     public IdentifierExpressionNode(String name) {
         this.name = name;
@@ -13,6 +17,6 @@ public class IdentifierExpressionNode implements ExpressionNode {
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
+        return visitor.analyze(this);
     }
 }

src/main/java/ast/expression/UnaryExpressionNode.java

@@ -2,8 +2,9 @@ package ast.expression;
 
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
+import visitor.Visitable;
 
-public class UnaryExpressionNode implements ExpressionNode {
+public class UnaryExpressionNode implements ExpressionNode, Visitable {
     public ExpressionNode expression;
     public String operator;  // Stores the operator (e.g., "-", "!")
 
@@ -14,6 +15,6 @@ public class UnaryExpressionNode implements ExpressionNode {
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
+        return visitor.analyze(this);
     }
 }

src/main/java/ast/member/ConstructorNode.java

@@ -2,7 +2,7 @@ package ast.member;
 
 import ast.type.AccessTypeNode;
 import bytecode.visitor.MethodVisitor;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public class ConstructorNode extends MethodNode implements Visitable {
     public ConstructorNode(AccessTypeNode visibility, String name) {

src/main/java/ast/member/FieldNode.java

@@ -5,7 +5,7 @@ import ast.type.TypeNode;
 import bytecode.visitor.ClassVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public class FieldNode implements MemberNode, Visitable {
     public AccessTypeNode accessTypeNode;

src/main/java/ast/member/MethodNode.java

@@ -3,15 +3,15 @@ package ast.member;
 import ast.parameter.ParameterListNode;
 import ast.statement.StatementNode;
 import ast.type.AccessTypeNode;
-import ast.type.TypeNode;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import ast.type.TypeNode;
 import bytecode.visitor.MethodVisitor;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public class MethodNode implements MemberNode, Visitable {
     public AccessTypeNode visibility;

src/main/java/ast/statement/AssignmentStatementNode.java

@@ -4,7 +4,7 @@ import ast.VarNode;
 import ast.expression.ExpressionNode;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
-import typechecker.Visitable;
+import visitor.Visitable;
 
 public class AssignmentStatementNode extends StatementNode implements Visitable {
   public VarNode varNode;

src/main/java/ast/statement/IfStatementNode.java

@@ -1,6 +1,8 @@
 package ast.statement;
 
 import ast.expression.ExpressionNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
 
 public class IfStatementNode extends StatementNode {
     public ExpressionNode condition;
@@ -12,4 +14,9 @@ public class IfStatementNode extends StatementNode {
         this.thenStatement = thenStatement;
         this.elseStatement = elseStatement;
     }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
 }

src/main/java/ast/statement/ReturnStatementNode.java

@@ -1,6 +1,8 @@
 package ast.statement;
 
 import ast.expression.ExpressionNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
 
 public class ReturnStatementNode extends StatementNode {
     public ExpressionNode expression;
@@ -8,4 +10,9 @@ public class ReturnStatementNode extends StatementNode {
     public ReturnStatementNode(ExpressionNode expression) {
         this.expression = expression;
     }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
 }

src/main/java/ast/statement/StatementNode.java

@@ -1,7 +1,8 @@
 package ast.statement;
 
 import ast.ASTNode;
+import visitor.Visitable;
 
-public abstract class StatementNode implements ASTNode {
+public abstract class StatementNode implements ASTNode, Visitable {
 }
 

src/main/java/ast/statement/VariableDeclarationStatementNode.java

@@ -1,7 +1,9 @@
 package ast.statement;
 
-import ast.type.TypeNode;
 import ast.expression.ExpressionNode;
+import ast.type.TypeNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
 
 public class VariableDeclarationStatementNode extends StatementNode {
     public TypeNode type;
@@ -12,4 +14,9 @@ public class VariableDeclarationStatementNode extends StatementNode {
         this.identifier = identifier;
         this.expression = expression;
     }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
 }

src/main/java/ast/statement/WhileStatementNode.java

@@ -1,6 +1,8 @@
 package ast.statement;
 
 import ast.expression.ExpressionNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
 
 public class WhileStatementNode extends StatementNode {
     public ExpressionNode condition;
@@ -10,4 +12,9 @@ public class WhileStatementNode extends StatementNode {
         this.condition = condition;
         this.body = body;
     }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
 }

src/main/java/ast/type/BaseTypeNode.java

@@ -1,6 +1,8 @@
 package ast.type;
 
-public class BaseTypeNode implements TypeNode{
+import ast.ASTNode;
+
+public class BaseTypeNode implements ASTNode, TypeNode {
 
     public EnumTypeNode enumType;
 

src/main/java/ast/type/ReferenceTypeNode.java

@@ -1,4 +1,6 @@
 package ast.type;
 
-public class ReferenceTypeNode implements TypeNode{
+import ast.ASTNode;
+
+public class ReferenceTypeNode implements ASTNode, TypeNode {
 }

src/main/java/bytecode/Mapper.java

@@ -4,6 +4,7 @@ import ast.parameter.ParameterListNode;
 import ast.parameter.ParameterNode;
 import ast.type.*;
 import org.objectweb.asm.Opcodes;
+import ast.type.BaseTypeNode;
 
 public class Mapper {
     public int mapAccessTypeToOpcode(AccessTypeNode type) {

src/main/java/parser/ASTBuilder.java

@@ -13,10 +13,12 @@ import ast.parameter.ParameterNode;
 import ast.statement.*;
 import ast.type.*;
 import org.antlr.v4.runtime.tree.TerminalNode;
+
 import java.util.ArrayList;
 import java.util.List;
 import parser.generated.*;
 import parser.generated.SimpleJavaParser.LiteralContext;
+import ast.type.BaseTypeNode;
 
 public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
     @Override
@@ -74,9 +76,9 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitParameter(SimpleJavaParser.ParameterContext ctx) {
-        TypeNode type = (TypeNode) visit(ctx.type());
+        TypeNode typeNode = (TypeNode) visit(ctx.type());
         String identifier = ctx.IDENTIFIER().getText();
-        return new ParameterNode(type, identifier);
+        return new ParameterNode(typeNode, identifier);
     }
 
     @Override

src/main/java/semantic/Scope.java

@@ -0,0 +1,36 @@
+package semantic;
+
+import ast.type.TypeNode;
+
+import java.util.HashMap;
+import java.util.Stack;
+
+public class Scope {
+
+    private Stack<HashMap<String, TypeNode>> localVars;
+
+    public void addLocalVar(String name, TypeNode type) {
+        if (this.contains(name)) {
+            throw new RuntimeException("Variable " + name + " already exists in this scope");
+        }
+        localVars.peek().put(name, type);
+    }
+
+    public boolean contains(String name) {
+        for (HashMap<String, TypeNode> map : localVars) {
+            if (map.containsKey(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void pushScope() {
+        localVars.push(new HashMap<String, TypeNode>());
+    }
+
+    public void popScope() {
+        localVars.pop();
+    }
+
+}

src/main/java/semantic/SemanticAnalyzer.java

@@ -2,101 +2,145 @@ package semantic;
 
 
 import ast.*;
-import ast.expression.ExpressionNode;
+import ast.expression.BinaryExpressionNode;
-import ast.member.ConstructorNode;
+import ast.expression.IdentifierExpressionNode;
+import ast.expression.UnaryExpressionNode;
 import ast.member.FieldNode;
 import ast.member.MemberNode;
 
 import ast.member.MethodNode;
-import ast.statement.AssignmentStatementNode;
+import ast.statement.*;
-import ast.statement.StatementNode;
+
 import java.util.ArrayList;
 import java.util.List;
 
-import ast.type.TypeNode;
 import typechecker.TypeCheckResult;
 
 public class SemanticAnalyzer implements SemanticVisitor {
 
-  private ArrayList<String> currentFields = new ArrayList<>();
+    private ArrayList<String> currentFields = new ArrayList<>();
 
-  public static ASTNode generateTast(ASTNode node) throws RuntimeException {
+    private Scope currentScope;
-    SemanticAnalyzer semanticCheck = new SemanticAnalyzer();
-    ProgramNode programNode = (ProgramNode) node;
-    var result = programNode.accept(semanticCheck);
-    if (result.isValid()) {
-      return node;
-    } else {
-      throw new RuntimeException("Not Valid");
-    }
-  }
 
-  @Override
+    public static ASTNode generateTast(ASTNode node) throws RuntimeException {
-  public TypeCheckResult analyze(ProgramNode node) {
+        SemanticAnalyzer semanticCheck = new SemanticAnalyzer();
-
+        ProgramNode programNode = (ProgramNode) node;
-    var valid = true;
+        var result = programNode.accept(semanticCheck);
-
+        if (result.isValid()) {
-    List<ClassNode> classes = node.classes;
+            return node;
-    for (ClassNode classNode : classes) {
+        } else {
-      var result = classNode.accept(this);
+            throw new RuntimeException("Not Valid");
-      valid = valid && result.isValid();
+        }
-    }
-    return new TypeCheckResult(valid, null);
-  }
-
-  @Override
-  public TypeCheckResult analyze(ClassNode classNode) {
-    var valid = true;
-    List<MemberNode> members = classNode.members;
-    for (MemberNode memberNode : members) {
-      if (memberNode instanceof FieldNode fieldNode) {
-        var result = fieldNode.accept(this);
-        valid = valid && result.isValid();
-      } else if (memberNode instanceof MethodNode methodNode) {
-        var result = methodNode.accept(this);
-        valid = valid && result.isValid();
-      }
     }
 
-    return new TypeCheckResult(valid, null);
+    @Override
+    public TypeCheckResult analyze(ProgramNode node) {
 
-  }
+        var valid = true;
 
-  @Override
+        List<ClassNode> classes = node.classes;
-  public TypeCheckResult analyze(MethodNode methodNode) {
+        for (ClassNode classNode : classes) {
-    var valid = true;
+            var result = classNode.accept(this);
-    List<StatementNode> statements = methodNode.statements;
+            valid = valid && result.isValid();
-    for (StatementNode statement : statements) {
+        }
-      if(statement instanceof AssignmentStatementNode assignmentStatementNode) {
+        return new TypeCheckResult(valid, null);
-        var result = assignmentStatementNode.accept(this);
-        valid = valid && result.isValid();
-      }
     }
-    return new TypeCheckResult(valid, null);
-  }
 
-  @Override
+    @Override
-  public TypeCheckResult analyze(FieldNode toCheck) {
+    public TypeCheckResult analyze(ClassNode classNode) {
-    if(currentFields.contains(toCheck.identifier)){
+        var valid = true;
-      throw new RuntimeException(toCheck.identifier + " Is Already Declared");
+        List<MemberNode> members = classNode.members;
-    }else {
+        for (MemberNode memberNode : members) {
-      currentFields.add(toCheck.identifier);
+            if (memberNode instanceof FieldNode fieldNode) {
+                var result = fieldNode.accept(this);
+                valid = valid && result.isValid();
+            } else if (memberNode instanceof MethodNode methodNode) {
+                var result = methodNode.accept(this);
+                valid = valid && result.isValid();
+            }
+        }
+
+        return new TypeCheckResult(valid, null);
+
     }
-    return new TypeCheckResult(true, null);
-  }
 
-  @Override
+    @Override
-  public TypeCheckResult analyze(AssignmentStatementNode assignmentStatementNode) {
+    public TypeCheckResult analyze(MethodNode methodNode) {
-    if(assignmentStatementNode.expression instanceof LiteralNode literalNode) {
+        var valid = true;
-      TypeCheckResult varResult = assignmentStatementNode.varNode.accept(this);
+
-      TypeCheckResult expressionResult = assignmentStatementNode.expression.accept(this);
+        currentLocalScope.pushScope();
+
+        List<StatementNode> statements = methodNode.statements;
+        for (StatementNode statement : statements) {
+            if (statement instanceof AssignmentStatementNode assignmentStatementNode) {
+                var result = assignmentStatementNode.accept(this);
+                valid = valid && result.isValid();
+            } else if (statement instanceof VariableDeclarationStatementNode variableDeclarationStatementNode) {
+                var result = variableDeclarationStatementNode.accept(this);
+                valid = valid && result.isValid();
+            }
+        }
+        return new TypeCheckResult(valid, null);
     }
-    return new TypeCheckResult(true, null);
-  }
 
-  @Override
+    @Override
-  public TypeCheckResult analyze(VarNode toCheck) {
+    public TypeCheckResult analyze(FieldNode toCheck) {
-    return new TypeCheckResult(true, null);
+        if (currentFields.contains(toCheck.identifier)) {
-  }
+            throw new RuntimeException(toCheck.identifier + " Is Already Declared");
+        } else {
+            currentFields.add(toCheck.identifier);
+        }
+        return new TypeCheckResult(true, null);
+    }
+
+    @Override
+    public TypeCheckResult analyze(AssignmentStatementNode assignmentStatementNode) {
+        if (assignmentStatementNode.expression instanceof LiteralNode literalNode) {
+            TypeCheckResult varResult = assignmentStatementNode.varNode.accept(this);
+            TypeCheckResult expressionResult = assignmentStatementNode.expression.accept(this);
+        }
+        return new TypeCheckResult(true, null);
+    }
+
+    @Override
+    public TypeCheckResult analyze(VarNode toCheck) {
+        return new TypeCheckResult(true, null);
+    }
+
+    @Override
+    public TypeCheckResult analyze(BinaryExpressionNode toCheck) {
+        return null;
+    }
+
+    @Override
+    public TypeCheckResult analyze(IdentifierExpressionNode toCheck) {
+        return null;
+    }
+
+    @Override
+    public TypeCheckResult analyze(UnaryExpressionNode toCheck) {
+        return null;
+    }
+
+    @Override
+    public TypeCheckResult analyze(VariableDeclarationStatementNode toCheck) {
+
+        return new TypeCheckResult(true, null);
+    }
+
+    @Override
+    public TypeCheckResult analyze(IfStatementNode toCheck) {
+        return null;
+    }
+
+    @Override
+    public TypeCheckResult analyze(ReturnStatementNode toCheck) {
+        return null;
+    }
+
+    @Override
+    public TypeCheckResult analyze(WhileStatementNode toCheck) {
+        return null;
+    }
 
 }

src/main/java/semantic/SemanticVisitor.java

@@ -4,9 +4,12 @@ package semantic;
 import ast.ClassNode;
 import ast.ProgramNode;
 import ast.VarNode;
+import ast.expression.BinaryExpressionNode;
+import ast.expression.IdentifierExpressionNode;
+import ast.expression.UnaryExpressionNode;
 import ast.member.FieldNode;
 import ast.member.MethodNode;
-import ast.statement.AssignmentStatementNode;
+import ast.statement.*;
 import typechecker.TypeCheckResult;
 
 public interface SemanticVisitor {
@@ -22,41 +25,18 @@ public interface SemanticVisitor {
     TypeCheckResult analyze(AssignmentStatementNode toCheck);
 
     TypeCheckResult analyze(VarNode toCheck);
-//
-//    TypeCheckResult typeCheck(ForStmt forStmt);
-//
-//    TypeCheckResult typeCheck(WhileStmt whileStmt);
-//
-//    TypeCheckResult typeCheck(ReturnStmt returnStmt);
-//
-//    TypeCheckResult typeCheck(LocalVarDecl localVarDecl);
-//
-//    TypeCheckResult typeCheck(IfStmt ifStmt);
-//
-//    TypeCheckResult typeCheck(Block block);
-//
-//    TypeCheckResult typeCheck(NewDecl newDecl);
-//
-//    TypeCheckResult typeCheck(MethodCall methodCall);
-//
-//    TypeCheckResult typeCheck(Unary unary);
-//
-//    TypeCheckResult typeCheck(This aThis);
-//
-//    TypeCheckResult typeCheck(Null aNull);
-//
-//    TypeCheckResult typeCheck(LocalOrFieldVar localOrFieldVar);
-//
-//    TypeCheckResult typeCheck(IntegerExpr integerExpr);
-//
-//    TypeCheckResult typeCheck(InstVar instVar);
-//
-//    TypeCheckResult typeCheck(CharExpr charExpr);
-//
-//    TypeCheckResult typeCheck(BoolExpr boolExpr);
-//
-//    TypeCheckResult typeCheck(Binary binary);
-//
-//    TypeCheckResult typeCheck(StringExpr instVar);
 
+    TypeCheckResult analyze(BinaryExpressionNode toCheck);
+
+    TypeCheckResult analyze(IdentifierExpressionNode toCheck);
+
+    TypeCheckResult analyze(UnaryExpressionNode toCheck);
+
+    TypeCheckResult analyze(VariableDeclarationStatementNode toCheck);
+
+    TypeCheckResult analyze(IfStatementNode toCheck);
+
+    TypeCheckResult analyze(ReturnStatementNode toCheck);
+
+    TypeCheckResult analyze(WhileStatementNode toCheck);
 }

src/main/java/typechecker/Type.java

@@ -1,5 +0,0 @@
-package typechecker;
-
-public interface Type {
-    boolean equals(Object obj);
-}

src/main/java/typechecker/TypeCheckResult.java

@@ -1,12 +1,14 @@
 package typechecker;
 
 
+import ast.type.TypeNode;
+
 public class TypeCheckResult {
 
   private boolean valid;
-  private Type type;
+  private TypeNode type;
 
-  public TypeCheckResult(boolean valid, Type type) {
+  public TypeCheckResult(boolean valid, TypeNode type) {
     this.valid = valid;
     this.type = type;
   }
@@ -15,7 +17,7 @@ public class TypeCheckResult {
     return valid;
   }
 
-  public Type getType() {
+  public TypeNode getType() {
     return type;
   }
 }

src/main/java/typechecker/Typer.java

@@ -1,9 +0,0 @@
-package typechecker;
-
-public class Typer {
-
-    public static void Typeify(){
-
-    }
-
-}

src/main/java/visitor/Visitable.java

@@ -1,9 +1,10 @@
-package typechecker;
+package visitor;
 
 import bytecode.visitor.ClassVisitor;
 import bytecode.visitor.MethodVisitor;
 import bytecode.visitor.ProgramVisitor;
 import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
 
 public interface Visitable {
     default void accept(ProgramVisitor programVisitor) {