Merge pull request #14 from x0k/java

Java

.gitattributes

@@ -3,3 +3,4 @@
 *.so filter=lfs diff=lfs merge=lfs -text
 *.dat filter=lfs diff=lfs merge=lfs -text
 *.dll filter=lfs diff=lfs merge=lfs -text
+*.jar filter=lfs diff=lfs merge=lfs -text

.gitmodules

@@ -5,3 +5,6 @@
 [submodule "packages/gleam-runtime/gleam"]
 	path = packages/gleam-runtime/gleam
 	url = https://github.com/gleam-lang/gleam.git
+[submodule "packages/java-runtime/doppio"]
+	path = packages/java-runtime/doppio
+	url = https://github.com/plasma-umass/doppio.git

apps/ppp/package.json

@@ -34,7 +34,8 @@
     "php-runtime": "workspace:*",
     "python-runtime": "workspace:*",
     "rust-runtime": "workspace:*",
-    "typescript-runtime": "workspace:*"
+    "typescript-runtime": "workspace:*",
+    "java-runtime": "workspace:*"
   },
   "devDependencies": {
     "@iconify-json/lucide": "^1.1.202",

apps/ppp/src/adapters/monaco.ts

@@ -20,6 +20,7 @@ export const MONACO_LANGUAGE_ID: Record<Language, string> = {
   [Language.Rust]: "rust",
   [Language.Gleam]: Language.Gleam,
   [Language.CSharp]: "csharp",
+  [Language.Java]: "java",
 };
 
 const LANGUAGE_ID_SCOPE_NAME = {

apps/ppp/src/adapters/runtime/descriptions.ts

@@ -10,6 +10,7 @@ import GoDescription from "./go/description.svelte";
 import RustDescription from "./rust/description.svelte";
 import GleamDescription from "./gleam/description.svelte";
 import DotnetDescription from "./dotnet/description.svelte";
+import JavaDescription from "./java/description.svelte";
 
 export const DESCRIPTIONS: Record<Language, Component> = {
   [Language.JavaScript]: JsDescription,
@@ -20,4 +21,5 @@ export const DESCRIPTIONS: Record<Language, Component> = {
   [Language.Rust]: RustDescription,
   [Language.Gleam]: GleamDescription,
   [Language.CSharp]: DotnetDescription,
+  [Language.Java]: JavaDescription,
 };

apps/ppp/src/adapters/runtime/java/description.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+  import { version } from "java-runtime/version";
+</script>
+
+<p>
+  {version}
+</p>
+
+<p>
+  Your code is compiled by <code>Javac</code> and executed in
+  <a target="_blank" class="link" href="https://github.com/plasma-umass/doppio/"
+    >DoppioJVM</a
+  > in a web worker environment.
+</p>
+
+<p>
+  Public class <code>Test</code> is reserved.
+</p>

apps/ppp/src/adapters/runtime/java/test-compiler-factory.ts

@@ -0,0 +1,83 @@
+import type { Context } from "libs/context";
+import type { Writer } from "libs/io";
+import type { TestCompiler } from "testing";
+
+import {
+  JavaCompiler,
+  JavaTestProgram,
+  initFs,
+  makeJVMFactory,
+} from "java-runtime";
+
+// @ts-expect-error vite url import
+import libZipUrl from "java-runtime/doppio.zip";
+
+export interface Options<I, O> {
+  className?: string;
+  classDefinitions: string;
+  mainMethodBody: string;
+  nativesFactory: (
+    input: I,
+    saveOutput: (output: O) => void
+  ) => Record<string, Function>;
+}
+
+export class JavaTestCompilerFactory {
+  constructor(private readonly writer: Writer) {}
+  async create<I, O>(
+    ctx: Context,
+    {
+      className = "Test",
+      classDefinitions,
+      mainMethodBody,
+      nativesFactory,
+    }: Options<I, O>
+  ): Promise<TestCompiler<I, O>> {
+    const jvmFactory = makeJVMFactory(this.writer);
+    const libZipData = await fetch(libZipUrl, {
+      signal: ctx.signal,
+      cache: "force-cache",
+    }).then((response) => response.arrayBuffer());
+    const fs = await initFs(libZipData);
+    const compiler = new JavaCompiler(
+      jvmFactory,
+      `/home/${className}.java`,
+      fs
+    );
+    class TestProgram extends JavaTestProgram<I, O> {
+      private output?: O;
+      private saveOutput(output: O) {
+        this.output = output;
+      }
+      protected override getNatives(input: I): Record<string, Function> {
+        return nativesFactory(input, this.saveOutput.bind(this));
+      }
+      protected override getResult(): O {
+        if (this.output === undefined) {
+          throw new Error("No output");
+        }
+        return this.output;
+      }
+    }
+    return {
+      async compile(ctx, files) {
+        if (files.length !== 1) {
+          throw new Error("Compilation of multiple files is not implemented");
+        }
+        await compiler.compile(
+          ctx,
+          `${files[0].content}
+
+public class ${className} {
+  ${classDefinitions}
+  public static void main(String[] args) {
+    ${mainMethodBody}
+  }
+}`
+        );
+        return new TestProgram(className, jvmFactory);
+      },
+      [Symbol.dispose]() {},
+    };
+  }
+}

apps/ppp/src/adapters/runtime/java/test-worker.ts

@@ -0,0 +1,16 @@
+import { util } from 'java-runtime'
+import { startTestCompilerActor } from "testing/actor";
+
+import { JavaTestCompilerFactory } from "./test-compiler-factory";
+
+export interface JavaTestWorkerConfig {
+  javaTestCompilerFactory: JavaTestCompilerFactory;
+  util: typeof util;
+}
+
+startTestCompilerActor<JavaTestWorkerConfig>((ctx, out, factory) =>
+  factory(ctx, {
+    javaTestCompilerFactory: new JavaTestCompilerFactory(out),
+    util,
+  })
+);

apps/ppp/src/components/editor/model.ts

@@ -31,4 +31,5 @@ export const LANG_ICONS: Record<Language, string> = {
   [Language.Rust]: "vscode-icons:file-type-rust",
   [Language.Gleam]: "vscode-icons:file-type-gleam",
   [Language.CSharp]: "vscode-icons:file-type-csharp",
+  [Language.Java]: "vscode-icons:file-type-java",
 };

apps/ppp/src/components/editor/panel/panel.svelte

@@ -156,6 +156,7 @@
         runner[Symbol.dispose]();
       }
     } catch (err) {
+      console.error(err);
       logger.error(stringifyError(err));
     } finally {
       isRunning = false;

apps/ppp/src/content/design-patterns/factory/editor.astro

@@ -21,6 +21,7 @@ const { contentId } = Astro.props;
   import { rustCode, rustFactory } from "./rust";
   import { gleamCode, gleamFactory } from "./gleam";
   import { csCode, csFactory } from "./csharp";
+  import { javaCode, javaFactory } from './java'
 
   mountEditor(testCases, {
     [Language.JavaScript]: {
@@ -55,5 +56,9 @@ const { contentId } = Astro.props;
       initialValue: csCode,
       factory: csFactory,
     },
+    [Language.Java]: {
+      initialValue: javaCode,
+      factory: javaFactory
+    }
   });
 </script>

apps/ppp/src/content/design-patterns/factory/java/code.java

@@ -0,0 +1,11 @@
+enum SystemType {
+  PAY_PAL,
+  WEB_MONEY,
+  CAT_BANK
+}
+
+class Payment {
+  public static int execute(SystemType type, int base, int amount) {
+    throw new RuntimeException("Not implemented");
+  }
+}

apps/ppp/src/content/design-patterns/factory/java/factory.ts

@@ -0,0 +1,46 @@
+import { makeRemoteTestCompilerFactory } from "testing/actor";
+
+import Worker from "@/adapters/runtime/java/test-worker?worker";
+
+// Only type imports are allowed
+
+import type { TestCompilerFactory } from "testing";
+
+import type { JavaTestWorkerConfig } from "@/adapters/runtime/java/test-worker";
+
+import type { Input, Output } from "../tests-data";
+import type { PaymentSystemType } from "../reference";
+
+export const factory: TestCompilerFactory<Input, Output> =
+  makeRemoteTestCompilerFactory(
+    Worker,
+    (ctx, { javaTestCompilerFactory, util }: JavaTestWorkerConfig) => {
+      const JAVA_PAYMENT_SYSTEM_TYPES: Record<PaymentSystemType, string> = {
+        paypal: "PAY_PAL",
+        webmoney: "WEB_MONEY",
+        "cat-bank": "CAT_BANK",
+      };
+      return javaTestCompilerFactory.create(ctx, {
+        classDefinitions: `static native String getSystemType();
+  static native int getBase();
+  static native int getAmount();
+  static native void saveResult(int result);`,
+        mainMethodBody: `saveResult(Payment.execute(
+      SystemType.valueOf(getSystemType()),
+      getBase(),
+      getAmount()
+    ));`,
+        nativesFactory: (input, save) => ({
+          // @ts-expect-error TODO: import thread type
+          "getSystemType()Ljava/lang/String;": (t) =>
+            util.initString(
+              t.getBsCl(),
+              JAVA_PAYMENT_SYSTEM_TYPES[input.paymentSystem]
+            ),
+          "getBase()I": () => input.base,
+          "getAmount()I": () => input.amount,
+          "saveResult(I)V": (_: unknown, result: number) => save(result),
+        }),
+      });
+    }
+  );

apps/ppp/src/content/design-patterns/factory/java/index.ts

@@ -0,0 +1,2 @@
+export { default as javaCode } from "./code.java?raw";
+export { factory as javaFactory } from "./factory"

apps/ppp/src/shared/languages.ts

@@ -7,6 +7,7 @@ export enum Language {
   Rust = "rust",
   Gleam = "gleam",
   CSharp = "csharp",
+  Java = "java",
 }
 
 export const LANGUAGE_TITLE: Record<Language, string> = {
@@ -18,4 +19,5 @@ export const LANGUAGE_TITLE: Record<Language, string> = {
   [Language.Rust]: "Rust",
   [Language.Gleam]: "Gleam",
   [Language.CSharp]: "CSharp",
+  [Language.Java]: "Java",
 };