herb 0.7.1-arm-linux-musl → 0.7.3-arm-linux-musl

data/templates/javascript/packages/core/src/nodes.ts.erb

@@ -0,0 +1,414 @@
+import { Location } from "./location.js"
+import { Token, SerializedToken } from "./token.js"
+import { HerbError } from "./errors.js"
+import { convertToUTF8 } from "./util.js"
+
+import type { SerializedLocation } from "./location.js"
+import type { SerializedHerbError } from "./errors.js"
+import type { Visitor } from "./visitor.js"
+
+export type SerializedNodeType = string
+
+export interface SerializedNode {
+  type: SerializedNodeType
+  location: SerializedLocation
+  errors: SerializedHerbError[]
+}
+
+export interface BaseNodeProps {
+  type: NodeType
+  location: Location
+  errors: HerbError[]
+}
+
+export abstract class Node implements BaseNodeProps {
+  readonly type: NodeType
+  readonly location: Location
+  readonly errors: HerbError[]
+
+  static from(node: SerializedNode): Node {
+    return fromSerializedNode(node)
+  }
+
+  static get type(): NodeType {
+    throw new Error("AST_NODE")
+  }
+
+  constructor(type: NodeType, location: Location, errors: HerbError[]) {
+    this.type = type
+    this.location = location
+    this.errors = errors
+  }
+
+  toJSON(): SerializedNode {
+    return {
+      type: this.type,
+      location: this.location.toJSON(),
+      errors: this.errors,
+    }
+  }
+
+  inspect(): string {
+    return this.treeInspect(0)
+  }
+
+  is<T extends Node>(nodeClass: { new(...args: any[]): T; prototype: T, type: NodeType }): this is T {
+    return this.type === nodeClass.type
+  }
+
+  isOfType<T extends Node>(type: NodeType): this is T {
+    return this.type === type
+  }
+
+  get isSingleLine(): boolean {
+    return this.location.start.line === this.location.end.line
+  }
+
+  abstract treeInspect(indent?: number): string
+  abstract recursiveErrors(): HerbError[]
+  abstract accept(visitor: Visitor): void
+  abstract childNodes(): (Node | null | undefined)[]
+  abstract compactChildNodes(): Node[]
+
+  protected inspectArray(
+    array: (Node | HerbError)[] | null | undefined,
+    prefix: string,
+  ): string {
+    if (!array) return "∅\n"
+    if (array.length === 0) return "[]\n"
+
+    let output = `(${array.length} item${array.length === 1 ? "" : "s"})\n`
+
+    array.forEach((item, index) => {
+      const isLast = index === array.length - 1
+
+      if (item instanceof Node || item instanceof HerbError) {
+        output += this.inspectNode(
+          item,
+          prefix,
+          isLast ? "    " : "│   ",
+          isLast,
+          false,
+        )
+      } else {
+        const symbol = isLast ? "└── " : "├── "
+        output += `${prefix}${symbol} ${item}\n`
+      }
+    })
+
+    output += `${prefix}\n`
+
+    return output
+  }
+
+  protected inspectNode(
+    node: Node | HerbError | undefined | null,
+    prefix: string,
+    prefix2: string = "    ",
+    last: boolean = true,
+    trailingNewline: boolean = true,
+  ): string {
+    if (!node) return "∅\n"
+
+    let output = trailingNewline ? "\n" : ""
+    output += `${prefix}`
+
+    output += last ? "└── " : "├── "
+    output += node
+      .treeInspect()
+      .trimStart()
+      .split("\n")
+      .map((line, index) =>
+        index === 0 ? line.trimStart() : `${prefix}${prefix2}${line}`,
+      )
+      .join("\n")
+      .trimStart()
+
+    output += `\n`
+
+    return output
+  }
+}
+
+<%- nodes.each do |node| -%>
+export interface Serialized<%= node.name %> extends SerializedNode {
+  type: "<%= node.type %>";
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  <%= field.name %>: string;
+  <%- when Herb::Template::TokenField -%>
+  <%= field.name %>: SerializedToken | null;
+  <%- when Herb::Template::BooleanField -%>
+  <%= field.name %>: boolean;
+  <%- when Herb::Template::ElementSourceField -%>
+  <%= field.name %>: string;
+  <%- when Herb::Template::NodeField -%>
+  <%- if field.specific_kind -%>
+  <%= field.name %>: Serialized<%= field.specific_kind %> | null;
+  <%- else -%>
+  <%= field.name %>: SerializedNode | null;
+  <%- end -%>
+  <%- when Herb::Template::ArrayField -%>
+  <%= field.name %>: SerializedNode[];
+  <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
+  // no-op for <%= field.name %>
+  <%- else -%>
+  <% raise "Unhandled class #{field.class}" %>
+  <%- end -%>
+  <%- end -%>
+}
+
+export interface <%= node.name %>Props extends BaseNodeProps {
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  <%= field.name %>: string;
+  <%- when Herb::Template::TokenField -%>
+  <%= field.name %>: Token | null;
+  <%- when Herb::Template::BooleanField -%>
+  <%= field.name %>: boolean;
+  <%- when Herb::Template::ElementSourceField -%>
+  <%= field.name %>: string;
+  <%- when Herb::Template::NodeField -%>
+  <%- if field.specific_kind -%>
+  <%= field.name %>: <%= field.specific_kind %> | null;
+  <%- else -%>
+  <%= field.name %>: Node | null;
+  <%- end -%>
+  <%- when Herb::Template::ArrayField -%>
+  <%- if field.specific_kind == "Node" -%>
+  <%= field.name %>: Node[];
+  <%- else -%>
+  <%= field.name %>: any[];
+  <%- end -%>
+  <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
+  // no-op for <%= field.name %>
+  <%- else -%>
+  <% raise "Unhandled class #{field.class}" %>
+  <%- end -%>
+  <%- end -%>
+}
+
+export class <%= node.name %> extends Node {
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  readonly <%= field.name %>: string;
+  <%- when Herb::Template::TokenField -%>
+  readonly <%= field.name %>: Token | null;
+  <%- when Herb::Template::BooleanField -%>
+  readonly <%= field.name %>: boolean;
+  <%- when Herb::Template::ElementSourceField -%>
+  readonly <%= field.name %>: string;
+  <%- when Herb::Template::NodeField -%>
+  <%- if field.specific_kind -%>
+  readonly <%= field.name %>: <%= field.specific_kind %> | null;
+  <%- else -%>
+  readonly <%= field.name %>: Node | null;
+  <%- end -%>
+  <%- when Herb::Template::ArrayField -%>
+  <%- if field.specific_kind == "Node" -%>
+  readonly <%= field.name %>: Node[];
+  <%- else -%>
+  readonly <%= field.name %>: Node[];
+  <%- end -%>
+  <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
+  // no-op for <%= field.name %>
+  <%- else -%>
+  <% raise "Unhandled class #{field.class}" %>
+  <%- end -%>
+  <%- end -%>
+
+  static get type(): NodeType {
+    return "<%= node.type %>"
+  }
+
+  static from(data: Serialized<%= node.name %>): <%= node.name %> {
+    return new <%= node.name %>({
+      type: data.type,
+      location: Location.from(data.location),
+      errors: (data.errors || []).map(error => HerbError.from(error)),
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::StringField -%>
+      <%= field.name %>: data.<%= field.name %>,
+      <%- when Herb::Template::TokenField -%>
+      <%= field.name %>: data.<%= field.name %> ? Token.from(data.<%= field.name %>) : null,
+      <%- when Herb::Template::BooleanField -%>
+      <%= field.name %>: data.<%= field.name %>,
+      <%- when Herb::Template::ElementSourceField -%>
+      <%= field.name %>: data.<%= field.name %>,
+      <%- when Herb::Template::NodeField -%>
+      <%= field.name %>: data.<%= field.name %> ? fromSerializedNode((data.<%= field.name %>)) : null,
+      <%- when Herb::Template::ArrayField -%>
+      <%= field.name %>: (data.<%= field.name %> || []).map(node => fromSerializedNode(node)),
+      <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
+      // no-op for <%= field.name %>
+      <%- else -%>
+      <% raise "Unhandled class #{field.class}" %>
+      <%- end -%>
+      <%- end -%>
+    })
+  }
+
+  constructor(props: <%= node.name %>Props) {
+    super(props.type, props.location, props.errors);
+    <%- node.fields.each do |field| -%>
+    <%- case field -%>
+    <%- when Herb::Template::ArrayField -%>
+    this.<%= field.name %> = props.<%= field.name %>;
+    <%- when Herb::Template::TokenField -%>
+    this.<%= field.name %> = props.<%= field.name %>;
+    <%- when Herb::Template::NodeField -%>
+    this.<%= field.name %> = props.<%= field.name %>;
+    <%- when Herb::Template::StringField -%>
+    this.<%= field.name %> = convertToUTF8(props.<%= field.name %>);
+    <%- when Herb::Template::BooleanField -%>
+    this.<%= field.name %> = props.<%= field.name %>;
+    <%- when Herb::Template::ElementSourceField -%>
+    this.<%= field.name %> = props.<%= field.name %>;
+    <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
+    // no-op for <%= field.name %>
+    <%- else -%>
+    <% raise "Unhandled class #{field.class}" %>
+    <%- end -%>
+    <%- end -%>
+  }
+
+  accept(visitor: Visitor): void {
+    visitor.visit<%= node.name %>(this)
+  }
+
+  childNodes(): (Node | null | undefined)[] {
+    return [
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::NodeField -%>
+      this.<%= field.name %>,
+      <%- when Herb::Template::ArrayField -%>
+      ...this.<%= field.name %>,
+      <%- end -%>
+      <%- end -%>
+    ];
+  }
+
+  compactChildNodes(): Node[] {
+    return this.childNodes().filter(node => node !== null && node !== undefined)
+  }
+
+  recursiveErrors(): HerbError[] {
+    return [
+      ...this.errors,
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::NodeField -%>
+      this.<%= field.name %> ? this.<%= field.name %>.recursiveErrors() : [],
+      <%- when Herb::Template::ArrayField -%>
+      ...this.<%= field.name %>.map(node => node.recursiveErrors()),
+      <%- end -%>
+      <%- end -%>
+    ].flat();
+  }
+
+  toJSON(): Serialized<%= node.name %> {
+    return {
+      ...super.toJSON(),
+      type: "<%= node.type %>",
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::StringField -%>
+      <%= field.name %>: this.<%= field.name %>,
+      <%- when Herb::Template::TokenField -%>
+      <%= field.name %>: this.<%= field.name %> ? this.<%= field.name %>.toJSON() : null,
+      <%- when Herb::Template::BooleanField -%>
+      <%= field.name %>: this.<%= field.name %>,
+      <%- when Herb::Template::ElementSourceField -%>
+      <%= field.name %>: this.<%= field.name %>,
+      <%- when Herb::Template::NodeField -%>
+      <%= field.name %>: this.<%= field.name %> ? this.<%= field.name %>.toJSON() : null,
+      <%- when Herb::Template::ArrayField -%>
+      <%= field.name %>: this.<%= field.name %>.map(node => node.toJSON()),
+      <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
+      // no-op for <%= field.name %>
+      <%- else -%>
+      <% raise "Unhandled class #{field.class}" %>
+      <%- end -%>
+      <%- end -%>
+    };
+  }
+
+  treeInspect(): string {
+    let output = "";
+
+    output += `@ <%= node.name %> ${this.location.treeInspectWithLabel()}\n`;
+    output += `├── errors: ${this.inspectArray(this.errors, "<%= node.fields.any? ? "│   " : "    " %>")}`;
+    <%- node.fields.each do |field| -%>
+    <%- symbol = node.fields.last == field ? "└──" : "├──" -%>
+    <%- name = "#{symbol} #{field.name}: " -%>
+    <%- case field -%>
+    <%- when Herb::Template::StringField -%>
+    output += `<%= name %>${this.<%= field.name %> ? JSON.stringify(this.<%= field.name %>) : "∅"}\n`;
+    <%- when Herb::Template::TokenField -%>
+    output += `<%= name %>${this.<%= field.name %> ? this.<%= field.name %>.treeInspect() : "∅"}\n`;
+    <%- when Herb::Template::BooleanField -%>
+    output += `<%= name %>${typeof this.<%= field.name %> === 'boolean' ? String(this.<%= field.name %>) : "∅"}\n`;
+    <%- when Herb::Template::ElementSourceField -%>
+    output += `<%= name %>${this.<%= field.name %> ? JSON.stringify(this.<%= field.name %>) : "∅"}\n`;
+    <%- when Herb::Template::NodeField -%>
+    output += `<%= name %>${this.inspectNode(this.<%= field.name %>, "<%= (node.fields.last == field) ? "    " : "│   " %>")}`;
+    <%- when Herb::Template::ArrayField -%>
+    output += `<%= name %>${this.inspectArray(this.<%= field.name %>, "<%= (node.fields.last == field) ? "    " : "│   " %>")}`;
+    <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
+    // no-op for <%= field.name %>
+    <%- else -%>
+    <% raise "Unhandled class #{field.class}" %>
+    <%- end -%>
+    <%- end -%>
+
+    return output
+  }
+}
+
+<%- end -%>
+
+export type ConcreteNode =
+<%- nodes.each do |node| -%>
+  <%= node.name %><%- if nodes.last != node -%> |<%- end -%>
+<%- end -%>
+
+<%- nodes.each do |node| -%>
+export function fromSerializedNode(node: Serialized<%= node.name %>): <%= node.name %>;
+<%- end -%>
+export function fromSerializedNode(node: SerializedNode): Node;
+
+export function fromSerializedNode(node: SerializedNode): Node {
+  switch (node.type) {
+    <%- nodes.each do |node| -%>
+    case "<%= node.type %>": return <%= node.name %>.from(node as Serialized<%= node.name %>);
+    <%- end -%>
+
+    default:
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}
+
+export type NodeType =
+  <%- nodes.each_with_index.map do |node, index| -%>
+  | "<%= node.type %>"
+  <%- end -%>
+
+export type ERBNodeType = Extract<NodeType, `AST_ERB_${string}`>;
+
+export type ERBNode =
+  <%- nodes.each_with_index.map do |node, index| -%>
+    <%- next unless node.name.start_with?("ERB") -%>
+  | <%= node.name %>
+  <%- end -%>
+
+export const ERBNodeClasses = [
+  <%- nodes.each_with_index.map do |node, index| -%>
+  <%- next unless node.name.start_with?("ERB") -%>
+  <%= node.name %>,
+  <%- end -%>
+]

data/templates/javascript/packages/core/src/visitor.ts.erb

@@ -0,0 +1,29 @@
+import {
+  Node,
+  <%- nodes.each do |node| -%>
+  <%= node.name %>,
+  <%- end -%>
+} from "./nodes.js"
+
+export class Visitor {
+  visit(node: Node | null | undefined): void {
+    if (!node) return
+
+    node.accept(this)
+  }
+
+  visitAll(nodes: (Node | null | undefined)[]): void {
+    nodes.forEach(node => node?.accept(this))
+  }
+
+  visitChildNodes(node: Node): void {
+    node.compactChildNodes().forEach(node => node.accept(this))
+  }
+
+  <%- nodes.each do |node| -%>
+  visit<%= node.name %>(node: <%= node.name %>): void {
+    this.visitChildNodes(node)
+  }
+
+  <%- end -%>
+}

data/templates/javascript/packages/node/extension/error_helpers.cpp.erb

@@ -0,0 +1,113 @@
+#include <node_api.h>
+#include "error_helpers.h"
+#include "extension_helpers.h"
+#include "nodes.h"
+
+extern "C" {
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/array.h"
+#include "../extension/libherb/include/errors.h"
+#include "../extension/libherb/include/ast_node.h"
+#include "../extension/libherb/include/ast_nodes.h"
+}
+
+napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
+napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+
+<%- errors.each do |error| -%>
+napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>) {
+  if (!<%= error.human %>) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateString(env, error_type_to_string(&<%= error.human %>->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateString(env, <%= error.human %>->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, <%= error.human %>->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  napi_value <%= field.name %> = CreateString(env, <%= error.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::NodeField -%>
+  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= error.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::TokenField -%>
+  napi_value <%= field.name %> = CreateToken(env, <%= error.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::TokenTypeField -%>
+  napi_value <%= field.name %> = CreateString(env, token_type_to_string(<%= error.human %>-><%= field.name %>));
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::BooleanField -%>
+  napi_value <%= field.name %>;
+  napi_get_boolean(env, <%= error.human %>-><%= field.name %>, &<%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::ArrayField -%>
+  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= error.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- else -%>
+  napi_value <%= field.name %>;
+  napi_get_null(env, &<%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- end -%>
+  <%- end -%>
+
+  return result;
+}
+
+<%- end -%>
+
+napi_value ErrorsArrayFromCArray(napi_env env, array_T* array) {
+  napi_value result;
+  napi_create_array(env, &result);
+
+  if (array) {
+    for (size_t i = 0; i < array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*) array_get(array, i);
+      if (error) {
+        napi_value js_error = ErrorFromCStruct(env, error);
+        napi_set_element(env, result, i, js_error);
+      }
+    }
+  }
+
+  return result;
+}
+
+napi_value ErrorFromCStruct(napi_env env, ERROR_T* error) {
+  if (!error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  switch (error->type) {
+  <%- errors.each do |error| -%>
+    case <%= error.type %>:
+      return <%= error.name %>FromCStruct(env, (<%= error.struct_type %>*) error);
+      break;
+  <%- end -%>
+    default:
+      napi_value null_value;
+      napi_get_null(env, &null_value);
+      return null_value;
+  }
+}

data/templates/javascript/packages/node/extension/error_helpers.h.erb

@@ -0,0 +1,17 @@
+#ifndef HERB_EXTENSION_ERRORS_H
+#define HERB_EXTENSION_ERRORS_H
+
+#include <node_api.h>
+
+extern "C" {
+#include "../extension/libherb/include/herb.h"
+}
+
+napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
+napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+
+<%- errors.each do |error| -%>
+napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>);
+<%- end -%>
+
+#endif

data/templates/javascript/packages/node/extension/nodes.cpp.erb

@@ -0,0 +1,111 @@
+#include <node_api.h>
+#include "error_helpers.h"
+#include "extension_helpers.h"
+#include "nodes.h"
+
+extern "C" {
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/array.h"
+#include "../extension/libherb/include/ast_node.h"
+#include "../extension/libherb/include/ast_nodes.h"
+}
+
+napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
+napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+
+<%- nodes.each do |node| -%>
+napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>) {
+  if (!<%= node.human %>) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateString(env, ast_node_type_to_string(&<%= node.human %>->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value location = CreateLocation(env, <%= node.human %>->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value errors = ErrorsArrayFromCArray(env, <%= node.human %>->base.errors);
+  napi_set_named_property(env, result, "errors", errors);
+
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  napi_value <%= field.name %> = CreateString(env, <%= node.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::NodeField -%>
+  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::TokenField -%>
+  napi_value <%= field.name %> = CreateToken(env, <%= node.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::BooleanField -%>
+  napi_value <%= field.name %>;
+  napi_get_boolean(env, <%= node.human %>-><%= field.name %>, &<%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::ArrayField -%>
+  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= node.human %>-><%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- when Herb::Template::ElementSourceField -%>
+  napi_value <%= field.name %> = CreateString(env, element_source_to_string(<%= node.human %>-><%= field.name %>));
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- else -%>
+  napi_value <%= field.name %>;
+  napi_get_null(env, &<%= field.name %>);
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
+  <%- end -%>
+  <%- end -%>
+
+  return result;
+}
+<%- end -%>
+
+napi_value NodesArrayFromCArray(napi_env env, array_T* array) {
+  napi_value result;
+  napi_create_array(env, &result);
+
+  if (array) {
+    for (size_t i = 0; i < array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+      if (child_node) {
+        napi_value js_child = NodeFromCStruct(env, child_node);
+        napi_set_element(env, result, i, js_child);
+      }
+    }
+  }
+
+  return result;
+}
+
+napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node) {
+  if (!node) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  switch (node->type) {
+  <%- nodes.each do |node| -%>
+    case <%= node.type %>:
+      return <%= node.human %>NodeFromCStruct(env, (<%= node.struct_type %>*) node);
+      break;
+  <%- end -%>
+    default:
+      napi_value null_value;
+      napi_get_null(env, &null_value);
+      return null_value;
+  }
+}