Fix conditional expression bug

Author: 1001mei

src/compiler/__tests__/__utils__/test-utils.ts

@@ -1,5 +1,6 @@
 import { inspect } from "util";
-import { Compiler } from "../../compiler";
+//import { Compiler } from "../../compiler";
+import { compile } from "../../index";
 import { BinaryWriter } from "../../binary-writer";
 import { AST } from "../../../ast/types/packages-and-modules";
 import { javaPegGrammar } from "../../grammar"
@@ -19,7 +20,7 @@ const pathToTestDir = "./src/compiler/__tests__/";
 const parser = peggy.generate(javaPegGrammar, {
   allowedStartRules: ["CompilationUnit"],
 });
-const compiler = new Compiler();
+//const compiler = new Compiler();
 const binaryWriter = new BinaryWriter();
 
 export function runTest(program: string, expectedLines: string[]) {
@@ -30,7 +31,7 @@ export function runTest(program: string, expectedLines: string[]) {
     console.log(inspect(ast, false, null, true));
   }
 
-  const classFile = compiler.compile(ast as AST);
+  const classFile = compile(ast as AST);
   binaryWriter.writeBinary(classFile, pathToTestDir);
 
   const prevDir = process.cwd();

src/compiler/__tests__/tests/ifElse.test.ts

@@ -42,6 +42,43 @@ const testCases: testCase[] = [
     `,
     expectedLines: ["ok", "done"],
   },
+  {
+    comment: "if and else, single variable conditional expression",
+    program: `
+      public class Main {
+        public static void main(String[] args) {
+          boolean b = true;
+          if (b) {
+            System.out.println("This is expected");
+          } else {
+            System.out.println("This is incorrect");
+          }
+
+          boolean c = false;
+          if (c) {
+            System.out.println("Incorrect");
+          } else {
+            System.out.println("Correct");
+          }
+
+          boolean g = false;
+          if (!g) {
+            System.out.println("This is expected");
+          } else {
+            System.out.println("This is incorrect");
+          }
+
+          boolean h = true;
+          if (!h) {
+            System.out.println("Incorrect");
+          } else {
+            System.out.println("Correct");
+          }
+        }
+      }
+    `,
+    expectedLines: ["This is expected", "Correct", "This is expected", "Correct"],
+  },
   {
     comment: "if and else",
     program: `
@@ -200,10 +237,22 @@ const testCases: testCase[] = [
           } else {
             System.out.println("Yes2");
           }
+
+          boolean b = true;
+          boolean c = !b;
+
+          if (!(!(!(!c)))) {
+            System.out.println("Hmm");
+          } else {
+            System.out.println("Yes3");
+          }
+
+          boolean d = !(!(!(b == c)));
+          System.out.println(d);
         }
       }
     `,
-    expectedLines: ["Yes1", "Yes2"],
+    expectedLines: ["Yes1", "Yes2", "Yes3", "true"],
   },
   {
     comment: "complex conditional expression",

src/compiler/binary-writer.ts

@@ -44,11 +44,17 @@ export class BinaryWriter {
   }
 
   writeBinary(classFile: ClassFile, filepath: string) {
-    const filename = filepath + 'Main.class'
+    const filename = filepath + this.getClassName(classFile) + '.class'
     const binary = this.toBinary(classFile)
     fs.writeFileSync(filename, binary)
   }
 
+  private getClassName(classFile: ClassFile) {
+    const classInfo = classFile.constantPool[classFile.thisClass - 1] as ConstantClassInfo;
+    const classNameInfo = classFile.constantPool[classInfo.nameIndex - 1] as ConstantUtf8Info;
+    return classNameInfo.value;
+  }
+
   private toBinary(classFile: ClassFile) {
     this.byteArray = []
     this.constantPool = classFile.constantPool

src/compiler/code-generator.ts

@@ -181,11 +181,11 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
     cg.symbolTable.extend()
     let maxStack = 0
     let resultType = ''
-    ;(node as Block).blockStatements.forEach(x => {
-      const { stackSize: stackSize, resultType: type } = compile(x, cg)
-      maxStack = Math.max(maxStack, stackSize)
-      resultType = type
-    })
+      ; (node as Block).blockStatements.forEach(x => {
+        const { stackSize: stackSize, resultType: type } = compile(x, cg)
+        maxStack = Math.max(maxStack, stackSize)
+        resultType = type
+      })
     cg.symbolTable.teardown()
 
     return { stackSize: maxStack, resultType }
@@ -418,8 +418,10 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
           literalType: { kind: kind, value: value }
         } = node
         const boolValue = value === 'true'
-        if (kind === 'BooleanLiteral' && onTrue === boolValue) {
-          cg.addBranchInstr(OPCODE.GOTO, targetLabel)
+        if (kind === 'BooleanLiteral') {
+          if (onTrue === boolValue) {
+            cg.addBranchInstr(OPCODE.GOTO, targetLabel)
+          }
           return { stackSize: 0, resultType: cg.symbolTable.generateFieldDescriptor('boolean') }
         }
       }
@@ -470,20 +472,20 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
         } else if (op in reverseLogicalOp) {
           if (isNullLiteral(left)) {
             // still use l to represent the first argument pushed onto stack
-            l = f(right, targetLabel, onTrue)
+            l = compile(right, cg)
             cg.addBranchInstr(
               onTrue !== (op === '!=') ? OPCODE.IFNULL : OPCODE.IFNONNULL,
               targetLabel
             )
           } else if (isNullLiteral(right)) {
-            l = f(left, targetLabel, onTrue)
+            l = compile(left, cg)
             cg.addBranchInstr(
               onTrue !== (op === '!=') ? OPCODE.IFNULL : OPCODE.IFNONNULL,
               targetLabel
             )
           } else {
-            l = f(left, targetLabel, onTrue)
-            r = f(right, targetLabel, onTrue)
+            l = compile(left, cg)
+            r = compile(right, cg)
             cg.addBranchInstr(onTrue ? logicalOp[op] : reverseLogicalOp[op], targetLabel)
           }
           return {
@@ -496,7 +498,9 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
         }
       }
 
-      return compile(node, cg)
+      const res = compile(node, cg)
+      cg.addBranchInstr(onTrue ? OPCODE.IFNE : OPCODE.IFEQ, cg.labels[cg.labels.length - 1])
+      return res
     }
     return f(node, cg.labels[cg.labels.length - 1], false)
   },
@@ -799,9 +803,10 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
           field
         )
       }
+      const fetchedFieldTypeDescriptor = (fieldInfos[fieldInfos.length - 1] as FieldInfo).typeDescriptor
       return {
-        stackSize: 1,
-        resultType: (fieldInfos[fieldInfos.length - 1] as FieldInfo).typeDescriptor
+        stackSize: 1 + (['D', 'J'].includes(fetchedFieldTypeDescriptor) ? 1 : 0),
+        resultType: fetchedFieldTypeDescriptor
       }
     } else {
       cg.code.push(
@@ -917,14 +922,19 @@ class CodeGenerator {
     }
 
     methodNode.methodHeader.formalParameterList.forEach(p => {
-      this.symbolTable.insertVariableInfo({
+      const paramInfo = {
         name: p.identifier,
         accessFlags: 0,
         index: this.maxLocals,
         typeName: p.unannType,
         typeDescriptor: this.symbolTable.generateFieldDescriptor(p.unannType)
-      })
-      this.maxLocals++
+      }
+      this.symbolTable.insertVariableInfo(paramInfo)
+      if (['D', 'J'].includes(paramInfo.typeDescriptor)) {
+        this.maxLocals += 2
+      } else {
+        this.maxLocals++
+      }
     })
 
     if (methodNode.methodHeader.identifier === '<init>') {