Merge from main

.github/workflows/build.yml

@@ -42,6 +42,10 @@ jobs:
           distribution: 'oracle'
           java-version: '17'
       - uses: ArtiomTr/jest-coverage-report-action@v2
+        if: github.event_name == 'pull_request'
         with:
           test-script: yarn test
           annotations: none
+      - name: Run tests
+        if: github.event_name != 'pull_request'
+        run: yarn test

README.md

@@ -54,6 +54,7 @@ The Java language in Source Academy currently supports a host of available featu
 - Explicit type conversion (type narrowing)
 - Implicit type conversion for system calls (e.g. int input to System.out.println)
 - Single nested class
+- Exceptions
 
 ## Future Features
 

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

@@ -20,6 +20,7 @@ describe("extract ExpressionStatement correctly", () => {
             kind: "NormalClassDeclaration",
             classModifier: [],
             typeIdentifier: "Test",
+            sclass: undefined,
             classBody: [
               {
                 kind: "MethodDeclaration",
@@ -203,8 +204,7 @@ describe("extract ExpressionStatement correctly", () => {
       const ast = parse(programStr);
       expect(ast).toEqual(expectedAst);
     });
-
-    it("extract Assignment Expression simple ExpressionName correctly", () => {
+    it("extract Assignment LeftHandSide qualified ExpressionName correctly", () => {
       const programStr = `
         class Test {
           void test() {
@@ -716,6 +716,7 @@ describe("extract ReturnStatement correctly", () => {
           kind: "NormalClassDeclaration",
           classModifier: [],
           typeIdentifier: "Test",
+          sclass: undefined,
           classBody: [
             {
               kind: "MethodDeclaration",
@@ -804,6 +805,115 @@ describe("extract ReturnStatement correctly", () => {
       location: expect.anything(),
     };
 
+    const ast = parse(programStr);
+    console.log(JSON.stringify(ast, null, 2));
+    expect(ast).toEqual(expectedAst);
+  });
+});
+
+describe("extract TryStatement and ThrowStatement correctly", () => {
+  it("extract ThrowStatement inside catch block correctly", () => {
+    const programStr = `
+      class Test {
+        void test() {
+          try {
+            throw new Exception();
+          } catch (Exception e) {
+            throw new Exception();
+          }
+        }
+      }
+    `;
+
+    const expectedAst: AST = {
+      kind: "CompilationUnit",
+      importDeclarations: [],
+      topLevelClassOrInterfaceDeclarations: [
+        {
+          kind: "NormalClassDeclaration",
+          classModifier: [],
+          typeIdentifier: "Test",
+          classBody: [
+            {
+              kind: "MethodDeclaration",
+              methodModifier: [],
+              methodHeader: {
+                result: "void",
+                identifier: "test",
+                formalParameterList: [],
+              },
+              methodBody: {
+                kind: "Block",
+                blockStatements: [
+                  {
+                    kind: "TryStatement",
+                    block: {
+                      kind: "Block",
+                      blockStatements: [
+                        {
+                          kind: "ThrowStatement",
+                          expression: {
+                            kind: "ClassInstanceCreationExpression",
+                            identifier: "Exception",
+                            argumentList: [],
+                            location: expect.anything(),
+                          },
+                          location: expect.anything(),
+                        },
+                      ],
+                      location: expect.anything(),
+                    },
+                    catches: {
+                      kind: "Catches",
+                      catchClauses: [
+                        {
+                          kind: "CatchClause",
+                          catchFormalParameter: {
+                            kind: "CatchFormalParameter",
+                            catchType: {
+                              kind: "CatchType",
+                              unannClassType: "Exception",
+                              location: expect.anything(),
+                            },
+                            variableDeclaratorId: "e",
+                            location: expect.anything(),
+                          },
+                            block: {
+                              kind: "Block",
+                              blockStatements: [
+                                {
+                                  kind: "ThrowStatement",
+                                  expression: {
+                                    kind: "ClassInstanceCreationExpression",
+                                    identifier: "Exception",
+                                    argumentList: [],
+                                    location: expect.anything(),
+                                  },
+                                  location: expect.anything(),
+                                },
+                              ],
+                            location: expect.anything(),
+                          },
+                          location: expect.anything(),
+                        },
+                      ],
+                      location: expect.anything(),
+                    },
+                    finally: undefined,
+                    location: expect.anything(),
+                  },
+                ],
+                location: expect.anything(),
+              },
+              location: expect.anything(),
+            },
+          ],
+          location: expect.anything(),
+        },
+      ],
+      location: expect.anything(),
+    };
+
     const ast = parse(programStr);
     expect(ast).toEqual(expectedAst);
   });

src/ast/astExtractor/class-extractor.ts

@@ -27,14 +27,17 @@ export class ClassExtractor extends BaseJavaCstVisitorWithDefaults {
 
   extract(cst: ClassDeclarationCstNode): ClassDeclaration {
     this.visit(cst);
-    return {
+    const result: NormalClassDeclaration = {
       kind: "NormalClassDeclaration",
       classModifier: this.modifier,
       typeIdentifier: this.identifier,
       classBody: this.body,
-      sclass: this.sclass,
       location: cst.location,
-    } as NormalClassDeclaration;
+    };
+    if (this.sclass) {
+      result.sclass = this.sclass;
+    }
+    return result;
   }
 
   classModifier(ctx: ClassModifierCtx) {

src/ast/astExtractor/statement-extractor.ts

@@ -25,6 +25,13 @@ import {
   SwitchBlockCtx,
   SwitchLabelCtx,
   SwitchBlockStatementGroupCtx,
+  ThrowStatementCtx,
+  TryStatementCtx,
+  CatchClauseCtx,
+  CatchFormalParameterCtx,
+  CatchTypeCtx,
+  CatchesCtx,
+  FinallyCtx,
   StatementCstNode,
   StatementExpressionCtx,
   StatementWithoutTrailingSubstatementCtx,
@@ -97,6 +104,10 @@ export class StatementExtractor extends BaseJavaCstVisitorWithDefaults {
         exp: returnStatementExp,
         location: ctx.returnStatement[0].location,
       };
+    } else if (ctx.throwStatement) {
+      return this.visit(ctx.throwStatement);
+    } else if (ctx.tryStatement) {
+      return this.visit(ctx.tryStatement);
     }
   }
 
@@ -356,6 +367,69 @@ export class StatementExtractor extends BaseJavaCstVisitorWithDefaults {
     return ctx.expression.map((e) => expressionExtractor.extract(e));
   }
 
+  throwStatement(ctx: ThrowStatementCtx) {
+    const expressionExtractor = new ExpressionExtractor();
+    return {
+      kind: "ThrowStatement",
+      expression: expressionExtractor.extract(ctx.expression[0]),
+      location: ctx.Throw[0],
+    };
+  }
+
+  tryStatement(ctx: TryStatementCtx) {
+    return {
+      kind: "TryStatement",
+      block: ctx.block ? this.visit(ctx.block) : { kind: "Block", blockStatements: [], location: ctx.Try![0] },
+      catches: ctx.catches ? this.visit(ctx.catches) : undefined,
+      finally: ctx.finally ? this.visit(ctx.finally) : undefined,
+      location: ctx.Try![0],
+    };
+  }
+
+  catches(ctx: CatchesCtx) {
+    return {
+      kind: "Catches",
+      catchClauses: ctx.catchClause.map((catchClause) => this.visit(catchClause)),
+      location: ctx.catchClause[0].location,
+    };
+  }
+
+  catchClause(ctx: CatchClauseCtx) {
+    return {
+      kind: "CatchClause",
+      catchFormalParameter: this.visit(ctx.catchFormalParameter),
+      block: this.visit(ctx.block),
+      location: ctx.Catch[0],
+    };
+  }
+
+  catchFormalParameter(ctx: CatchFormalParameterCtx) {
+    return {
+      kind: "CatchFormalParameter",
+      catchType: this.visit(ctx.catchType[0]),
+      variableDeclaratorId:
+        ctx.variableDeclaratorId[0].children.Identifier[0].image,
+      location: ctx.catchType[0].location,
+    };
+  }
+
+  catchType(ctx: CatchTypeCtx) {
+    const result = new TypeExtractor().visit(ctx.unannClassType[0] as any);
+      return {
+        kind: "CatchType",
+        unannClassType: result,
+        location: ctx.unannClassType[0].location,
+      };
+  }
+
+  finally(ctx: FinallyCtx) {
+    return {
+      kind: "Finally",
+      block: this.visit(ctx.block),
+      location: ctx.Finally[0],
+    };
+  }
+
   fqnOrRefType(ctx: FqnOrRefTypeCtx) {
     // Assignment LHS, MethodInvocation identifier
     let { name, location } = this.visit(ctx.fqnOrRefTypePartFirst);
@@ -419,8 +493,15 @@ export class StatementExtractor extends BaseJavaCstVisitorWithDefaults {
   }
 
   block(ctx: BlockCtx): Statement {
-    if (ctx.blockStatements) return this.visit(ctx.blockStatements);
-    return { kind: "EmptyStatement" };
+    const location =
+      (ctx.blockStatements?.[0] as any)?.location ||
+      (ctx.LCurly?.[0] as any)?.location ||
+      (ctx.RCurly?.[0] as any)?.location;
+    if (ctx.blockStatements) {
+      const block = this.visit(ctx.blockStatements) as Statement;
+      return { ...block, location };
+    }
+    return { kind: "EmptyStatement", location };
   }
 
   blockStatements(ctx: BlockStatementsCtx): Statement {

src/ast/types/blocks-and-statements.ts

@@ -101,7 +101,48 @@ export type StatementWithoutTrailingSubstatement =
   | DoStatement
   | ReturnStatement
   | BreakStatement
-  | ContinueStatement;
+  | ContinueStatement
+  | ThrowStatement
+  | TryStatement;
+
+export interface ThrowStatement extends BaseNode {
+  kind: "ThrowStatement";
+  expression: Expression;
+}
+
+export interface CatchClause extends BaseNode {
+  kind: "CatchClause";
+  catchFormalParameter: CatchFormalParameter;
+  block: Block;
+}
+
+export interface Catches extends BaseNode {
+  kind: "Catches";
+  catchClauses: Array<CatchClause>;
+}
+
+export interface CatchFormalParameter extends BaseNode {
+  kind: "CatchFormalParameter";
+  catchType: CatchType;
+  variableDeclaratorId: Identifier;
+}
+
+export interface CatchType extends BaseNode {
+  kind: "CatchType";
+  unannClassType: UnannType;
+}
+
+export interface Finally extends BaseNode {
+  kind: "Finally";
+  block: Block;
+}
+
+export interface TryStatement extends BaseNode {
+  kind: "TryStatement";
+  block: Block;
+  catches?: Catches;
+  finally?: Finally;
+}
 
 export interface ExpressionStatement extends BaseNode {
   kind: "ExpressionStatement";

src/compiler/README.md

@@ -1,7 +1,5 @@
 This is a bookkeeping of the planned scope of the compiler. It will be updated from time to time to reflect the current status of the compiler and to make the scope clearer. For a more formal treatment of what features are being supported, see scope.txt for a BNF-form of the Java sub-language.
 
-Note that the compiler is separate from the Java Playground in the online version of Source Academy, which runs in tandem with the ECE. As such, any program run in the Playground will follow the features implemented in the ECE (e.g. widening type conversions), rather than the features below.
-
 **Features that are already supported**
 
 - Single source file, single public class, with exactly one main method