fixup: add c addon variant

Author: addaleax

package-lock.json

@@ -2,3 +2,4 @@
 dist
 pkg
 target
+build

packages/async-rewriter3/.gitignore

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [lib]
-crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib", "rlib", "staticlib"]
 
 [[bin]]
 name = "async-rewriter3"

packages/async-rewriter3/Cargo.toml

@@ -0,0 +1,90 @@
+#include <node_api.h>
+#include <stdlib.h>
+
+extern uint8_t async_rewrite_c(
+    const uint8_t* input,
+    uintptr_t input_len,
+    uint8_t** output,
+    uintptr_t* output_len,
+    uint8_t debug_level);
+extern void async_rewrite_free_result(
+    uint8_t* output);
+
+static napi_value async_rewrite_napi(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value argv[2];
+  size_t argc = sizeof(argv) / sizeof(argv[0]);
+
+  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  if (status != napi_ok) {
+    return NULL;
+  }
+  if (argc < 2) {
+    napi_throw_error(env, NULL, "Wrong number of arguments");
+    return NULL;
+  }
+
+  size_t bufsize = 0;
+  status = napi_get_value_string_utf8(env, argv[0], NULL, 0, &bufsize);
+  if (status != napi_ok) {
+    return NULL;
+  }
+  uint8_t* input = (uint8_t*)malloc(bufsize + 1);
+  if (input == NULL) {
+    napi_throw_error(env, NULL, "Memory allocation failed");
+    return NULL;
+  }
+  status = napi_get_value_string_utf8(env, argv[0], (char*)input, bufsize + 1, &bufsize);
+  if (status != napi_ok) {
+    free(input);
+    return NULL;
+  }
+  input[bufsize] = '\0';
+  uint32_t debug_level = 0;
+  status = napi_get_value_uint32(env, argv[1], &debug_level);
+  if (status != napi_ok) {
+    free(input);
+    return NULL;
+  }
+
+  uint8_t* output = NULL;
+  uintptr_t output_len = 0;
+  uint8_t result = async_rewrite_c(input, bufsize, &output, &output_len, debug_level);
+  free(input);
+
+  if (result != 0) {
+    napi_throw_error(env, NULL, "Error in async_rewrite_c");
+    return NULL;
+  }
+
+  napi_value result_value;
+  status = napi_create_string_utf8(env, (const char*)output, output_len, &result_value);
+  async_rewrite_free_result(output);
+  if (status != napi_ok) {
+    return NULL;
+  }
+
+  return result_value;
+}
+
+NAPI_MODULE_INIT() {
+  napi_value exported_function;
+  napi_status status;
+  status = napi_create_function(env,
+      "asyncRewrite",
+      NAPI_AUTO_LENGTH,
+      async_rewrite_napi,
+      NULL,
+      &exported_function);
+  if (status != napi_ok) {
+    return NULL;
+  }
+  status = napi_set_named_property(env,
+    exports,
+    "asyncRewrite",
+    exported_function);
+  if (status != napi_ok) {
+    return NULL;
+  }
+  return exports;
+}

packages/async-rewriter3/addon/binding.c

@@ -0,0 +1,12 @@
+{
+  'targets': [{
+    'target_name': 'async_rewriter3',
+    'sources': [ 'addon/binding.c' ],
+    'libraries': [
+      '<(PRODUCT_DIR)/../../target/release/libasync_rewriter3.a'
+    ],
+    'xcode_settings': {
+      'MACOSX_DEPLOYMENT_TARGET': '12.0',
+    }
+  }]
+}

packages/async-rewriter3/binding.gyp

@@ -17,6 +17,9 @@
     "node": ">=14.15.1"
   },
   "scripts": {
+    "prebuild-addon": "cargo build --release",
+    "build-addon": "node-gyp rebuild",
+    "install": "npm run build-addon",
     "compile": "npm run webpack-build",
     "prewebpack": "rm -rf dist pkg",
     "webpack": "webpack",
@@ -29,5 +32,6 @@
     "depcheck": "^1.4.3",
     "wasm-pack": "^0.13.1",
     "webpack-merge": "^5.8.0"
-  }
+  },
+  "gypfile": true
 }

packages/async-rewriter3/package.json

@@ -10,6 +10,7 @@ use oxc_parser::{ParseOptions, Parser};
 use oxc_semantic::{AstNode, Semantic, SemanticBuilder};
 use oxc_span::GetSpan;
 use oxc_span::{SourceType, Span};
+use core::slice;
 use std::{borrow::Cow, cmp::Ordering, collections::VecDeque};
 use wasm_bindgen::prelude::*;
 
@@ -607,3 +608,43 @@ pub fn async_rewrite(input: &str, debug_level: DebugLevel) -> Result<String, Str
 
     Ok(result)
 }
+
+#[no_mangle]
+pub extern "C" fn async_rewrite_c(
+    input: *const u8,
+    input_len: usize,
+    output: *mut *mut i8,
+    output_len: *mut usize,
+    debug_level: u8,
+) -> u8 {
+    let input = unsafe { String::from_utf8_lossy(slice::from_raw_parts(input, input_len)) };
+
+    let result = async_rewrite(input.as_ref(), match debug_level {
+        0 => DebugLevel::None,
+        1 => DebugLevel::TypesOnly,
+        2 => DebugLevel::Verbose,
+        _ => return 1,
+    });
+    match result {
+        Ok(output_str) => {
+            let output_cstr = std::ffi::CString::new(output_str).unwrap();
+            unsafe {
+                *output_len = output_cstr.as_bytes().len();
+                *output = output_cstr.into_raw();
+            }
+            0
+        }
+        Err(_) => 1,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn async_rewrite_free_result(
+    result: *mut i8,
+) -> () {
+    if !result.is_null() {
+        unsafe {
+            drop(std::ffi::CString::from_raw(result));
+        }
+    }
+}