Java slang (#2895)

* add java-slang support

* merge master

* remove lib import

* fix library import path

* remove fixme comment

* use java-slang package

* use js-slang enums

* revert yarn lock

* use cdn

* clean up code structure

* read input as json

* fix editor suggestions

* refactor async load

* move url to constants

* fix typo

* fix buffer, JSON error handling

* update js-slang

* specify module name

---------

Co-authored-by: Martin Henz <henz@comp.nus.edu.sg>
Co-authored-by: Richard Dominick <34370238+RichDom2185@users.noreply.github.com>

Author: 3 people

package.json

@@ -50,6 +50,7 @@
     "flexboxgrid": "^6.3.1",
     "flexboxgrid-helpers": "^1.1.3",
     "hastscript": "^9.0.0",
+    "java-slang": "^1.0.1",
     "js-slang": "^1.0.62",
     "js-yaml": "^4.1.0",
     "konva": "^9.2.0",

src/commons/application/ApplicationTypes.ts

@@ -122,13 +122,15 @@ export enum SupportedLanguage {
   JAVASCRIPT = 'JavaScript',
   SCHEME = 'Scheme',
   PYTHON = 'Python',
+  JAVA = 'Java',
   C = 'C'
 }
 
 export const SUPPORTED_LANGUAGES = [
   SupportedLanguage.JAVASCRIPT,
   SupportedLanguage.SCHEME,
   SupportedLanguage.PYTHON,
+  SupportedLanguage.JAVA,
   SupportedLanguage.C
 ];
 
@@ -211,6 +213,15 @@ export const pyLanguages: SALanguage[] = pySubLanguages.map(sublang => {
   return { ...sublang, mainLanguage: SupportedLanguage.PYTHON, supports: { repl: true } };
 });
 
+export const javaLanguages: SALanguage[] = [
+  {
+    chapter: Chapter.FULL_JAVA,
+    variant: Variant.DEFAULT,
+    displayName: 'Java',
+    mainLanguage: SupportedLanguage.JAVA,
+    supports: {}
+  }
+];
 export const cLanguages: SALanguage[] = [
   {
     chapter: Chapter.FULL_C,
@@ -290,6 +301,7 @@ export const ALL_LANGUAGES: readonly SALanguage[] = [
   htmlLanguage,
   ...schemeLanguages,
   ...pyLanguages,
+  ...javaLanguages,
   ...cLanguages
 ];
 // TODO: Remove this function once logic has been fully migrated

src/commons/editor/Editor.tsx

@@ -435,8 +435,8 @@ const EditorBase = React.memo((props: EditorProps & LocalStateProps) => {
     session.on('changeAnnotation' as any, makeHandleAnnotationChange(session));
 
     // Start autocompletion
-    if (props.sourceChapter === Chapter.FULL_C) {
-      // for C language, use the default autocomplete provided by ace editor
+    if (props.sourceChapter === Chapter.FULL_C || props.sourceChapter === Chapter.FULL_JAVA) {
+      // for C, Java language, use the default autocomplete provided by ace editor
       const { textCompleter, keyWordCompleter, setCompleters } = acequire('ace/ext/language_tools');
       setCompleters([textCompleter, keyWordCompleter]);
     } else {

src/commons/navigationBar/subcomponents/NavigationBarLangSelectButton.tsx

@@ -4,6 +4,7 @@ import { useDispatch } from 'react-redux';
 import {
   cLanguages,
   getLanguageConfig,
+  javaLanguages,
   pyLanguages,
   SALanguage,
   schemeLanguages,
@@ -23,6 +24,7 @@ const defaultSublanguages: {
   [SupportedLanguage.JAVASCRIPT]: sourceLanguages[0],
   [SupportedLanguage.PYTHON]: pyLanguages[0],
   [SupportedLanguage.SCHEME]: schemeLanguages[0],
+  [SupportedLanguage.JAVA]: javaLanguages[0],
   [SupportedLanguage.C]: cLanguages[0]
 };
 

src/commons/sagas/WorkspaceSaga/helpers/evalCode.ts

@@ -9,6 +9,7 @@ import { SagaIterator } from 'redux-saga';
 import { call, put, race, select, take } from 'redux-saga/effects';
 import * as Sourceror from 'sourceror';
 import { makeCCompilerConfig, specialCReturnObject } from 'src/commons/utils/CToWasmHelper';
+import { javaRun } from 'src/commons/utils/JavaHelper';
 import { notifyStoriesEvaluated } from 'src/features/stories/StoriesActions';
 import { EVAL_STORY } from 'src/features/stories/StoriesTypes';
 
@@ -244,6 +245,7 @@ export function* evalCode(
   const isLazy: boolean = context.variant === Variant.LAZY;
   const isWasm: boolean = context.variant === Variant.WASM;
   const isC: boolean = context.chapter === Chapter.FULL_C;
+  const isJava: boolean = context.chapter === Chapter.FULL_JAVA;
 
   let lastDebuggerResult = yield select(
     (state: OverallState) => state.workspaces[workspaceLocation].lastDebuggerResult
@@ -263,6 +265,8 @@ export function* evalCode(
         ? call_variant(context.variant)
         : isC
         ? call(cCompileAndRun, entrypointCode, context)
+        : isJava
+        ? call(javaRun, entrypointCode, context)
         : call(
             runFilesInContext,
             isFolderModeEnabled

src/commons/utils/AceHelper.ts

@@ -50,6 +50,8 @@ export const getModeString = (chapter: Chapter, variant: Variant, library: strin
     case Chapter.SCHEME_4:
     case Chapter.FULL_SCHEME:
       return 'scheme';
+    case Chapter.FULL_JAVA:
+      return 'java';
     case Chapter.FULL_C:
       return 'c_cpp';
     default:

src/commons/utils/Constants.ts

@@ -39,6 +39,7 @@ const githubClientId = process.env.REACT_APP_GITHUB_CLIENT_ID || '';
 const githubOAuthProxyUrl = process.env.REACT_APP_GITHUB_OAUTH_PROXY_URL || '';
 const sicpBackendUrl =
   process.env.REACT_APP_SICPJS_BACKEND_URL || 'https://sicp.sourceacademy.org/';
+const javaPackagesUrl = 'https://source-academy.github.io/modules/java/java-packages/src/';
 const workspaceSettingsLocalStorageKey = 'workspace-settings';
 
 // For achievements feature (CA - Continual Assessment)
@@ -136,6 +137,7 @@ const Constants = {
   sharedbBackendUrl,
   cadetLoggerInterval,
   sicpBackendUrl,
+  javaPackagesUrl,
   workspaceSettingsLocalStorageKey,
   caFulfillmentLevel
 };

src/commons/utils/JavaHelper.ts

@@ -0,0 +1,138 @@
+import setupJVM, { parseBin } from 'java-slang/dist/jvm';
+import { createModuleProxy, loadCachedFiles } from 'java-slang/dist/jvm/utils/integration';
+import { Context } from 'js-slang';
+import loadSourceModules from 'js-slang/dist/modules/loader';
+
+import Constants from './Constants';
+import DisplayBufferService from './DisplayBufferService';
+
+export async function javaRun(javaCode: string, context: Context) {
+  let compiled = {};
+
+  let files = {};
+  let buffer: string[] = [];
+
+  const readClassFiles = (path: string) => {
+    let item = files[path as keyof typeof files];
+
+    // not found: attempt to fetch from CDN
+    if (!item && path) {
+      const splits = path.split('/');
+      splits.pop(); // classname.class
+      const pkg = splits.join('_');
+
+      const request = new XMLHttpRequest();
+      request.open('GET', `${Constants.javaPackagesUrl}${pkg}.json`, false);
+      request.send(null);
+      if (request.status !== 200) {
+        throw new Error('File not found: ' + path);
+      }
+      const json = JSON.parse(request.responseText);
+      // we might want to cache the files in IndexedDB here
+      files = { ...files, ...json };
+
+      if (!files[path as keyof typeof files]) {
+        throw new Error('File not found: ' + path);
+      }
+
+      item = files[path as keyof typeof files];
+    }
+
+    // convert base64 to classfile object
+    const binaryString = atob(item);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return parseBin(new DataView(bytes.buffer));
+  };
+  const loadNatives = async (path: string) => {
+    // dynamic load modules
+    if (path.startsWith('modules')) {
+      const module = path.split('/')[1] as string;
+      const moduleFuncs = await loadSourceModules(new Set([module]), context, true);
+      const { proxy } = createModuleProxy(module, moduleFuncs[module]);
+      return { default: proxy };
+    }
+    return await import(`java-slang/dist/jvm/stdlib/${path}.js`);
+  };
+  const stdout = (str: string) => {
+    if (str.endsWith('\n')) {
+      buffer.push(str);
+      const lines = buffer.join('').split('\n');
+      lines.pop();
+      lines.forEach(line => DisplayBufferService.push(line, context.externalContext));
+      buffer = [];
+    } else {
+      buffer.push(str);
+    }
+  };
+  const stderr = (msg: string) => {
+    context.errors.push({
+      type: 'Runtime' as any,
+      severity: 'Error' as any,
+      location: {
+        start: {
+          line: -1,
+          column: -1
+        },
+        end: {
+          line: -1,
+          column: -1
+        }
+      },
+      explain: () => msg,
+      elaborate: () => msg
+    });
+  };
+
+  // FIXME: Remove when the compiler is working
+  try {
+    const json = JSON.parse(javaCode);
+    compiled = json;
+  } catch (e) {
+    stderr(e);
+    return Promise.resolve({ status: 'error' });
+  }
+
+  // load cached classfiles from IndexedDB
+  return loadCachedFiles(() =>
+    // Initial loader to fetch commonly used classfiles
+    fetch(Constants.javaPackagesUrl + '_base.json')
+      .then(res => res.json())
+      .then((obj: { [key: string]: string }) => {
+        return obj;
+      })
+  )
+    .then(stdlib => {
+      files = {
+        ...stdlib,
+        ...compiled
+      };
+
+      // run the JVM
+      return new Promise((resolve, reject) => {
+        setupJVM({
+          javaClassPath: '',
+          nativesPath: '',
+          callbacks: {
+            readFileSync: readClassFiles,
+            readFile: loadNatives,
+            stdout,
+            stderr,
+            onFinish: () => {
+              resolve(
+                context.errors.length
+                  ? { status: 'error' }
+                  : { status: 'finished', context, value: '' }
+              );
+            }
+          },
+          natives: {}
+        })();
+      });
+    })
+    .catch(() => {
+      return { status: 'error' };
+    });
+}