Restore js_of_ocaml web interpreter

Author: rprimet

.gitattributes

@@ -3,5 +3,5 @@
 *.md linguist-documentation
 *.hints linguist-generated
 
-**/package-lock.json linguist-generated
-**/yarn.lock linguist-generated
+**/package-lock.json linguist-generated -diff
+**/yarn.lock linguist-generated -diff

.github/workflows/ci.yml

@@ -112,6 +112,12 @@ jobs:
       - name: Validate Python runtime
         if: ${{ always() }}
         run: cd /home/ocaml/catala && opam exec -- make validate-py-runtime
+      - name: Test web interpreter (jsoo)
+        if: ${{ always() }}
+        run: |
+          cd /home/ocaml/catala
+          opam exec -- dune build compiler/catala_web_interpreter.bc.js
+          node compiler/test_web_interpreter.js
       - name: Test Summary
         uses: test-summary/action@v2
         with:

Makefile

@@ -208,6 +208,10 @@ CLERK_TEST=$(CLERK_BIN) test --exe $(CATALA_BIN) \
 unit-tests: .FORCE
 	dune build @for-tests @runtest
 
+web-interpreter-tests: .FORCE
+	dune build compiler/catala_web_interpreter.bc.js
+	node compiler/test_web_interpreter.js
+
 BACKEND_TEST_DIRS = arithmetic array bool date dec default enum exception func io money monomorphisation name_resolution parsing scope struct tuples typing variable_state
 
 BACKEND_TESTS = $(wildcard $(BACKEND_TEST_DIRS:%=tests/%/good/*.catala_*))

catala.opam

@@ -42,6 +42,9 @@ depends: [
   "uucp" {>= "10"}
   "ubase" {>= "0.05"}
   "zarith" {>= "1.12"}
+  "zarith_stubs_js" {>= "v0.17.0"}
+  "js_of_ocaml" {>= "6.0"}
+  "js_of_ocaml-ppx" {>= "6.0"}
   "yojson" {>= "2.1.0" & < "3"}
    # Not a strict upper bound for catala, but other tools (adgen) have it and we
    # don't want them to need a catala recompile

compiler/catala_utils/message.ml

@@ -182,6 +182,12 @@ module Content = struct
   let of_string (s : string) : t =
     [MainMessage (fun ppf -> Format.pp_print_text ppf s)]
 
+  let get_positions (content : t) : (Pos.t * message option) list =
+    List.filter_map
+      (function
+        | Position { pos; pos_message } -> Some (pos, pos_message) | _ -> None)
+      content
+
   let basic_msg ?header ppf target content =
     let pp_header ppf = Option.iter (Format.fprintf ppf " %s: ") header in
     Format.pp_open_vbox ppf 0;

compiler/catala_utils/message.mli

@@ -52,6 +52,9 @@ module Content : sig
   val add_suggestion : t -> string list -> t
   val add_position : t -> ?message:message -> Pos.t -> t
 
+  val get_positions : t -> (Pos.t * message option) list
+  (** Extract all positions from the content *)
+
   (** {2 Content emission}*)
 
   val emit_n :

compiler/catala_web.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// CLI wrapper for the Catala web interpreter
+// Mimics a subset of the catala CLI for testing purposes
+//
+// Usage:
+//   node catala_web.js interpret FILE -s SCOPE
+//   node catala_web.js test-scope SCOPE FILE
+//   node catala_web.js Typecheck FILE
+
+const fs = require('fs');
+const path = require('path');
+
+// Load the interpreter
+const interpreterPath = path.join(__dirname, '../_build/default/compiler/catala_web_interpreter.bc.js');
+if (!fs.existsSync(interpreterPath)) {
+  console.error('Error: Interpreter not found. Run: dune build compiler/catala_web_interpreter.bc.js');
+  process.exit(1);
+}
+eval(fs.readFileSync(interpreterPath, 'utf8'));
+
+// Parse arguments
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  console.error('Usage: catala_web.js <command> [options] <file>');
+  console.error('Commands: interpret, test-scope, Typecheck');
+  process.exit(1);
+}
+
+const command = args[0];
+
+// Detect language from file extension
+function detectLanguage(file) {
+  if (file.endsWith('.catala_en')) return 'en';
+  if (file.endsWith('.catala_fr')) return 'fr';
+  if (file.endsWith('.catala_pl')) return 'pl';
+  return 'en'; // default
+}
+
+// Extract test scopes from file (scopes with #[test] attribute)
+function extractTestScopes(content) {
+  const regex = /#\[test\]\s*declaration\s+scope\s+(\w+)/g;
+  const scopes = [];
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    scopes.push(match[1]);
+  }
+  return scopes;
+}
+
+// Format output like the CLI
+function formatOutput(scopeName, output) {
+  if (!output.trim()) {
+    return `┌─[RESULT]─\n│ Computation successful!\n└─`;
+  }
+  const lines = output.trim().split('\n');
+  const formatted = lines.map(l => `│ ${l}`).join('\n');
+  return `┌─[RESULT]─ ${scopeName} ─\n${formatted}\n└─`;
+}
+
+// Main logic
+let file, scope, lang;
+
+switch (command) {
+  case 'interpret':
+  case 'Interpret': {
+    // catala interpret FILE -s SCOPE
+    const sIdx = args.indexOf('-s');
+    if (sIdx === -1 || sIdx + 1 >= args.length) {
+      console.error('Error: -s SCOPE required for interpret');
+      process.exit(1);
+    }
+    scope = args[sIdx + 1];
+    file = args.find((a, i) => i > 0 && a !== '-s' && args[i-1] !== '-s' && !a.startsWith('-'));
+    if (!file) {
+      console.error('Error: FILE required');
+      process.exit(1);
+    }
+    lang = detectLanguage(file);
+    const content = fs.readFileSync(file, 'utf8');
+    const result = exports.interpret({
+      files: { [path.basename(file)]: content },
+      scope: scope,
+      language: lang
+    });
+    if (result.success) {
+      console.log(formatOutput(scope, result.output));
+    } else {
+      console.error(result.error);
+      process.exit(1);
+    }
+    break;
+  }
+
+  case 'test-scope': {
+    // catala test-scope SCOPE FILE  (legacy)
+    // or catala test-scope FILE (runs all #[test] scopes)
+    if (args.length < 2) {
+      console.error('Error: FILE required');
+      process.exit(1);
+    }
+
+    // Check if second arg is a file or scope name
+    if (args.length >= 3 && fs.existsSync(args[2])) {
+      // catala test-scope SCOPE FILE
+      scope = args[1];
+      file = args[2];
+    } else if (fs.existsSync(args[1])) {
+      // catala test-scope FILE (run all #[test] scopes)
+      file = args[1];
+      scope = null;
+    } else {
+      // Assume catala test-scope SCOPE FILE
+      scope = args[1];
+      file = args[2];
+    }
+
+    lang = detectLanguage(file);
+    const content = fs.readFileSync(file, 'utf8');
+
+    const scopes = scope ? [scope] : extractTestScopes(content);
+    if (scopes.length === 0) {
+      console.error('Error: No test scopes found');
+      process.exit(1);
+    }
+
+    let hasError = false;
+    for (const s of scopes) {
+      const result = exports.interpret({
+        files: { [path.basename(file)]: content },
+        scope: s,
+        language: lang
+      });
+      if (result.success) {
+        console.log(formatOutput(s, result.output));
+      } else {
+        console.error(result.error);
+        hasError = true;
+      }
+    }
+    if (hasError) process.exit(1);
+    break;
+  }
+
+  case 'Typecheck':
+  case 'typecheck': {
+    file = args[1];
+    if (!file) {
+      console.error('Error: FILE required');
+      process.exit(1);
+    }
+    lang = detectLanguage(file);
+    const content = fs.readFileSync(file, 'utf8');
+    const result = exports.typecheck({
+      files: { [path.basename(file)]: content },
+      language: lang
+    });
+    if (result.success) {
+      console.log('┌─[RESULT]─\n│ Typechecking successful!\n└─');
+    } else {
+      console.error(result.error);
+      process.exit(1);
+    }
+    break;
+  }
+
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.error('Supported: interpret, test-scope, Typecheck');
+    process.exit(1);
+}