@tellahq/rescript 10.1.0-alpha.1

package/scripts/ninjaFactory.js

@@ -0,0 +1,36 @@
+//@ts-check
+
+// -inline 1000 makes size too large
+// # TODO: make sure it can be bootstrapped, at least is a very good
+// # test case of our optimizations
+// # build bsdep.exe: cc bsdep.mli bsdep.ml
+// ../native/4.06.1/bin/ocamlopt.opt -c -O2 -nodynlink -I 4.06.1 -g -w a+32  4.06.1/whole_compiler.mli 4.06.1/whole_compiler.ml  &> warning.log
+
+var targetDir = require("./bin_path").dirName;
+
+/**
+ *
+ * @param {{ocamlopt : string ;  INCL : string, isWin : boolean}} config
+ *
+ */
+function libNinja(config) {
+  return `
+ocamlopt = ${config.ocamlopt}${config.isWin ? ".exe" : ""}
+ext = .exe
+INCL = ${config.INCL}
+flags = -nodynlink -I $INCL -g -w -a ../jscomp/stubs/ext_basic_hash_stubs.c
+rule cc
+    command = $ocamlopt -O2  $flags $in -o $out ${
+      config.isWin ? "" : "&& strip $out"
+    }
+    description = Making $out
+build ../${targetDir}/rescript$ext:  cc $INCL/rescript.mli $INCL/rescript.ml
+    flags = $flags -unboxed-types unix.cmxa str.cmxa    
+build ../${targetDir}/bsb_helper$ext:  cc $INCL/bsb_helper.mli $INCL/bsb_helper.ml
+    flags = $flags  -unboxed-types -w -a
+build ../${targetDir}/bsc$ext: cc $INCL/whole_compiler.mli $INCL/whole_compiler.ml
+    flags = $flags -w A-4-9-48-40-45-41-44-50-21-30-32-34-37-27-60-42
+`;
+}
+
+exports.libNinja = libNinja;

package/scripts/pack.js

@@ -0,0 +1,107 @@
+//@ts-check
+var fs = require("fs");
+var path = require("path");
+var util = require("util");
+var child_process = require("child_process");
+// Note the escaping is escape to ocaml style string literals.
+// `util.format` is useful to escape to js style string literrals.
+// { name : "basic", children : ... }
+// { name : "xx", content : ... }
+/**
+ *
+ * @param {string} dir
+ */
+function scanDir(dir) {
+  var files = fs.readdirSync(dir).sort();
+  var children = files.map(file => {
+    var curFile = path.join(dir, file);
+    var stat = fs.statSync(curFile);
+    if (stat.isFile()) {
+      var content = fs.readFileSync(curFile, "utf8");
+      return { name: file, content };
+    } else if (stat.isDirectory()) {
+      return scanDir(curFile);
+    }
+  });
+  return { name: path.basename(dir), children };
+}
+
+/**
+ *
+ * @param {string} s
+ * @param {number} indent
+ */
+function escape(s, indent) {
+  return (
+    " ".repeat(indent) +
+    '"' +
+    s.replace(/(\n|"|\\|\t|\r)/g, (match, _, offset) => {
+      switch (match) {
+        case "\n":
+          var o = `\\n\\
+${" ".repeat(indent)}`;
+          if (s[offset + 1] === " ") {
+            o += "\\";
+          }
+          return o;
+        default:
+          return "\\" + match;
+      }
+    }) +
+    '"'
+  );
+}
+
+function toString(data, indent) {
+  var output = "";
+  if (data.children) {
+    output += `${" ".repeat(indent)}Dir("${data.name}",[
+${data.children.map(x => toString(x, indent + 1)).join(";\n")}        
+${" ".repeat(indent)}])`;
+  } else {
+    output += `${" ".repeat(indent)}File("${data.name}",
+${escape(data.content, indent)}
+${" ".repeat(indent)})`;
+  }
+  return output;
+}
+
+/**
+ *
+ */
+function updateThemes() {
+  var templatesDir = path.join(__dirname, "..", "jscomp", "bsb", "templates");
+  var output = child_process.spawnSync(`git clean -dfx ${templatesDir}`, {
+    shell: true,
+    encoding: "utf-8",
+  });
+  if (output.error) {
+    throw output.error;
+  }
+  console.log(output.stdout);
+  if (output.status !== 0) {
+    console.log(output.stderr);
+  }
+
+  // run git clean -dfx . first
+  fs.writeFileSync(
+    path.join(templatesDir, "..", "bsb_templates.ml"),
+    `
+type  node = 
+  | Dir of string *  node list 
+  | File of string *  string  
+let root = ([
+${fs
+  .readdirSync(templatesDir)
+  .filter(x => fs.statSync(path.join(templatesDir, x)).isDirectory())
+  .map(x => toString(scanDir(path.join(templatesDir, x)), 3))
+  .join(";\n")}
+])`,
+    "utf8"
+  );
+}
+exports.updateThemes = updateThemes;
+
+if (require.main === module) {
+  updateThemes();
+}

