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,265 @@
+import {
+  runTest,
+  testCase,
+} from "../__utils__/test-utils";
+import { compileFromSource } from "../../index";
+
+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: "nested class forward-references a sibling class declared after it",
+    program: `
+      public class Main {
+        static class A {
+          int get() { return B.code; }
+        }
+        static class B {
+          static int code = 9;
+        }
+        public static void main(String[] args) {
+          A a = new A();
+          System.out.println(a.get());
+        }
+      }
+    `,
+    expectedLines: ["9"],
+  },
+  {
+    comment: "nested class forward-references a sibling enum declared after it",
+    program: `
+      public class Main {
+        static class Box {
+          Color get() { return Color.RED; }
+        }
+        enum Color { RED, BLUE }
+        public static void main(String[] args) {
+          Box box = new Box();
+          Color c = box.get();
+          System.out.println(c.name());
+        }
+      }
+    `,
+    expectedLines: ["RED"],
+  },
+  {
+    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"],
+  },
+  {
+    comment: "two unrelated top-level classes each have a nested class with the same simple name",
+    program: `
+      class A {
+        static class Item {}
+      }
+      class B {
+        static class Item {}
+      }
+      public class Main {
+        public static void main(String[] args) {
+          System.out.println(0);
+        }
+      }
+    `,
+    expectedLines: ["0"],
+  },
+  {
+    comment: "nested class extends a sibling nested class",
+    program: `
+      public class Main {
+        static class Base {}
+        static class Child extends Base {
+          public int get() { return 1; }
+        }
+
+        public static void main(String[] args) {
+          Child child = new Child();
+          System.out.println(child.get());
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
+  {
+    comment: "two levels deep: nested class extends a sibling nested class",
+    program: `
+      public class Main {
+        static class Middle {
+          static class Base {}
+          static class Child extends Base {
+            public int get() { return 1; }
+          }
+        }
+
+        public static void main(String[] args) {
+          Child child = new Child();
+          System.out.println(child.get());
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
+  {
+    comment: "nested class extends its own (nested) enclosing class",
+    program: `
+      public class Main {
+        static class Middle {
+          static class Child extends Middle {
+            public int get() { return 1; }
+          }
+        }
+
+        public static void main(String[] args) {
+          Child child = new Child();
+          System.out.println(child.get());
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
+  {
+    comment: "unqualified declaration, qualified instantiation (new Outer.Inner())",
+    program: `
+      public class Main {
+        static class Inner {
+          public int get() { return 1; }
+        }
+        public static void main(String[] args) {
+          Inner inner = new Main.Inner();
+          System.out.println(inner.get());
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
+  {
+    comment: "qualified declaration and instantiation (Outer.Inner on both sides)",
+    program: `
+      public class Main {
+        static class Inner {
+          public int get() { return 1; }
+        }
+        public static void main(String[] args) {
+          Main.Inner inner = new Main.Inner();
+          System.out.println(inner.get());
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
+  {
+    comment: "two levels deep, fully qualified (Outer.Middle.Inner)",
+    program: `
+      public class Main {
+        static class Middle {
+          static class Inner {
+            public int get() { return 1; }
+          }
+        }
+        public static void main(String[] args) {
+          Main.Middle.Inner inner = new Main.Middle.Inner();
+          System.out.println(inner.get());
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  },
+];
+
+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));
+  }
+
+  it("still rejects two top-level classes sharing the same name", () => {
+    expect(() =>
+      compileFromSource(`
+        class Item {}
+        class Item {}
+        public class Main {
+          public static void main(String[] args) {}
+        }
+      `)
+    ).toThrow('"Item" has already been declared')
+  })
+});