Add support for static inner classes

src/ast/__tests__/class-extractor.test.ts

@@ -124,3 +124,39 @@ describe("extract multiple NormalClassDeclaration correctly", () => {
     expect(ast).toEqual(expectedAst);
   });
 });
+
+describe("extract nested NormalClassDeclaration correctly", () => {
+  it("extract a static nested class inside a class body correctly", () => {
+    const programStr = `
+      class Outer {
+        static class Inner {}
+      }
+    `;
+
+    const expectedAst: AST = {
+      kind: "CompilationUnit",
+      importDeclarations: [],
+      topLevelClassOrInterfaceDeclarations: [
+        {
+          kind: "NormalClassDeclaration",
+          classModifier: [],
+          typeIdentifier: "Outer",
+          classBody: [
+            {
+              kind: "NormalClassDeclaration",
+              classModifier: ["static"],
+              typeIdentifier: "Inner",
+              classBody: [],
+              location: expect.anything(),
+            },
+          ],
+          location: expect.anything(),
+        },
+      ],
+      location: expect.anything(),
+    };
+
+    const ast = parse(programStr);
+    expect(ast).toEqual(expectedAst);
+  });
+});

src/ast/astExtractor/class-extractor.ts

@@ -91,5 +91,12 @@ export class ClassExtractor extends BaseJavaCstVisitorWithDefaults {
         this.body.push(methodNode);
       })
     }
+    if (ctx.classDeclaration) {
+      ctx.classDeclaration.forEach(x => {
+        const classExtractor = new ClassExtractor();
+        const classNode = classExtractor.extract(x);
+        this.body.push(classNode);
+      })
+    }
   }
 }

src/ast/types/classes.ts

@@ -43,7 +43,7 @@ export type ClassModifier =
   | "strictfp"
   | "enum";
 