package/scripts/prebuilt.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+//@ts-check
+var cp = require("child_process");
+var path = require("path");
+var { is_windows } = require("./config.js");
+
+var root = path.join(__dirname, "..");
+var root_config = { cwd: root, stdio: [0, 1, 2], encoding: "utf8" };
+
+var ocamlVersion = require("./buildocaml.js").getVersionPrefix();
+var fs = require("fs");
+var package_config = require(path.join(__dirname, "..", "package.json"));
+var bsVersion = fs.readFileSync(
+  path.join(__dirname, "..", "jscomp", "common", "bs_version.ml"),
+  "utf-8"
+);
+/**
+ *
+ * @param {string} bsVersion
+ * @param {string} version
+ */
+function verifyVersion(bsVersion, version) {
+  try {
+    let [major, minor] = bsVersion
+      .split("\n")
+      .find(x => x.startsWith("let version = "))
+      .split("=")[1]
+      .trim()
+      .slice(1, -1)
+      .split(".");
+    let [specifiedMajor, specifiedMinor] = version.split(".");
+    console.log(
+      `package.json ${specifiedMajor}.${specifiedMinor} vs ABI : ${major}.${minor}`
+    );
+    return major === specifiedMajor && minor === specifiedMinor;
+  } catch (e) {
+    return false;
+  }
+}
+var assert = require("assert");
+
+assert(verifyVersion(bsVersion, package_config.version));
+
+function isHostPlatform() {
+  return process.platform === "darwin" || process.platform === "linux";
+}
+function rebuild() {
+  cp.execSync(`node ${path.join(__dirname, "ninja.js")} cleanbuild`, {
+    cwd: __dirname,
+    stdio: [0, 1, 2],
+  });
+}
+
+var use_env_compiler = process.argv.includes("-use-env-compiler");
+var bin_path = require("./bin_path").absolutePath;
+
+function buildCompiler() {
+  var prebuilt = "prebuilt.ninja";
+  var content = require("./ninjaFactory.js").libNinja({
+    ocamlopt: use_env_compiler
+      ? `ocamlopt.opt`
+      : `../native/${ocamlVersion}/bin/ocamlopt.opt`,
+    INCL: "4.06.1",
+    isWin: is_windows,
+  });
+
+  fs.writeFileSync(path.join(root, "lib", prebuilt), content, "ascii");
+  // This is for ninja access
+  process.env.PATH = `${bin_path}${path.delimiter}${process.env.PATH}`;
+  let ninjaPath = `ninja.exe`;
+  console.log(`start build`);
+  cp.execSync(
+    `${ninjaPath} -C lib -f ${prebuilt} -v -t clean && ${ninjaPath} -v -C lib -f ${prebuilt}`,
+    root_config
+  );
+  console.log("compiler built done");
+}
+if (!is_windows) {
+  if (!process.argv.includes("-no-clean")) {
+    require("./pack").updateThemes();
+    rebuild();
+    require("./ninja.js").updateRelease();
+  }
+}
+
+function createNinjaTar() {
+  if (isHostPlatform()) {
+    require("./installUtils.js").install();
+    console.log(`status in ninja submodule:`);
+    cp.execSync(`git -C ninja status -uno`, { cwd: root, stdio: [0, 1, 2] });
+    cp.execSync(
+      `git -C ninja archive --format=tar.gz HEAD -o ../vendor/ninja.tar.gz`,
+      { cwd: root, stdio: [0, 1, 2] }
+    );
+  }
+}
+
+createNinjaTar();
+buildCompiler();

