✨ feat: Add basic function to parse()

rust/src/core.rs

@@ -21,6 +21,28 @@ use crate::{enums, options, outputs};
 
 const VERSION: &'static str = "0.2.0";
 
+pub fn parse<'local>(code: String, options: options::ParseOptions) -> Result<outputs::ParseOutput, String> {
+  let parse_params = ParseParams {
+    specifier: options.specifier,
+    text_info: SourceTextInfo::from_string(code),
+    media_type: options.media_type,
+    capture_tokens: options.capture_tokens,
+    maybe_syntax: None,
+    scope_analysis: options.scope_analysis,
+  };
+  let result = match options.parse_mode {
+    enums::ParseMode::Script => parse_script(parse_params),
+    _ => parse_module(parse_params),
+  };
+  match result {
+    Ok(parsed_source) => Ok(outputs::ParseOutput {
+      module: parsed_source.is_module(),
+      script: parsed_source.is_script(),
+    }),
+    Err(e) => Err(e.to_string()),
+  }
+}
+
 pub fn transpile<'local>(code: String, options: options::TranspileOptions) -> Result<outputs::TranspileOutput, String> {
   let parse_params = ParseParams {
     specifier: options.specifier,

rust/src/error.rs

@@ -17,59 +17,113 @@
 
 use jni::objects::{GlobalRef, JStaticMethodID, JThrowable};
 use jni::signature::ReturnType;
-use jni::sys::{jvalue};
+use jni::sys::jvalue;
 use jni::JNIEnv;
 
 use crate::converter;
 
-struct JniCalls {
-  pub jclass_core_exception: GlobalRef,
-  pub jmethod_id_core_exception_transpile_error: JStaticMethodID,
+struct JavaCoreException {
+  pub class: GlobalRef,
+  pub method_parse_error: JStaticMethodID,
+  pub method_transpile_error: JStaticMethodID,
 }
-unsafe impl Send for JniCalls {}
-unsafe impl Sync for JniCalls {}
+unsafe impl Send for JavaCoreException {}
+unsafe impl Sync for JavaCoreException {}
 
-static mut JNI_CALLS: Option<JniCalls> = None;
+impl JavaCoreException {
+  pub fn new<'local>(env: &mut JNIEnv<'local>) -> Self {
+    let class = env
+      .find_class("com/caoccao/javet/swc4j/exceptions/Swc4jCoreException")
+      .expect("Couldn't find class Swc4jCoreException");
+    let class = env
+      .new_global_ref(class)
+      .expect("Couldn't globalize class Swc4jCoreException");
+    let method_parse_error = env
+      .get_static_method_id(
+        &class,
+        "parseError",
+        "(Ljava/lang/String;)Lcom/caoccao/javet/swc4j/exceptions/Swc4jCoreException;",
+      )
+      .expect("Couldn't find static method Swc4jCoreException.parseError");
+    let method_transpile_error = env
+      .get_static_method_id(
+        &class,
+        "transpileError",
+        "(Ljava/lang/String;)Lcom/caoccao/javet/swc4j/exceptions/Swc4jCoreException;",
+      )
+      .expect("Couldn't find static method Swc4jCoreException.transpileError");
+    JavaCoreException {
+      class,
+      method_parse_error,
+      method_transpile_error,
+    }
+  }
+
+  pub fn throw_parse_error<'local, 'a>(&self, env: &mut JNIEnv<'local>, message: &'a str) {
+    let message = jvalue {
+      l: converter::string_to_jstring(env, message).as_raw(),
+    };
+    let exception = unsafe {
+      JThrowable::from_raw(
+        env
+          .call_static_method_unchecked(
+            &self.class,
+            &self.method_parse_error,
+            ReturnType::Object,
+            &[message],
+          )
+          .expect("Couldn't create parse error")
+          .as_jni()
+          .l,
+      )
+    };
+    let _ = env.throw(exception);
+  }
+
+  pub fn throw_transpile_error<'local, 'a>(&self, env: &mut JNIEnv<'local>, message: &'a str) {
+    let message = jvalue {
+      l: converter::string_to_jstring(env, message).as_raw(),
+    };
+    let exception = unsafe {
+      JThrowable::from_raw(
+        env
+          .call_static_method_unchecked(
+            &self.class,
+            &self.method_transpile_error,
+            ReturnType::Object,
+            &[message],
+          )
+          .expect("Couldn't create transpile error")
+          .as_jni()
+          .l,
+      )
+    };
+    let _ = env.throw(exception);
+  }
+}
+
+static mut JAVA_CORE_EXCEPTION: Option<JavaCoreException> = None;
 
 pub fn init<'local>(env: &mut JNIEnv<'local>) {
-  let jclass_core_exception = env
-    .find_class("com/caoccao/javet/swc4j/exceptions/Swc4jCoreException")
-    .expect("Couldn't find class Swc4jCoreException");
-  let jclass_core_exception = env
-    .new_global_ref(jclass_core_exception)
-    .expect("Couldn't globalize class Swc4jCoreException");
-  let jmethod_id_core_exception_transpile_error = env
-    .get_static_method_id(
-      &jclass_core_exception,
-      "transpileError",
-      "(Ljava/lang/String;)Lcom/caoccao/javet/swc4j/exceptions/Swc4jCoreException;",
-    )
-    .expect("Couldn't find static method Swc4jCoreException.transpileError");
   unsafe {
-    JNI_CALLS = Some(JniCalls {
-      jclass_core_exception,
-      jmethod_id_core_exception_transpile_error,
-    });
+    JAVA_CORE_EXCEPTION = Some(JavaCoreException::new(env));
+  }
+}
+
+pub fn throw_parse_error<'local, 'a>(env: &mut JNIEnv<'local>, message: &'a str) {
+  unsafe {
+    JAVA_CORE_EXCEPTION
+      .as_ref()
+      .unwrap()
+      .throw_parse_error(env, message);
   }
 }
 
 pub fn throw_transpile_error<'local, 'a>(env: &mut JNIEnv<'local>, message: &'a str) {
-  let message = jvalue {
-    l: converter::string_to_jstring(env, message).as_raw(),
-  };
-  let exception = unsafe {
-    JThrowable::from_raw(
-      env
-        .call_static_method_unchecked(
-          &JNI_CALLS.as_ref().unwrap().jclass_core_exception,
-          &JNI_CALLS.as_ref().unwrap().jmethod_id_core_exception_transpile_error,
-          ReturnType::Object,
-          &[message],
-        )
-        .expect("Couldn't create transpile error")
-        .as_jni()
-        .l,
-    )
-  };
-  let _ = env.throw(exception);
+  unsafe {
+    JAVA_CORE_EXCEPTION
+      .as_ref()
+      .unwrap()
+      .throw_transpile_error(env, message);
+  }
 }

rust/src/lib.rs

@@ -53,13 +53,20 @@ pub extern "system" fn Java_com_caoccao_javet_swc4j_Swc4jNative_coreGetVersion<'
 
 #[no_mangle]
 pub extern "system" fn Java_com_caoccao_javet_swc4j_Swc4jNative_coreParse<'local>(
-  _: JNIEnv<'local>,
+  mut env: JNIEnv<'local>,
   _: JClass<'local>,
-  _: jstring,
-  _: jobject,
+  code: jstring,
+  options: jobject,
 ) -> jobject {
-  // TODO
-  null_mut()
+  let code = converter::jstring_to_string(&mut env, code);
+  let options = options::ParseOptions::from_jni_type(&mut env, options);
+  match core::parse(code, options) {
+    Ok(output) => output.to_jni_type(&mut env).as_raw(),
+    Err(message) => {
+      error::throw_parse_error(&mut env, message.as_str());
+      null_mut()
+    }
+  }
 }
 
 #[no_mangle]