-export type ClassBodyDeclaration = ClassMemberDeclaration | ConstructorDeclaration | EnumDeclaration;
+export type ClassBodyDeclaration = ClassMemberDeclaration | ConstructorDeclaration | EnumDeclaration | NormalClassDeclaration;
 export type ClassMemberDeclaration = MethodDeclaration | FieldDeclaration;
 
 export interface ConstructorDeclaration extends BaseNode {

src/compiler/__tests__/classOrdering.test.ts

@@ -11,7 +11,7 @@ describe('compiled class ordering', () => {
       }
     `
     const classes = compileFromSource(program)
-    expect(classes.map(c => c.className)).toEqual(['Main', 'Day'])
+    expect(classes.map(c => c.className)).toEqual(['Main', 'Main$Day'])
   })
 
   it('keeps top-level declaration order, with member enums appended', () => {
@@ -24,7 +24,9 @@ describe('compiled class ordering', () => {
     `
     const classes = compileFromSource(program)
     expect(classes[0].className).toBe('Main')
-    expect(new Set(classes.map(c => c.className))).toEqual(new Set(['Main', 'A', 'B']))
+    expect(new Set(classes.map(c => c.className))).toEqual(
+      new Set(['Main', 'Main$A', 'Main$B'])
+    )
   })
 
   it('is unchanged when there is no enum', () => {

src/compiler/__tests__/index.ts

@@ -10,6 +10,7 @@ import { importTest } from "./tests/import.test";
 import { arrayTest } from "./tests/array.test";
 import { classTest } from "./tests/class.test";
 import { enumTest } from "./tests/enum.test";
+import { nestedClassesTest } from "./tests/nestedClasses.test";
 import { typeConversionTest } from "./tests/typeConversion.test";
 
 describe("compiler tests", () => {
@@ -25,5 +26,6 @@ describe("compiler tests", () => {
   arrayTest();
   classTest();
   enumTest();
+  nestedClassesTest();
   typeConversionTest();
 })

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

@@ -103,6 +103,19 @@ const testCases: testCase[] = [
     `,
     expectedLines: ["in f"],
   },
+  {
+    comment: "instance field with an inline initializer",
+    program: `
+      public class Main {
+        public int one = 1;
+        public static void main(String[] args) {
+          Main m = new Main();
+          System.out.println(m.one);
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
   {
     comment: "instance field",
     program: `

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

@@ -0,0 +1,99 @@
+import {
+  runTest,
+  testCase,
+} from "../__utils__/test-utils";
+
+const testCases: testCase[] = [
+  {
+    comment: "basic static nested class instantiation and usage",
+    program: `
+      public class Main {
+        public static class Inner {
+          public int value;
+          public Inner(int v) {
+            this.value = v;
+          }
+          public int getValue() {
+            return this.value;
+          }
+        }
+
+        public static void main(String[] args) {
+          Inner inner = new Inner(42);
+          System.out.println(inner.getValue());
+        }
+      }
+    `,
+    expectedLines: ["42"],
+  },
+  {
+    comment: "one nested class field typed as a sibling nested class",
+    program: `
+      public class Main {
+        public static class Box {
+          public int value;
+          public Box(int v) {
+            this.value = v;
+          }
+        }
+
+        public static class Holder {
+          public Box box;
+          public Holder(Box b) {
+            this.box = b;
+          }
+        }
+
+        public static void main(String[] args) {
+          Box box = new Box(9);
+          Holder holder = new Holder(box);
+          System.out.println(holder.box.value);
+        }
+      }
+    `,
+    expectedLines: ["9"],
+  },
+  {
+    comment: "nested class instance field with an inline initializer",
+    program: `
+      public class Main {
+        static class Inner1 {
+          public int one = 1;
+        }
+        public static void main(String[] args) {
+          Inner1 inner1 = new Inner1();
+          int n = inner1.one;
+          System.out.println(n);
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
+  {
+    comment: "two levels of static nested class",
+    program: `
+      public class Main {
+        public static class Middle {
+          public static class Inner {
+            public String greet() {
+              return "hello";
+            }
+          }
+        }
+
+        public static void main(String[] args) {
+          Inner inner = new Inner();
+          System.out.println(inner.greet());
+        }
+      }
+    `,
+    expectedLines: ["hello"],
+  },
+];
+
+export const nestedClassesTest = () => describe("static nested classes", () => {
+  for (let testCase of testCases) {
+    const { comment: comment, program: program, expectedLines: expectedLines } = testCase;
+    it(comment, () => runTest(program, expectedLines));
+  }
+});

src/compiler/code-generator.ts

@@ -1098,7 +1098,13 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
       }
     }
     const res = compile(expr, cg)
-    const classInfoIndex = cg.constantPoolManager.indexClassInfo(ct)
+    let castClassName = ct
+    try {
+      castClassName = cg.symbolTable.queryClass(ct).name
+    } catch (e) {
+      castClassName = ct.includes('/') ? ct : ct.replace(/\./g, '/')
+    }
+    const classInfoIndex = cg.constantPoolManager.indexClassInfo(castClassName)
     cg.code.push(OPCODE.CHECKCAST, 0, classInfoIndex)
     return res
   },
@@ -1107,7 +1113,18 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
     const { identifier: id, argumentList: argLst } = node as ClassInstanceCreationExpression
     let maxStack = 2
 
-    cg.code.push(OPCODE.NEW, 0, cg.constantPoolManager.indexClassInfo(id), OPCODE.DUP)
+    let instantiatedClassName = id
+    try {
+      instantiatedClassName = cg.symbolTable.queryClass(id).name
+    } catch (e) {
+      instantiatedClassName = id.includes('/') ? id : id.replace(/\./g, '/')
+    }
+    cg.code.push(
+      OPCODE.NEW,
+      0,
+      cg.constantPoolManager.indexClassInfo(instantiatedClassName),
+      OPCODE.DUP
+    )
 
     const argTypes: Array<UnannType> = []
     argLst.forEach((x, i) => {
@@ -1120,7 +1137,10 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
     const methodInfos = cg.symbolTable.queryMethod('<init>') as MethodInfos
     for (let i = 0; i < methodInfos.length; i++) {
       const methodInfo = methodInfos[i]
-      if (methodInfo.typeDescriptor.includes(argDescriptor) && methodInfo.className == id) {
+      if (
+        methodInfo.typeDescriptor.includes(argDescriptor) &&
+        methodInfo.className == instantiatedClassName
+      ) {
         const method = cg.constantPoolManager.indexMethodrefInfo(
           methodInfo.className,
           methodInfo.name,
@@ -1131,7 +1151,7 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
       }
     }
 
-    return { stackSize: maxStack, resultType: id }
+    return { stackSize: maxStack, resultType: instantiatedClassName }
   },
 
   ArrayAccess: (node: Node, cg: CodeGenerator) => {
@@ -1768,7 +1788,11 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
                     return field.ordinal
                   })()
                 : label.expression.kind === 'ExpressionName'
-                  ? (() => { throw new Error(`Identifier case labels are only supported for enum switch selectors: ${label.expression.name}`) })()
+                  ? (() => {
+                      throw new Error(
+                        `Identifier case labels are only supported for enum switch selectors: ${label.expression.name}`
+                      )
+                    })()
                   : parseInt((label.expression as Literal).literalType.value)
             caseValues.push(value)
             caseLabelMap.set(value, caseLabels[index])