package/scripts/release.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+//@ts-check
+
+// used as a unit of releasing
+var path = require("path");
+var fs = require("fs");
+var cp = require("child_process");
+var rootDir = path.join(__dirname, "..");
+var libJsDir = path.join(rootDir, "lib", "js");
+var jscompDir = path.join(rootDir, "jscomp");
+
+function run() {
+  // Note removing js file would affect `release.ninja`
+  // for (let file of fs.readdirSync(libJsDir)) {
+  //     if (file.endsWith('.js')) {
+  //         fs.unlinkSync(path.join(libJsDir, file))
+  //     }
+  // }
+
+  cp.execSync(
+    `git clean -dfx stubs ext common syntax depends core bsb main .`,
+    { cwd: jscompDir, encoding: "utf8", stdio: [0, 1, 2] }
+  );
+  // cp.execSync(`git clean -dfx templates && ocp-ocamlres templates -o bsb_templates.ml`,
+  //     { cwd: path.join(jscompDir,'bsb'), encoding: 'utf8', stdio: [0, 1, 2] })
+  cp.execSync(`ninja -t clean -g && ninja`, {
+    cwd: jscompDir,
+    encoding: "utf8",
+    stdio: [0, 1, 2],
+  });
+  cp.execSync("ninja", { cwd: path.join(rootDir, "lib"), stdio: [0, 1, 2] });
+  cp.execSync("ninja -f release.ninja -t clean && ninja -f release.ninja", {
+    cwd: path.join(rootDir, "jscomp"),
+    stdio: [0, 1, 2],
+  });
+  require("./doc_gen").main();
+}
+if (require.main === module) {
+  run();
+}
+exports.run = run;

