herb 0.11.1 → 0.11.2

data/vendor/prism/templates/java/{org → api/src/main/java-templates/org/ruby_lang}/prism/Nodes.java.erb

@@ -1,5 +1,5 @@
-<%- string_type = Prism::Template::JAVA_STRING_TYPE -%>
-package org.prism;
+<%- id_type = Prism::Template::JAVA_IDENTIFIER_TYPE -%>
+package org.ruby_lang.prism;
 
 import java.lang.Override;
 import java.lang.String;
@@ -8,7 +8,6 @@ import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
 
@@ -16,7 +15,7 @@ import java.util.Arrays;
 // @formatter:off
 public abstract class Nodes {
 
-    public static final <%= string_type %>[] EMPTY_STRING_ARRAY = {};
+    public static final <%= id_type %>[] EMPTY_IDENTIFIER_ARRAY = {};
 
     @Target(ElementType.FIELD)
     @Retention(RetentionPolicy.SOURCE)
@@ -47,12 +46,10 @@ public abstract class Nodes {
     }
 
     public static final class Source {
-        public final byte[] bytes;
         private int startLine = 1;
         private int[] lineOffsets = null;
 
-        Source(byte[] bytes) {
-          this.bytes = bytes;
+        Source() {
         }
 
         void setStartLine(int startLine) {
@@ -70,7 +67,6 @@ public abstract class Nodes {
 
         // 0-based
         public int findLine(int byteOffset) {
-            if (byteOffset >= bytes.length) byteOffset = bytes.length - 1;
             assert byteOffset >= 0 : byteOffset;
             int index = Arrays.binarySearch(lineOffsets, byteOffset);
             int line;
@@ -142,7 +138,23 @@ public abstract class Nodes {
 
         protected abstract String toString(String indent);
     }
-<%# FLAGS -%>
+
+    protected static String asString(Object value) {
+        return value.toString();
+    }
+
+    protected static String asString(byte[] value) {
+        StringBuilder buf = new StringBuilder(value.length);
+        for (byte b : value) {
+            if (b >= 0x20 && b <= 0x7e) {
+                buf.append((char) b);
+            } else {
+                buf.append(String.format("\\x%02x", Byte.toUnsignedInt(b)));
+            }
+        }
+        return buf.toString();
+    }
+<%-# FLAGS -%>
     <%- flags.each do |flag| -%>
 
     /**
@@ -194,7 +206,7 @@ public abstract class Nodes {
         <%- end -%>
     }
 <%- end -%>
-<%# NODES -%>
+<%-# NODES -%>
     <%- nodes.each do |node| -%>
 
     /**
@@ -205,8 +217,11 @@ public abstract class Nodes {
      * </pre>
      */
     public static final class <%= node.name -%> extends Node {
-        <%- if node.needs_serialized_length? -%>
-        public final int serializedLength;
+        <%- if node.lazy_field -%>
+        /** The position of the lazy marker in the serialized output, if this node is lazy. */
+        public final int lazyPosition;
+        /** The loader that loaded this node, if this node is lazy. */
+        public final Loader loader;
         <%- end -%>
         <%- if node.flags -%>
         public final short flags;
@@ -234,7 +249,10 @@ public abstract class Nodes {
           params = []
           params << "int nodeId" if Prism::Template::INCLUDE_NODE_ID
           params << "int startOffset" << "int length"
-          params << "int serializedLength" if node.needs_serialized_length?
+          if node.lazy_field
+            params << "int lazyPosition"
+            params << "Loader loader"
+          end
           params << "short flags" if node.flags
           params.concat(node.semantic_fields.map { |field| "#{field.java_type} #{field.name}" })
         -%>
@@ -244,8 +262,9 @@ public abstract class Nodes {
         <%- else -%>
             super(startOffset, length);
         <%- end -%>
-        <%- if node.needs_serialized_length? -%>
-            this.serializedLength = serializedLength;
+        <%- if node.lazy_field -%>
+            this.lazyPosition = lazyPosition;
+            this.loader = loader;
         <%- end -%>
         <%- if node.flags -%>
             this.flags = flags;
@@ -254,7 +273,22 @@ public abstract class Nodes {
             this.<%= field.name %> = <%= field.name %>;
         <%- end -%>
         }
-        <%# methods for flags -%>
+        <%-# extra methods for DefNode -%>
+        <%- if node.lazy_field -%>
+
+        public boolean isLazy() {
+            return loader != null;
+        }
+
+        public <%= node.name -%> getNonLazy() {
+            if (isLazy()) {
+                return loader.loadNonLazy<%= node.name %>(lazyPosition);
+            } else {
+                return this;
+            }
+        }
+        <%- end -%>
+        <%-# methods for flags -%>
         <%- if (node_flags = node.flags) -%>
         <%- node_flags.values.each do |value| -%>
 
@@ -263,7 +297,7 @@ public abstract class Nodes {
         }
         <%- end -%>
         <%- end -%>
-        <%# potential override of setNewLineFlag() -%>
+        <%-# potential override of setNewLineFlag() -%>
         <%- if node.newline == false -%>
 
         @Override
@@ -288,6 +322,7 @@ public abstract class Nodes {
         }
         <%- end -%>
 
+        @Override
         public <T> void visitChildNodes(AbstractNodeVisitor<T> visitor) {
           <%- node.semantic_fields.each do |field| -%>
             <%- case field -%>
@@ -305,6 +340,7 @@ public abstract class Nodes {
           <%- end -%>
         }
 
+        @Override
         public Node[] childNodes() {
           <%- if node.semantic_fields.none?(Prism::Template::NodeListField) and node.semantic_fields.none?(Prism::Template::NodeKindField) -%>
             return EMPTY_ARRAY;
@@ -326,6 +362,7 @@ public abstract class Nodes {
           <%- end -%>
         }
 
+        @Override
         public <T> T accept(AbstractNodeVisitor<T> visitor) {
             return visitor.visit<%= node.name -%>(this);
         }
@@ -338,11 +375,13 @@ public abstract class Nodes {
                 builder.append("[Li]");
             }
             builder.append('\n');
+            <%- unless [*node.flags, *node.semantic_fields].empty? -%>
             String nextIndent = indent + "  ";
+            <%- end -%>
             <%- if node.fields.any?(Prism::Template::NodeListField) or node.fields.any?(Prism::Template::ConstantListField) -%>
             String nextNextIndent = nextIndent + "  ";
             <%- end -%>
-            <%- [*node.flags, *node.fields.grep_v(Prism::Template::LocationField).grep_v(Prism::Template::OptionalLocationField)].each do |field| -%>
+            <%- [*node.flags, *node.semantic_fields].each do |field| -%>
             builder.append(nextIndent);
             builder.append("<%= field.name %>: ");
             <%- case field -%>
@@ -356,18 +395,18 @@ public abstract class Nodes {
                 builder.append(nextNextIndent).append(child.toString(nextNextIndent));
             }
             <%- when Prism::Template::StringField -%>
-            builder.append('"' + new String(this.<%= field.name %>, StandardCharsets.UTF_8) + '"');
+            builder.append('"' + asString(this.<%= field.name %>) + '"');
             builder.append('\n');
             <%- when Prism::Template::ConstantField -%>
-            builder.append('"').append(this.<%= field.name %>).append('"');
+            builder.append('"').append(asString(this.<%= field.name %>)).append('"');
             builder.append('\n');
             <%- when Prism::Template::OptionalConstantField -%>
-            builder.append(this.<%= field.name %> == null ? "null" : "\"" + this.<%= field.name %> + "\"");
+            builder.append(this.<%= field.name %> == null ? "null" : "\"" + asString(this.<%= field.name %>) + "\"");
             builder.append('\n');
             <%- when Prism::Template::ConstantListField -%>
             builder.append('\n');
-            for (<%= string_type %> constant : this.<%= field.name %>) {
-                builder.append(nextNextIndent).append('"').append(constant).append('"').append('\n');
+            for (<%= id_type %> constant : this.<%= field.name %>) {
+                builder.append(nextNextIndent).append('"').append(asString(constant)).append('"').append('\n');
             }
             <%- when Prism::Template::Flags -%>
             builder.append(flags);

data/vendor/prism/templates/javascript/src/deserialize.js.erb

@@ -1,20 +1,23 @@
 import * as nodes from "./nodes.js";
+import { getDecoder } from "./decoding.js";
+import { Location } from "./location.js";
+import { Source } from "./source.js";
 
-const MAJOR_VERSION = 1;
-const MINOR_VERSION = 9;
+const MAJOR_VERSION = 2;
+const MINOR_VERSION = 1;
 const PATCH_VERSION = 0;
 
-// The DataView getFloat64 function takes an optional second argument that
-// specifies whether the number is little-endian or big-endian. It does not
-// appear to have a native endian mode, so we need to determine the endianness
-// of the system at runtime.
+/* The DataView getFloat64 function takes an optional second argument that
+ * specifies whether the number is little-endian or big-endian. It does not
+ * appear to have a native endian mode, so we need to determine the endianness
+ * of the system at runtime. */
 const LITTLE_ENDIAN = (() => {
   let uint32 = new Uint32Array([0x11223344]);
   let uint8 = new Uint8Array(uint32.buffer);
 
   if (uint8[0] === 0x44) {
     return true;
-  } else if (uInt8[0] === 0x11) {
+  } else if (uint8[0] === 0x11) {
     return false;
   } else {
     throw new Error("Mixed endianness");
@@ -22,19 +25,11 @@ const LITTLE_ENDIAN = (() => {
 })();
 
 class SerializationBuffer {
-  FORCED_UTF8_ENCODING_FLAG = 1 << 2;
-  FORCED_BINARY_ENCODING_FLAG = 1 << 3;
-
-  DECODER_MAP = new Map([
-    ["ascii-8bit", "ascii"]
-  ]);
-
-  constructor(source, array) {
-    this.source = source;
+  constructor(array) {
     this.array = array;
     this.index = 0;
-    this.fileEncoding = "utf-8";
-    this.decoders = new Map();
+    this.encoding = "utf-8";
+    this.source = null;
   }
 
   readByte() {
@@ -53,7 +48,7 @@ class SerializationBuffer {
     return this.decodeString(this.readBytes(length), flags).value;
   }
 
-  // Read a 32-bit unsigned integer in little-endian format.
+  /* Read a 32-bit unsigned integer in little-endian format. */
   readUint32() {
     const result = this.scanUint32(this.index);
     this.index += 4;
@@ -65,6 +60,17 @@ class SerializationBuffer {
     return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
   }
 
+  /**
+   * Read a signed integer that was written in zigzag encoding, where the low
+   * bit carries the sign. Both operators here are 32-bit, which is what makes
+   * this correct for zigzag values above 2^31, where readVarInt overflows and
+   * returns the bit pattern as a negative number.
+   */
+  readVarSInt() {
+    const value = this.readVarInt();
+    return (value >>> 1) ^ -(value & 1);
+  }
+
   readVarInt() {
     let result = 0;
     let shift = 0;
@@ -83,7 +89,9 @@ class SerializationBuffer {
   }
 
   readLocation() {
-    return { startOffset: this.readVarInt(), length: this.readVarInt() };
+    const startOffset = this.readVarInt();
+    const length = this.readVarInt();
+    return new Location(this.source, startOffset, length);
   }
 
   readOptionalLocation() {
@@ -96,32 +104,14 @@ class SerializationBuffer {
 
   readStringField(flags) {
     if (flags === undefined) flags = 0;
-    const type = this.readByte();
-
-    switch (type) {
-      case 1: {
-        const startOffset = this.readVarInt();
-        const length = this.readVarInt();
-        return this.decodeString(this.source.slice(startOffset, startOffset + length), flags);
-      }
-      case 2:
-        return this.decodeString(this.readBytes(this.readVarInt()), flags);
-      default:
-        throw new Error(`Unknown serialized string type: ${type}`);
-    }
+    return this.decodeString(this.readBytes(this.readVarInt()), flags);
   }
 
   scanConstant(constantPoolOffset, constantIndex) {
     const offset = constantPoolOffset + constantIndex * 8;
-    let startOffset = this.scanUint32(offset);
+    const startOffset = this.scanUint32(offset);
     const length = this.scanUint32(offset + 4);
-
-    if (startOffset & (1 << 31)) {
-      startOffset &= (1 << 31) - 1;
-      return new TextDecoder().decode(this.array.slice(startOffset, startOffset + length));
-    } else {
-      return new TextDecoder().decode(this.source.slice(startOffset, startOffset + length));
-    }
+    return getDecoder(this.encoding, { fatal: true }).decode(this.array.slice(startOffset, startOffset + length));
   }
 
   readDouble() {
@@ -134,67 +124,37 @@ class SerializationBuffer {
   }
 
   decodeString(bytes, flags) {
-    const forcedBin = (flags & this.FORCED_BINARY_ENCODING_FLAG) !== 0;
-    const forcedUtf8 = (flags & this.FORCED_UTF8_ENCODING_FLAG) !== 0;
-
-    if (forcedBin) {
-      // just use raw bytes
-      return {
-        encoding: "ascii",
-        validEncoding: true,
-        value: this.asciiDecoder.decode(bytes)
-      };
-    } else {
-      const encoding = forcedUtf8 ? "utf-8" : this.fileEncoding.toLowerCase();
-      const decoder = this.getDecoder(encoding);
-
-      try {
-        // decode with encoding
-        return {
-          encoding,
-          validEncoding: true,
-          value: decoder.decode(bytes)
-        };
-      } catch(e) {
-        // just use raw bytes, capture what the encoding should be, set flag saying encoding is invalid
-        if (e.code === "ERR_ENCODING_INVALID_ENCODED_DATA") {
-          return {
-            encoding,
-            validEncoding: false,
-            value: this.asciiDecoder.decode(bytes)
-          };
-        }
-
-        throw e;
-      }
-    }
-  }
-
-  getDecoder(encoding) {
-    encoding = this.DECODER_MAP.get(encoding) || encoding;
+    let value, encoding, validEncoding;
 
-    if (!this.decoders.has(encoding)) {
-      this.decoders.set(encoding, new TextDecoder(encoding, {fatal: true}));
+    if ((flags & nodes.StringFlags.FORCED_BINARY_ENCODING) !== 0) {
+      encoding = "ascii-8bit";
+    } else if ((flags & nodes.StringFlags.FORCED_UTF8_ENCODING) !== 0) {
+      encoding = "utf-8";
+    } else {
+      encoding = this.encoding.toLowerCase();
     }
 
-    return this.decoders.get(encoding);
-  }
-
-  get asciiDecoder() {
-    if (!this._asciiDecoder) {
-      this._asciiDecoder = new TextDecoder("ascii");
+    const decoder = getDecoder(encoding, { fatal: true });
+
+    try {
+      value = decoder.decode(bytes);
+      validEncoding = true;
+    } catch (error) {
+      /* A fatal decoder reports bytes that are not valid in its encoding by
+       * throwing a TypeError, and that is the whole of what it throws, so the
+       * string is read back as binary and flagged. */
+      if (error instanceof TypeError) {
+        value = getDecoder("ascii-8bit").decode(bytes);
+        validEncoding = false;
+      } else {
+        throw error;
+      }
     }
 
-    return this._asciiDecoder;
+    return { value, encoding, validEncoding };
   }
 }
 
-/**
- * A location in the source code.
- *
- * @typedef {{ startOffset: number, length: number }} Location
- */
-
 /**
  * A comment in the source code.
  *
@@ -247,6 +207,7 @@ export class ParseResult {
   /**
    * @type {Location | null}
    */
+  dataLoc;
 
   /**
    * @type {ParseError[]}
@@ -258,20 +219,28 @@ export class ParseResult {
    */
   warnings;
 
+  /**
+   * @type {boolean}
+   */
+  continuable;
+
   /**
    * @param {nodes.ProgramNode} value
    * @param {Comment[]} comments
    * @param {MagicComment[]} magicComments
+   * @param {Location | null} dataLoc
    * @param {ParseError[]} errors
    * @param {ParseWarning[]} warnings
+   * @param {boolean} continuable
    */
-  constructor(value, comments, magicComments, dataLoc, errors, warnings) {
+  constructor(value, comments, magicComments, dataLoc, errors, warnings, continuable) {
     this.value = value;
     this.comments = comments;
     this.magicComments = magicComments;
     this.dataLoc = dataLoc;
     this.errors = errors;
     this.warnings = warnings;
+    this.continuable = continuable;
   }
 }
 
@@ -299,7 +268,7 @@ const warningTypes = [
  * @throws {Error}
  */
 export function deserialize(source, array) {
-  const buffer = new SerializationBuffer(source, array);
+  const buffer = new SerializationBuffer(array);
 
   if (buffer.readString(5) !== "PRISM") {
     throw new Error("Invalid serialization");
@@ -314,24 +283,34 @@ export function deserialize(source, array) {
   }
 
   // Read the file's encoding.
-  buffer.fileEncoding = buffer.readString(buffer.readVarInt());
+  buffer.encoding = buffer.readString(buffer.readVarInt());
 
-  // Skip past the start line, as we don't support that option yet in
-  // JavaScript.
-  buffer.readVarInt();
+  // Read the line that the source starts on along with the byte offset of the
+  // start of each line, which together let locations resolve lines and columns.
+  const startLine = buffer.readVarSInt();
 
-  // Skip past the line offsets, as there is no Source object yet in JavaScript.
-  // const lineOffsets = Array.from({ length: buffer.readVarInt() }, () => buffer.readVarInt());
-  const lineOffsetsCount = buffer.readVarInt();
-  for (let i = 0; i < lineOffsetsCount; i ++) {
-    buffer.readVarInt();
-  }
+  // Skip the 8-byte hash of the source, which this library does not expose.
+  buffer.readBytes(8);
+
+  const lineOffsets = Array.from({ length: buffer.readVarInt() }, () => buffer.readVarInt());
+
+  buffer.source = new Source(source, buffer.encoding, startLine, lineOffsets);
 
   const comments = Array.from({ length: buffer.readVarInt() }, () => ({
     type: buffer.readVarInt(),
     location: buffer.readLocation()
   }));
 
+  // Skip the comments attached to each node, which this library does not
+  // expose. Each entry is a node id followed by the indices of its comments.
+  for (let count = buffer.readVarInt(); count > 0; count--) {
+    buffer.readVarInt();
+
+    for (let length = buffer.readVarInt(); length > 0; length--) {
+      buffer.readVarInt();
+    }
+  }
+
   const magicComments = Array.from({ length: buffer.readVarInt() }, () => ({
     startLocation: buffer.readLocation(),
     endLocation: buffer.readLocation()
@@ -353,53 +332,81 @@ export function deserialize(source, array) {
     level: warningLevels[buffer.readByte()]
   }));
 
+  const continuable = buffer.readByte() !== 0;
+
   const constantPoolOffset = buffer.readUint32();
   const constants = Array.from({ length: buffer.readVarInt() }, () => null);
 
-  return new ParseResult(readRequiredNode(), comments, magicComments, dataLoc, errors, warnings);
-
-  function readRequiredNode() {
-    const type = buffer.readByte();
-    const nodeID = buffer.readVarInt();
-    const location = buffer.readLocation();
-    let flags;
-
-    switch (type) {
-      <%- nodes.each.with_index(1) do |node, index| -%>
-      case <%= index %>:
-        <%- if node.needs_serialized_length? -%>
-        buffer.readUint32();
+  return new ParseResult(readNodes(constantPoolOffset), comments, magicComments, dataLoc, errors, warnings, continuable);
+
+  /* Read the nodes that are serialized before the given offset and return the
+   * root. Nodes are serialized in post-order, so the children of each node are
+   * the topmost values on the stack, in field order, by the time its record is
+   * read. */
+  function readNodes(finish) {
+    const stack = [];
+
+    while (buffer.index < finish) {
+      const type = buffer.readByte();
+
+      switch (type) {
+        case 0:
+          stack.push(null);
+          break;
+        case <%= Prism::Template::LAZY_MARKER %>:
+          buffer.readUint32();
+          buffer.readUint32();
+          break;
+        <%- local = ->(field) { field.name == "arguments" ? "arguments_" : field.name.gsub(/_([a-z])/) { $1.upcase } } -%>
+        <%- nodes.each.with_index(1) do |node, index| -%>
+        case <%= index %>: {
+          const nodeID = buffer.readVarInt();
+          const location = buffer.readLocation();
+          const flags = buffer.readVarInt();
+          <%- node.fields.each do |field| -%>
+          <%- case field -%>
+          <%- when Prism::Template::NodeField, Prism::Template::OptionalNodeField -%>
+          <%- when Prism::Template::NodeListField -%>
+          const <%= local[field] %>Size = buffer.readVarInt();
+          <%- else -%>
+          const <%= local[field] %> = <%=
+            case field
+            when Prism::Template::StringField then "buffer.readStringField(flags)"
+            when Prism::Template::ConstantField then "readRequiredConstant()"
+            when Prism::Template::OptionalConstantField then "readOptionalConstant()"
+            when Prism::Template::ConstantListField then "Array.from({ length: buffer.readVarInt() }, readRequiredConstant)"
+            when Prism::Template::LocationField then "buffer.readLocation()"
+            when Prism::Template::OptionalLocationField then "buffer.readOptionalLocation()"
+            when Prism::Template::UInt8Field then "buffer.readByte()"
+            when Prism::Template::UInt32Field then "buffer.readVarInt()"
+            when Prism::Template::IntegerField then "readInteger()"
+            when Prism::Template::DoubleField then "buffer.readDouble()"
+            else raise
+            end
+          %>;
+          <%- end -%>
+          <%- end -%>
+          <%- node.child_fields.reverse_each do |field| -%>
+          <%- if field.is_a?(Prism::Template::NodeListField) -%>
+          const <%= local[field] %> = stack.splice(stack.length - <%= local[field] %>Size, <%= local[field] %>Size);
+          <%- else -%>
+          const <%= local[field] %> = stack.pop();
+          <%- end -%>
+          <%- end -%>
+          stack.push(new nodes.<%= node.name %>(<%= ["nodeID", "location", "flags", *node.fields.map { |field| local[field] }].join(", ") %>));
+          break;
+        }
         <%- end -%>
-        return new nodes.<%= node.name %>(<%= ["nodeID", "location", "flags = buffer.readVarInt()", *node.fields.map { |field|
-          case field
-          when Prism::Template::NodeField then "readRequiredNode()"
-          when Prism::Template::OptionalNodeField then "readOptionalNode()"
-          when Prism::Template::StringField then "buffer.readStringField(flags)"
-          when Prism::Template::NodeListField then "Array.from({ length: buffer.readVarInt() }, readRequiredNode)"
-          when Prism::Template::ConstantField then "readRequiredConstant()"
-          when Prism::Template::OptionalConstantField then "readOptionalConstant()"
-          when Prism::Template::ConstantListField then "Array.from({ length: buffer.readVarInt() }, readRequiredConstant)"
-          when Prism::Template::LocationField then "buffer.readLocation()"
-          when Prism::Template::OptionalLocationField then "buffer.readOptionalLocation()"
-          when Prism::Template::UInt8Field then "buffer.readByte()"
-          when Prism::Template::UInt32Field then "buffer.readVarInt()"
-          when Prism::Template::IntegerField then "readInteger()"
-          when Prism::Template::DoubleField then "buffer.readDouble()"
-          end
-        }].join(", ") -%>);
-      <%- end -%>
-      default:
-        throw new Error(`Unknown node type: ${type}`);
+        default:
+          throw new Error(`Unknown node type: ${type}`);
+      }
     }
-  }
 
-  function readOptionalNode() {
-    if (buffer.readByte() != 0) {
-      buffer.index -= 1;
-      return readRequiredNode();
-    } else {
-      return null;
+    if (buffer.index !== finish || stack.length !== 1) {
+      throw new Error("Expected the serialized nodes to end at the constant pool with exactly one root");
     }
+
+    return stack[0];
   }
 
   function scanConstant(constantIndex) {

data/vendor/prism/templates/javascript/src/nodes.js.erb

@@ -24,6 +24,7 @@ def jstype(field)
   end
 end
 -%>
+import { Location } from "./location.js"
 import * as visitors from "./visitor.js"
 
 <%- flags.each do |flag| -%>
@@ -31,19 +32,13 @@ import * as visitors from "./visitor.js"
 /**
  * <%= flag.comment %>
  */
-const <%= flag.name %> = {
+export const <%= flag.name %> = {
 <%- flag.values.each_with_index do |value, index| -%>
   <%= value.name %>: 1 << <%= index + Prism::Template::COMMON_FLAGS_COUNT %>,
 <%- end -%>
 };
 <%- end -%>
 
-/**
- * A location in the source code.
- *
- * @typedef {{ startOffset: number, length: number }} Location
- */
-
 /**
  * An encoded Ruby string.
  *
@@ -137,7 +132,7 @@ export class <%= node.name -%> {
     when Prism::Template::NodeField, Prism::Template::OptionalNodeField then "this.#{prop(field)}"
     when Prism::Template::NodeListField then "...this.#{prop(field)}"
     end
-    }.compact.join(", ") %>]
+    }.compact.join(", ") %>];
   }
 
   /**
@@ -159,7 +154,7 @@ export class <%= node.name -%> {
       compact.push(this.<%= prop(field) %>);
     }
     <%- when Prism::Template::NodeListField -%>
-    compact.concat(this.<%= prop(field) %>);
+    compact.push(...this.<%= prop(field) %>);
     <%- end -%>
     <%- end -%>