use custom ctors for all kinds of JS objects

Author: iliabylich

build-convert/build.rs

@@ -31,12 +31,12 @@ fn field_name(f: &Field) -> String {
 }
 
 fn build_converter(node: &Node) -> String {
-    let set_fields: Vec<String> = node
+    let fields: Vec<String> = node
         .fields
         .iter()
         .map(|f| {
             format!(
-                "obj.Set(\"{name}\", convert(std::move(node->{name}), env));",
+                "convert(std::move(node->{name}), env),",
                 name = field_name(f)
             )
         })
@@ -47,22 +47,68 @@ fn build_converter(node: &Node) -> String {
         if (!node) {{
             return env.Null();
         }}
-        Napi::Object obj = Napi::Object::New(env);
-        obj.Set(\"type\", \"{class_name}\");
-        {set_fields}
-        return obj;
+        return {class_name}Ctor.New({{
+            {fields}
+        }});
     }}",
         class_name = node.struct_name,
+        fields = fields.join("\n            ")
+    )
+}
+
+fn ctor_definition(node: &Node) -> String {
+    format!("Napi::FunctionReference {}Ctor;", node.struct_name)
+}
+
+fn ctor_fn_definition(node: &Node) -> String {
+    let set_fields: Vec<String> = node
+        .fields
+        .iter()
+        .enumerate()
+        .map(|(idx, f)| {
+            format!(
+                "self.Set(\"{name}\", info[{idx}]);",
+                name = field_name(f),
+                idx = idx
+            )
+        })
+        .collect();
+
+    format!(
+        "Napi::Value {name}CtorFn(const Napi::CallbackInfo &info)
+    {{
+        Napi::Object self = info.This().As<Napi::Object>();
+        Napi::Env env = info.Env();
+        {set_fields}
+        return env.Null();
+    }}
+",
+        name = node.struct_name,
         set_fields = set_fields.join("\n        ")
     )
 }
 
+fn init_exports(node: &Node) -> String {
+    format!(
+        "fn = Napi::Function::New(env, {name}CtorFn, \"{name}\");
+        {name}Ctor = Napi::Persistent(fn);
+        {name}Ctor.SuppressDestruct();
+        exports.Set(\"{name}\", fn);
+",
+        name = node.struct_name
+    )
+}
+
 fn main() {
     let path = relative_path("../convert_gen.h");
     let nodes = lib_ruby_parser_nodes::nodes().unwrap();
 
+    let ctor_definitions: Vec<String> = nodes.iter().map(ctor_definition).collect();
+    let ctor_fn_definitions: Vec<String> = nodes.iter().map(ctor_fn_definition).collect();
+
     let converters: Vec<String> = nodes.iter().map(build_converter).collect();
     let comparisons: Vec<String> = nodes.iter().map(build_comparison).collect();
+    let init_exports: Vec<String> = nodes.iter().map(init_exports).collect();
 
     let contents = format!(
         "#ifndef LIB_RUBY_PARSER_CONVERT_GEN_H
@@ -78,6 +124,9 @@ template<class> inline constexpr bool always_false_v = false;
 
 namespace lib_ruby_parser_node
 {{
+    {ctor_definitions}
+    {ctor_fn_definitions}
+
     Napi::Value convert(std::unique_ptr<Node> node, Napi::Env env);
     Napi::Value convert(Node node, Napi::Env env);
     Napi::Value convert(std::unique_ptr<Range> range, Napi::Env env);
@@ -126,12 +175,21 @@ namespace lib_ruby_parser_node
                 static_assert(always_false_v<T>, \"non-exhaustive visitor!\");
         }}, node.inner);
     }}
+
+    void InitNodeTypes(Napi::Env env, Napi::Object exports) {{
+        Napi::Function fn;
+
+        {init_exports}
+    }}
 }} // namespace lib_ruby_parser_node
 
 #endif // LIB_RUBY_PARSER_CONVERT_GEN_H
 ",
         converters = converters.join("\n    "),
         comparisons = comparisons.join("\n            else "),
+        ctor_definitions = ctor_definitions.join("\n    "),
+        ctor_fn_definitions = ctor_fn_definitions.join("\n    "),
+        init_exports = init_exports.join("\n        ")
     );
 
     std::fs::write(&path, &contents).unwrap();