package/scripts/repl.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+/*
+ * This script is used to compile a bundled compiler file into a standalone JS bundle.
+ * The compiled output (including the compiled stdlib files), will be put in the defined
+ * `PLAYGROUND` directory.
+ *
+ * Example:
+ *
+ * ```
+ * mkdir playground && mkdir playground/stdlib
+ * PLAYGROUND=../playground node scripts/repl.js
+ * ```
+ *
+ * You may also pass an alternative JSOO entrypoint (we have multiple defined
+ * in `jscomp/snapshot.ninja`) as a first parameter:
+ *
+ * ```
+ * # Builds the "simpler" JS bundle
+ * mkdir playground && mkdir playground/stdlib
+ * PLAYGROUND=../playground node scripts/repl.js js_compiler
+ * ```
+ */
+
+//@ts-check
+var child_process = require("child_process");
+var fs = require("fs");
+var path = require("path");
+
+var ocamlVersion = "4.06.1";
+var jscompDir = path.join(__dirname, "..", "jscomp");
+var sourceDir = path.join(__dirname, "..", "lib", ocamlVersion, "unstable");
+
+var config = {
+  cwd: jscompDir,
+  encoding: "utf8",
+  stdio: [0, 1, 2],
+  shell: true,
+};
+/**
+ *
+ * @param {string} cmd
+ */
+function e(cmd) {
+  console.log(`>>>>>> running command: ${cmd}`);
+  child_process.execSync(cmd, config);
+  console.log(`<<<<<<`);
+}
+
+if (!process.env.PLAYGROUND) {
+  var defaultPlayground = path.join(__dirname, "..", "playground");
+  console.warn(`PLAYGROUND env var unset, defaulting to ${defaultPlayground}`);
+  process.env.PLAYGROUND = defaultPlayground;
+}
+
+const BUILD_THIRD_PARTY = process.env.BUILD_THIRD_PARTY || false;
+var playground = process.env.PLAYGROUND;
+var OCAMLC = `ocamlc.opt`;
+
+// This mini project is needed to build cmij files for third party deps like @rescript/react
+const PLAYGROUND_BUNDLING = path.join(
+  __dirname,
+  "..",
+  "packages",
+  "playground-bundling"
+);
+
+var JSOO = `js_of_ocaml`;
+
+function prepare(isDev, targetCompilerFile) {
+  var [env, ocamlFlag, jsooFlag] = isDev
+    ? ["development", "-g ", "--pretty "]
+    : ["production", "", ""];
+  console.log(
+    `building byte code version of target compiler file '${targetCompilerFile}' [${env}]`
+  );
+
+  if (!fs.existsSync(playground)) {
+    console.log(`Creating output folder "${playground}"`);
+
+    // Create both, the `playground` and `playground/stdlib` dir
+    const stdlibDir = path.join(playground, "stdlib");
+    fs.mkdirSync(stdlibDir, { recursive: true });
+  }
+
+  const mliFile = path.join(sourceDir, targetCompilerFile + ".mli");
+  const mlFile = path.join(sourceDir, targetCompilerFile + ".ml");
+
+  // There may be a situation where the .mli file doesn't exist (mostly when
+  // the snapshot hasn't been checked into `lib/4.06.1/unstable`
+  e(`touch ${mliFile}`);
+  e(
+    `${OCAMLC} ${ocamlFlag}-w -30-40 -no-check-prims -I ${sourceDir} ${mliFile} ${mlFile} -o jsc.byte `
+  );
+  console.log(
+    `building js version for compiler target '${targetCompilerFile}'`
+  );
+  e(`${JSOO} compile jsc.byte ${jsooFlag}-o compiler.js`);
+  console.log("copy js artifacts");
+  e(`cp ../lib/js/*.js ${playground}/stdlib`);
+  e(`mv ./compiler.js ${playground}`);
+
+  // BUILDING THIRD PARTY CMIJ FILES
+  if (BUILD_THIRD_PARTY) {
+    console.log("Building third party packages...");
+    e(`cd ${PLAYGROUND_BUNDLING} && npm run build`);
+  }
+}
+
+function prepublish() {
+  var mainPackageJson = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "..", "package.json"))
+  );
+  var packageJson = JSON.stringify(
+    {
+      name: "rescript-compiler",
+      version: mainPackageJson.version,
+      license: mainPackageJson.license,
+      description: mainPackageJson.description,
+      repository: mainPackageJson.repository,
+      author: mainPackageJson.author,
+      maintainers: mainPackageJson.maintainers,
+      bugs: mainPackageJson.bugs,
+      homepage: mainPackageJson.homepage,
+      main: "compiler.js",
+    },
+    null,
+    2
+  );
+
+  fs.writeFileSync(jscompDir + `/${playground}/package.json`, packageJson, {
+    encoding: "utf8",
+  });
+}
+
+// Relevant target compiler files can be found in jscomp/snapshot.ninja
+let targetCompilerFile = "js_playground_compiler";
+
+// Let's derive the target file to compile from the last argument list.
+if (process.argv.length > 2) {
+  const lastArg = process.argv[process.argv.length - 1];
+
+  if (!lastArg.startsWith("-")) {
+    targetCompilerFile = lastArg;
+  }
+}
+
+prepare(process.argv.includes("-development"), targetCompilerFile);
+if (process.argv.includes("-prepublish")) {
+  prepublish();
+}

package/scripts/rescript_arg.js

