Fixes and refactor

dibyendumajumdar · dibyendumajumdar · commit 23ab1b10630a · 2025-03-29T11:36:31.000Z
diff --git a/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java b/optvm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java
@@ -175,20 +175,11 @@ private void compileStatement(AST.Stmt statement) {
     }
 
     private void compileAssign(AST.AssignStmt assignStmt) {
-        boolean indexedLhs = false;
-        if (!(assignStmt.lhs instanceof AST.NameExpr))
-            indexedLhs = compileExpr(assignStmt.lhs);
         boolean indexedRhs = compileExpr(assignStmt.rhs);
         if (indexedRhs)
             codeIndexedLoad();
-        if (indexedLhs)
-            codeIndexedStore();
-        else if (assignStmt.lhs instanceof AST.NameExpr symbolExpr) {
-            Symbol.VarSymbol varSymbol = (Symbol.VarSymbol) symbolExpr.symbol;
-            codeMove(pop(), new Operand.LocalRegisterOperand(registerPool.getReg(varSymbol.regNumber), varSymbol));
-        }
-        else
-            throw new CompilerException("Invalid assignment expression: " + assignStmt.lhs);
+        Symbol.VarSymbol varSymbol = (Symbol.VarSymbol) assignStmt.nameExpr.symbol;
+        codeMove(pop(), new Operand.LocalRegisterOperand(registerPool.getReg(varSymbol.regNumber), varSymbol));
     }
 
     private void compileExprStmt(AST.ExprStmt exprStmt) {
diff --git a/parser/src/main/java/com/compilerprogramming/ezlang/parser/AST.java b/parser/src/main/java/com/compilerprogramming/ezlang/parser/AST.java
@@ -731,16 +731,17 @@ public void accept(ASTVisitor visitor) {
         }
     }
 