@@ -0,0 +1,168 @@
+//@ts-check
+class StringBuilder {
+  constructor() {
+    this.val = "";
+  }
+  /**
+   *
+   * @param {any} v
+   * @returns
+   */
+  add(v) {
+    this.val = this.val + v;
+    return this;
+  }
+}
+class ArgError extends Error {}
+
+/**
+ *
+ * @param {string} s
+ */
+function bad_arg(s) {
+  throw new ArgError(s);
+}
+
+/**
+ * @typedef {{val : string}} stringref
+ * @typedef {{val : boolean}} boolref
+ * @typedef {{kind:"Unit_call",data : ()=>void } | {kind : "Unit_set", data : boolref}}unit_action
+ * @typedef {{kind:"String_call",data:(s : string)=>void} | {kind : "String_set",data: stringref}} string_action
+ * @typedef {{kind:"Unit",data : unit_action } | {kind:"String", data: string_action}} action
+ * @typedef {Array<[string,action,string]>} specs
+ * @param {StringBuilder} b
+ * @param {string} usage
+ * @param {specs} specs
+ */
+function usage_b(b, usage, specs) {
+  b.add(usage);
+  if (specs.length === 0) {
+    return;
+  }
+  b.add(`\nOptions:\n`);
+  var max_col = 0;
+  for (let [key] of specs) {
+    if (key.length > max_col) {
+      max_col = key.length;
+    }
+  }
+  for (let i = 0; i < specs.length; i++) {
+    let [key, _, doc] = specs[i];
+    if (!doc.startsWith("*internal*")) {
+      b.add("  ")
+        .add(key)
+        .add(" ".repeat(max_col - key.length + 2));
+      let cur = 0;
+      let doc_length = doc.length;
+      while (cur < doc_length) {
+        if (cur !== 0) {
+          b.add("\n").add(" ".repeat(max_col + 4));
+        }
+        let i = doc.indexOf("\n", cur);
+        if (i < 0) {
+          b.add(doc.substring(cur));
+          break;
+        } else {
+          b.add(doc.substr(cur, i - cur));
+          cur = i + 1;
+        }
+      }
+      if (i < specs.length - 1) {
+        b.add("\n");
+      }
+    }
+  }
+}
+
+/**
+ * @typedef { {kind : "Unknown"; data:string} | {kind:"Missing";data:string}} error
+ * @param {string} usage
+ * @param {error} error
+ * @param {specs} specs
+ */
+function stop_raise(usage, error, specs) {
+  var b = new StringBuilder();
+  switch (error.kind) {
+    case "Unknown":
+      if (["-help", "--help", "-h"].includes(error.data)) {
+        usage_b(b, usage, specs);
+        process.stderr.write(b.val);
+        process.exit(0);
+      } else {
+        b.add("unknown option: '").add(error.data).add("'.\n");
+      }
+    case "Missing":
+      b.add("option '").add(error.data).add("' needs an argument.\n");
+  }
+  usage_b(b, usage, specs);
+  bad_arg(b.val);
+}
+
+/**
+ *
+ * @param {string} usage
+ * @param {Array<string>} argv
+ * @param {specs} specs
+ * @param {(args:Array<string>)=>void} annofun
+ * @param {number} start
+ * @param {number} finish
+ */
+function parse_exn(
+  usage,
+  argv,
+  specs,
+  annofun,
+  start = 0,
+  // first 3 are [node, rescript, subcommand]
+  finish = argv.length
+) {
+  var current = start;
+  var list = [];
+  while (current < finish) {
+    let s = argv[current];
+    ++current;
+    if (s !== "" && s[0] === "-") {
+      var out = specs.find(([flag]) => flag === s);
+      if (out !== undefined) {
+        let [_, action] = out;
+        switch (action.kind) {
+          case "Unit":
+            switch (action.data.kind) {
+              case "Unit_call":
+                action.data.data();
+                break;
+              case "Unit_set":
+                action.data.data.val = true;
+                break;
+            }
+            break;
+          case "String":
+            // switch(action.data.kind)
+            if (current >= finish) {
+              stop_raise(usage, { kind: "Missing", data: s }, specs);
+            } else {
+              let arg = argv[current];
+              ++current;
+              switch (action.data.kind) {
+                case "String_call":
+                  action.data.data(arg);
+                  break;
+                case "String_set":
+                  action.data.data.val = arg;
+                  break;
+              }
+            }
+            break;
+        }
+      } else {
+        stop_raise(usage, { kind: "Unknown", data: s }, specs);
+      }
+    } else {
+      list.push(s);
+    }
+  }
+  annofun(list);
+}
+exports.bad_arg = bad_arg;
+exports.parse_exn = parse_exn;
+exports.ArgError = ArgError;