+    /* name = value */
     public static class AssignStmt extends Stmt {
-        public final Expr lhs;
+        public final NameExpr nameExpr;
         public final Expr rhs;
-        public AssignStmt(Expr lhs, Expr rhs) {
-            this.lhs = lhs;
+        public AssignStmt(NameExpr nameExpr, Expr rhs) {
+            this.nameExpr = nameExpr;
             this.rhs = rhs;
         }
         @Override
         public StringBuilder toStr(StringBuilder sb) {
-            lhs.toStr(sb);
+            nameExpr.toStr(sb);
             sb.append(" = ");
             rhs.toStr(sb);
             return sb;
@@ -751,7 +752,7 @@ public void accept(ASTVisitor visitor) {
             visitor = visitor.visit(this, true);
             if (visitor == null)
                 return;
-            lhs.accept(visitor);
+            nameExpr.accept(visitor);
             rhs.accept(visitor);
             visitor.visit(this, false);
         }
diff --git a/parser/src/main/java/com/compilerprogramming/ezlang/parser/Parser.java b/parser/src/main/java/com/compilerprogramming/ezlang/parser/Parser.java
@@ -253,8 +253,11 @@ private AST.Stmt parseAssign(Lexer lexer) {
             else if (lhs instanceof AST.GetFieldExpr getFieldExpr) {
                 return new AST.ExprStmt(new AST.SetFieldExpr(getFieldExpr.object, getFieldExpr.fieldName, rhs));
             }
+            else if (lhs instanceof AST.NameExpr nameExpr) {
+                return new AST.AssignStmt(nameExpr, rhs);
+            }
+            else throw new CompilerException("Expected a name, expr[] or expr.field");
         }
-        return new AST.AssignStmt(lhs, rhs);
     }
 
     private AST.Expr parseBool(Lexer lexer) {
diff --git a/registervm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java b/registervm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java
@@ -139,20 +139,11 @@ private void compileStatement(AST.Stmt statement) {
     }
 
     private void compileAssign(AST.AssignStmt assignStmt) {
-        boolean indexedLhs = false;
-        if (!(assignStmt.lhs instanceof AST.NameExpr))
-            indexedLhs = compileExpr(assignStmt.lhs);
         boolean indexedRhs = compileExpr(assignStmt.rhs);
         if (indexedRhs)
             codeIndexedLoad();
-        if (indexedLhs)
-            codeIndexedStore();
-        else if (assignStmt.lhs instanceof AST.NameExpr symbolExpr) {
-            Symbol.VarSymbol varSymbol = (Symbol.VarSymbol) symbolExpr.symbol;
-            code(new Instruction.Move(pop(), new Operand.LocalRegisterOperand(varSymbol.regNumber, varSymbol.name)));
-        }
-        else
-            throw new CompilerException("Invalid assignment expression: " + assignStmt.lhs);
+        Symbol.VarSymbol varSymbol = (Symbol.VarSymbol) assignStmt.nameExpr.symbol;
+        code(new Instruction.Move(pop(), new Operand.LocalRegisterOperand(varSymbol.regNumber, varSymbol.name)));
     }
 
     private void compileExprStmt(AST.ExprStmt exprStmt) {
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java
@@ -712,7 +712,9 @@ private Node compileStatement(AST.Stmt statement) {
             case AST.VarStmt letStmt -> {
                 return compileLet(letStmt);
             }
-            case AST.VarDeclStmt varDeclStmt -> {}
+            case AST.VarDeclStmt varDeclStmt -> {
+                return ZERO;
+            }
             case AST.IfElseStmt ifElseStmt -> {
                 return compileIf(ifElseStmt);
             }
@@ -736,7 +738,6 @@ private Node compileStatement(AST.Stmt statement) {
             }
             default -> throw new IllegalStateException("Unexpected value: " + statement);
         }
-        throw new CompilerException("Not yet implemented");
     }
 
     private ScopeNode jumpTo(ScopeNode toScope) {
@@ -847,16 +848,13 @@ private Node compileWhile(AST.WhileStmt whileStmt) {
 
         // At exit the false control is the current control, and
         // the scope is the exit scope after the exit test.
-        _xScopes.pop();
         _xScopes.push(exit);
         _scope = exit;
         return ZERO;
     }
 
     private Node compileIf(AST.IfElseStmt ifElseStmt) {
         var pred = compileExpr(ifElseStmt.condition).keep();
-        pred.keep();
-
         // IfNode takes current control and predicate
         Node ifNode = new IfNode(ctrl(), pred).peephole();
         // Setup projection nodes
@@ -914,8 +912,7 @@ private Node compileExprStmt(AST.ExprStmt exprStmt) {
     }
 
     private Node compileAssign(AST.AssignStmt assignStmt) {
-        if (!(assignStmt.lhs instanceof AST.NameExpr nameExpr))
-            throw new CompilerException("Assignment requires a nameExpr");
+        var nameExpr = assignStmt.nameExpr;
         String name = nameExpr.name;
         if (!(nameExpr.symbol instanceof Symbol.VarSymbol varSymbol))
             throw new CompilerException("Assignment requires a variable name");
diff --git a/seaofnodes/src/test/java/com/compilerprogramming/ezlang/compiler/Simple.java b/seaofnodes/src/test/java/com/compilerprogramming/ezlang/compiler/Simple.java
@@ -11,7 +11,7 @@
 import java.util.stream.Collectors;
 
 public class Simple {
-    public static final String PORTS = "com.seaofnodes.simple.node.cpus";
+    public static final String PORTS = "com.compilerprogramming.ezlang.compiler.nodes.cpus";
 
     static final int DUMP_AFTER_PARSE        = 1<<0;
     static final int DUMP_AFTER_OPTO         = 1<<1;
diff --git a/semantic/src/main/java/com/compilerprogramming/ezlang/semantic/SemaAssignTypes.java b/semantic/src/main/java/com/compilerprogramming/ezlang/semantic/SemaAssignTypes.java
@@ -385,9 +385,9 @@ public ASTVisitor visit(AST.ExprStmt exprStmt, boolean enter) {
     @Override
     public ASTVisitor visit(AST.AssignStmt assignStmt, boolean enter) {
         if (!enter) {
-            validType(assignStmt.lhs.type, false);
+            validType(assignStmt.nameExpr.type, false);
             validType(assignStmt.rhs.type, true);
-            checkAssignmentCompatible(assignStmt.lhs.type, assignStmt.rhs.type);
+            checkAssignmentCompatible(assignStmt.nameExpr.type, assignStmt.rhs.type);
         }
         return this;
     }
diff --git a/stackvm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java b/stackvm/src/main/java/com/compilerprogramming/ezlang/compiler/CompiledFunction.java
@@ -111,20 +111,11 @@ private void compileStatement(AST.Stmt statement) {
     }
 
     private void compileAssign(AST.AssignStmt assignStmt) {
-        boolean indexedLhs = false;
-        if (!(assignStmt.lhs instanceof AST.NameExpr))
-            indexedLhs = compileExpr(assignStmt.lhs);
         boolean indexedRhs = compileExpr(assignStmt.rhs);
         if (indexedRhs)
             codeIndexedLoad();
-        if (indexedLhs)
-            codeIndexedStore();
-        else if (assignStmt.lhs instanceof AST.NameExpr symbolExpr) {
-            Symbol.VarSymbol varSymbol = (Symbol.VarSymbol) symbolExpr.symbol;
-            code(new Instruction.Store(varSymbol.regNumber));
-        }
-        else
-            throw new CompilerException("Invalid assignment expression: " + assignStmt.lhs);
+        Symbol.VarSymbol varSymbol = (Symbol.VarSymbol) assignStmt.nameExpr.symbol;
+        code(new Instruction.Store(varSymbol.regNumber));
     }
 
     private void compileExprStmt(AST.ExprStmt exprStmt) {

Original file line number	Diff line number	Diff line change
`@@ -253,8 +253,11 @@ private AST.Stmt parseAssign(Lexer lexer) {`
`253`	`253`	`else if (lhs instanceof AST.GetFieldExpr getFieldExpr) {`
`254`	`254`	`return new AST.ExprStmt(new AST.SetFieldExpr(getFieldExpr.object, getFieldExpr.fieldName, rhs));`
`255`	`255`	`}`
	`256`	`+ else if (lhs instanceof AST.NameExpr nameExpr) {`
	`257`	`+ return new AST.AssignStmt(nameExpr, rhs);`
	`258`	`+ }`
	`259`	`+ else throw new CompilerException("Expected a name, expr[] or expr.field");`
`256`	`260`	`}`
`257`		`- return new AST.AssignStmt(lhs, rhs);`
`258`	`261`	`}`
`259`	`262`
`260`	`263`	`private AST.Expr parseBool(Lexer lexer) {`
Original file line number	Diff line number	Diff line change
`@@ -712,7 +712,9 @@ private Node compileStatement(AST.Stmt statement) {`
`712`	`712`	`case AST.VarStmt letStmt -> {`
`713`	`713`	`return compileLet(letStmt);`
`714`	`714`	`}`
`715`		`- case AST.VarDeclStmt varDeclStmt -> {}`
	`715`	`+ case AST.VarDeclStmt varDeclStmt -> {`
	`716`	`+ return ZERO;`
	`717`	`+ }`
`716`	`718`	`case AST.IfElseStmt ifElseStmt -> {`
`717`	`719`	`return compileIf(ifElseStmt);`
`718`	`720`	`}`
`@@ -736,7 +738,6 @@ private Node compileStatement(AST.Stmt statement) {`
`736`	`738`	`}`
`737`	`739`	`default -> throw new IllegalStateException("Unexpected value: " + statement);`
`738`	`740`	`}`
`739`		`- throw new CompilerException("Not yet implemented");`
`740`	`741`	`}`
`741`	`742`
`742`	`743`	`private ScopeNode jumpTo(ScopeNode toScope) {`
`@@ -847,16 +848,13 @@ private Node compileWhile(AST.WhileStmt whileStmt) {`
`847`	`848`
`848`	`849`	`// At exit the false control is the current control, and`
`849`	`850`	`// the scope is the exit scope after the exit test.`
`850`		`- _xScopes.pop();`
`851`	`851`	`_xScopes.push(exit);`
`852`	`852`	`_scope = exit;`
`853`	`853`	`return ZERO;`
`854`	`854`	`}`
`855`	`855`
`856`	`856`	`private Node compileIf(AST.IfElseStmt ifElseStmt) {`
`857`	`857`	`var pred = compileExpr(ifElseStmt.condition).keep();`
`858`		`- pred.keep();`
`859`		`-`
`860`	`858`	`// IfNode takes current control and predicate`
`861`	`859`	`Node ifNode = new IfNode(ctrl(), pred).peephole();`
`862`	`860`	`// Setup projection nodes`
`@@ -914,8 +912,7 @@ private Node compileExprStmt(AST.ExprStmt exprStmt) {`
`914`	`912`	`}`
`915`	`913`
`916`	`914`	`private Node compileAssign(AST.AssignStmt assignStmt) {`
`917`		`- if (!(assignStmt.lhs instanceof AST.NameExpr nameExpr))`
`918`		`- throw new CompilerException("Assignment requires a nameExpr");`
	`915`	`+ var nameExpr = assignStmt.nameExpr;`
`919`	`916`	`String name = nameExpr.name;`
`920`	`917`	`if (!(nameExpr.symbol instanceof Symbol.VarSymbol varSymbol))`
`921`	`918`	`throw new CompilerException("Assignment requires a variable name");`
Original file line number	Diff line number	Diff line change
`@@ -385,9 +385,9 @@ public ASTVisitor visit(AST.ExprStmt exprStmt, boolean enter) {`
`385`	`385`	`@Override`
`386`	`386`	`public ASTVisitor visit(AST.AssignStmt assignStmt, boolean enter) {`
`387`	`387`	`if (!enter) {`
`388`		`- validType(assignStmt.lhs.type, false);`
	`388`	`+ validType(assignStmt.nameExpr.type, false);`
`389`	`389`	`validType(assignStmt.rhs.type, true);`
`390`		`- checkAssignmentCompatible(assignStmt.lhs.type, assignStmt.rhs.type);`
	`390`	`+ checkAssignmentCompatible(assignStmt.nameExpr.type, assignStmt.rhs.type);`
`391`	`391`	`}`
`392`	`392`	`return this;`
`393`	`393`	`}`