prism 0.15.0 → 0.16.0

data/ext/prism/extension.c

@@ -396,6 +396,24 @@ parse_input(pm_string_t *input, const char *filepath) {
     return result;
 }
 
+// Parse the given input and return an array of Comment objects.
+static VALUE
+parse_input_comments(pm_string_t *input, const char *filepath) {
+    pm_parser_t parser;
+    pm_parser_init(&parser, pm_string_source(input), pm_string_length(input), filepath);
+
+    pm_node_t *node = pm_parse(&parser);
+    rb_encoding *encoding = rb_enc_find(parser.encoding.name);
+
+    VALUE source = pm_source_new(&parser, encoding);
+    VALUE comments = parser_comments(&parser, source);
+
+    pm_node_destroy(&parser, node);
+    pm_parser_free(&parser);
+
+    return comments;
+}
+
 // Parse the given string and return a ParseResult instance.
 static VALUE
 parse(int argc, VALUE *argv, VALUE self) {
@@ -436,6 +454,33 @@ parse_file(VALUE self, VALUE filepath) {
     return value;
 }
 
+// Parse the given string and return an array of Comment objects.
+static VALUE
+parse_comments(int argc, VALUE *argv, VALUE self) {
+    VALUE string;
+    VALUE filepath;
+    rb_scan_args(argc, argv, "11", &string, &filepath);
+
+    pm_string_t input;
+    input_load_string(&input, string);
+
+    return parse_input_comments(&input, check_string(filepath));
+}
+
+// Parse the given file and return an array of Comment objects.
+static VALUE
+parse_file_comments(VALUE self, VALUE filepath) {
+    pm_string_t input;
+
+    const char *checked = check_string(filepath);
+    if (!pm_string_mapped_init(&input, checked)) return Qnil;
+
+    VALUE value = parse_input_comments(&input, checked);
+    pm_string_free(&input);
+
+    return value;
+}
+
 // Parse the given string and return a ParseResult instance.
 static VALUE
 parse_lex(int argc, VALUE *argv, VALUE self) {
@@ -554,6 +599,31 @@ parse_serialize_file_metadata(VALUE self, VALUE filepath, VALUE metadata) {
     return result;
 }
 
+// Inspect the AST that represents the given source using the prism pretty print
+// as opposed to the Ruby implementation.
+static VALUE
+inspect_node(VALUE self, VALUE source) {
+    pm_string_t input;
+    input_load_string(&input, source);
+
+    pm_parser_t parser;
+    pm_parser_init(&parser, pm_string_source(&input), pm_string_length(&input), NULL);
+
+    pm_node_t *node = pm_parse(&parser);
+    pm_buffer_t buffer = { 0 };
+
+    pm_prettyprint(&buffer, &parser, node);
+
+    rb_encoding *encoding = rb_enc_find(parser.encoding.name);
+    VALUE string = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), encoding);
+
+    pm_buffer_free(&buffer);
+    pm_node_destroy(&parser, node);
+    pm_parser_free(&parser);
+
+    return string;
+}
+
 /******************************************************************************/
 /* Initialization of the extension                                            */
 /******************************************************************************/
@@ -596,6 +666,8 @@ Init_prism(void) {
     rb_define_singleton_method(rb_cPrism, "lex_file", lex_file, 1);
     rb_define_singleton_method(rb_cPrism, "parse", parse, -1);
     rb_define_singleton_method(rb_cPrism, "parse_file", parse_file, 1);
+    rb_define_singleton_method(rb_cPrism, "parse_comments", parse_comments, -1);
+    rb_define_singleton_method(rb_cPrism, "parse_file_comments", parse_file_comments, 1);
     rb_define_singleton_method(rb_cPrism, "parse_lex", parse_lex, -1);
     rb_define_singleton_method(rb_cPrism, "parse_lex_file", parse_lex_file, 1);
 
@@ -606,6 +678,7 @@ Init_prism(void) {
     rb_define_singleton_method(rb_cPrismDebug, "memsize", memsize, 1);
     rb_define_singleton_method(rb_cPrismDebug, "profile_file", profile_file, 1);
     rb_define_singleton_method(rb_cPrismDebug, "parse_serialize_file_metadata", parse_serialize_file_metadata, 2);
+    rb_define_singleton_method(rb_cPrismDebug, "inspect_node", inspect_node, 1);
 
     // Next, initialize the other APIs.
     Init_prism_api_node();

data/ext/prism/extension.h

@@ -1,7 +1,7 @@
 #ifndef PRISM_EXT_NODE_H
 #define PRISM_EXT_NODE_H
 
-#define EXPECTED_PRISM_VERSION "0.15.0"
+#define EXPECTED_PRISM_VERSION "0.16.0"
 
 #include <ruby.h>
 #include <ruby/encoding.h>

data/include/prism/ast.h

@@ -327,32 +327,31 @@ enum pm_node_type {
     PM_RATIONAL_NODE = 116,
     PM_REDO_NODE = 117,
     PM_REGULAR_EXPRESSION_NODE = 118,
-    PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE = 119,
-    PM_REQUIRED_PARAMETER_NODE = 120,
-    PM_RESCUE_MODIFIER_NODE = 121,
-    PM_RESCUE_NODE = 122,
-    PM_REST_PARAMETER_NODE = 123,
-    PM_RETRY_NODE = 124,
-    PM_RETURN_NODE = 125,
-    PM_SELF_NODE = 126,
-    PM_SINGLETON_CLASS_NODE = 127,
-    PM_SOURCE_ENCODING_NODE = 128,
-    PM_SOURCE_FILE_NODE = 129,
-    PM_SOURCE_LINE_NODE = 130,
-    PM_SPLAT_NODE = 131,
-    PM_STATEMENTS_NODE = 132,
-    PM_STRING_CONCAT_NODE = 133,
-    PM_STRING_NODE = 134,
-    PM_SUPER_NODE = 135,
-    PM_SYMBOL_NODE = 136,
-    PM_TRUE_NODE = 137,
-    PM_UNDEF_NODE = 138,
-    PM_UNLESS_NODE = 139,
-    PM_UNTIL_NODE = 140,
-    PM_WHEN_NODE = 141,
-    PM_WHILE_NODE = 142,
-    PM_X_STRING_NODE = 143,
-    PM_YIELD_NODE = 144,
+    PM_REQUIRED_PARAMETER_NODE = 119,
+    PM_RESCUE_MODIFIER_NODE = 120,
+    PM_RESCUE_NODE = 121,
+    PM_REST_PARAMETER_NODE = 122,
+    PM_RETRY_NODE = 123,
+    PM_RETURN_NODE = 124,
+    PM_SELF_NODE = 125,
+    PM_SINGLETON_CLASS_NODE = 126,
+    PM_SOURCE_ENCODING_NODE = 127,
+    PM_SOURCE_FILE_NODE = 128,
+    PM_SOURCE_LINE_NODE = 129,
+    PM_SPLAT_NODE = 130,
+    PM_STATEMENTS_NODE = 131,
+    PM_STRING_CONCAT_NODE = 132,
+    PM_STRING_NODE = 133,
+    PM_SUPER_NODE = 134,
+    PM_SYMBOL_NODE = 135,
+    PM_TRUE_NODE = 136,
+    PM_UNDEF_NODE = 137,
+    PM_UNLESS_NODE = 138,
+    PM_UNTIL_NODE = 139,
+    PM_WHEN_NODE = 140,
+    PM_WHILE_NODE = 141,
+    PM_X_STRING_NODE = 142,
+    PM_YIELD_NODE = 143,
     PM_SCOPE_NODE
 };
 
@@ -427,6 +426,8 @@ typedef struct pm_and_node {
 // ArgumentsNode
 //
 // Type: PM_ARGUMENTS_NODE
+// Flags:
+//    PM_ARGUMENTS_NODE_FLAGS_KEYWORD_SPLAT
 typedef struct pm_arguments_node {
     pm_node_t base;
     struct pm_node_list arguments;
@@ -1065,8 +1066,8 @@ typedef struct pm_hash_node {
 typedef struct pm_hash_pattern_node {
     pm_node_t base;
     struct pm_node *constant;
-    struct pm_node_list assocs;
-    struct pm_node *kwrest;
+    struct pm_node_list elements;
+    struct pm_node *rest;
     pm_location_t opening_loc;
     pm_location_t closing_loc;
 } pm_hash_pattern_node_t;
@@ -1488,7 +1489,9 @@ typedef struct pm_module_node {
 // Type: PM_MULTI_TARGET_NODE
 typedef struct pm_multi_target_node {
     pm_node_t base;
-    struct pm_node_list targets;
+    struct pm_node_list lefts;
+    struct pm_node *rest;
+    struct pm_node_list rights;
     pm_location_t lparen_loc;
     pm_location_t rparen_loc;
 } pm_multi_target_node_t;
@@ -1498,7 +1501,9 @@ typedef struct pm_multi_target_node {
 // Type: PM_MULTI_WRITE_NODE
 typedef struct pm_multi_write_node {
     pm_node_t base;
-    struct pm_node_list targets;
+    struct pm_node_list lefts;
+    struct pm_node *rest;
+    struct pm_node_list rights;
     pm_location_t lparen_loc;
     pm_location_t rparen_loc;
     pm_location_t operator_loc;
@@ -1681,16 +1686,6 @@ typedef struct pm_regular_expression_node {
     pm_string_t unescaped;
 } pm_regular_expression_node_t;
 
-// RequiredDestructuredParameterNode
-//
-// Type: PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE
-typedef struct pm_required_destructured_parameter_node {
-    pm_node_t base;
-    struct pm_node_list parameters;
-    pm_location_t opening_loc;
-    pm_location_t closing_loc;
-} pm_required_destructured_parameter_node_t;
-
 // RequiredParameterNode
 //
 // Type: PM_REQUIRED_PARAMETER_NODE
@@ -1938,6 +1933,11 @@ typedef struct pm_yield_node {
     pm_location_t rparen_loc;
 } pm_yield_node_t;
 
+// ArgumentsNodeFlags
+typedef enum pm_arguments_node_flags {
+    PM_ARGUMENTS_NODE_FLAGS_KEYWORD_SPLAT = 1 << 0,
+} pm_arguments_node_flags_t;
+
 // CallNodeFlags
 typedef enum pm_call_node_flags {
     PM_CALL_NODE_FLAGS_SAFE_NAVIGATION = 1 << 0,

data/include/prism/defines.h

@@ -23,6 +23,15 @@
 #   endif
 #endif
 
+// PRISM_ATTRIBUTE_FORMAT
+#if defined(__GNUC__)
+#   define PRISM_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((format(printf, string_index, argument_index)))
+#elif defined(__clang__)
+#   define PRISM_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((__format__(__printf__, string_index, argument_index)))
+#else
+#   define PRISM_ATTRIBUTE_FORMAT(string_index, argument_index)
+#endif
+
 // PRISM_ATTRIBUTE_UNUSED
 #if defined(__GNUC__)
 #   define PRISM_ATTRIBUTE_UNUSED __attribute__((unused))

data/include/prism/enc/pm_encoding.h

@@ -57,6 +57,7 @@ bool pm_encoding_ascii_isupper_char(const uint8_t *b, PRISM_ATTRIBUTE_UNUSED ptr
 // the parser so they need to be internally visible.
 size_t pm_encoding_utf_8_alpha_char(const uint8_t *b, ptrdiff_t n);
 size_t pm_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n);
+bool pm_encoding_utf_8_isupper_char(const uint8_t *b, ptrdiff_t n);
 
 // This lookup table is referenced in both the UTF-8 encoding file and the
 // parser directly in order to speed up the default encoding processing.

data/include/prism/node.h

@@ -29,21 +29,4 @@ PRISM_EXPORTED_FUNCTION const char * pm_node_type_to_str(pm_node_type_t node_typ
 
 #define PM_EMPTY_NODE_LIST ((pm_node_list_t) { .nodes = NULL, .size = 0, .capacity = 0 })
 
-// ScopeNodes are helper nodes, and will never be part of the AST. We manually
-// declare them here to avoid generating them.
-typedef struct pm_scope_node {
-    pm_node_t base;
-    struct pm_scope_node *previous;
-    pm_node_t *ast_node;
-    struct pm_parameters_node *parameters;
-    pm_node_t *body;
-    pm_constant_id_list_t locals;
-    pm_parser_t *parser;
-
-    // We don't have the CRuby types ID and st_table within Prism
-    // so we use void *
-    void *constants; // ID *constants
-    void *index_lookup_table; // st_table *index_lookup_table
-} pm_scope_node_t;
-
 #endif // PRISM_NODE_H

data/include/prism/parser.h

@@ -212,6 +212,7 @@ typedef enum {
     PM_CONTEXT_EMBEXPR,        // an interpolated expression
     PM_CONTEXT_ENSURE,         // an ensure statement
     PM_CONTEXT_FOR,            // a for loop
+    PM_CONTEXT_FOR_INDEX,      // a for loop's index
     PM_CONTEXT_IF,             // an if statement
     PM_CONTEXT_LAMBDA_BRACES,  // a lambda expression with braces
     PM_CONTEXT_LAMBDA_DO_END,  // a lambda expression with do..end

data/include/prism/prettyprint.h

@@ -0,0 +1,15 @@
+#ifndef PRISM_PRETTYPRINT_H
+#define PRISM_PRETTYPRINT_H
+
+#include "prism/defines.h"
+
+#include <stdio.h>
+
+#include "prism/ast.h"
+#include "prism/parser.h"
+#include "prism/util/pm_buffer.h"
+
+// Pretty-prints the AST represented by the given node to the given buffer.
+PRISM_EXPORTED_FUNCTION void pm_prettyprint(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node);
+
+#endif

data/include/prism/util/pm_buffer.h

@@ -13,9 +13,9 @@
 // block of memory. It is used to store the serialized representation of a
 // prism tree.
 typedef struct {
-    char *value;
     size_t length;
     size_t capacity;
+    char *value;
 } pm_buffer_t;
 
 // Return the size of the pm_buffer_t struct.
@@ -36,17 +36,23 @@ PRISM_EXPORTED_FUNCTION size_t pm_buffer_length(pm_buffer_t *buffer);
 // Append the given amount of space as zeroes to the buffer.
 void pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length);
 
+// Append a formatted string to the buffer.
+void pm_buffer_append_format(pm_buffer_t *buffer, const char *format, ...) PRISM_ATTRIBUTE_FORMAT(2, 3);
+
 // Append a string to the buffer.
-void pm_buffer_append_str(pm_buffer_t *buffer, const char *value, size_t length);
+void pm_buffer_append_string(pm_buffer_t *buffer, const char *value, size_t length);
 
 // Append a list of bytes to the buffer.
 void pm_buffer_append_bytes(pm_buffer_t *buffer, const uint8_t *value, size_t length);
 
 // Append a single byte to the buffer.
-void pm_buffer_append_u8(pm_buffer_t *buffer, uint8_t value);
+void pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value);
 
 // Append a 32-bit unsigned integer to the buffer.
-void pm_buffer_append_u32(pm_buffer_t *buffer, uint32_t value);
+void pm_buffer_append_varint(pm_buffer_t *buffer, uint32_t value);
+
+// Append one buffer onto another.
+void pm_buffer_concat(pm_buffer_t *destination, const pm_buffer_t *source);
 
 // Free the memory associated with the buffer.
 PRISM_EXPORTED_FUNCTION void pm_buffer_free(pm_buffer_t *buffer);

data/include/prism/util/pm_constant_pool.h

@@ -76,7 +76,7 @@ typedef struct {
 bool pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity);
 
 // Return a pointer to the constant indicated by the given constant id.
-pm_constant_t * pm_constant_pool_id_to_constant(pm_constant_pool_t *pool, pm_constant_id_t constant_id);
+pm_constant_t * pm_constant_pool_id_to_constant(const pm_constant_pool_t *pool, pm_constant_id_t constant_id);
 
 // Insert a constant into a constant pool that is a slice of a source string.
 // Returns the id of the constant, or 0 if any potential calls to resize fail.

data/include/prism/util/pm_newline_list.h

@@ -53,7 +53,7 @@ bool pm_newline_list_check_append(pm_newline_list_t *list, const uint8_t *cursor
 // Returns the line and column of the given offset. If the offset is not in the
 // list, the line and column of the closest offset less than the given offset
 // are returned.
-pm_line_column_t pm_newline_list_line_column(pm_newline_list_t *list, const uint8_t *cursor);
+pm_line_column_t pm_newline_list_line_column(const pm_newline_list_t *list, const uint8_t *cursor);
 
 // Free the internal memory allocated for the newline list.
 void pm_newline_list_free(pm_newline_list_t *list);

data/include/prism/version.h

@@ -1,4 +1,4 @@
 #define PRISM_VERSION_MAJOR 0
-#define PRISM_VERSION_MINOR 15
+#define PRISM_VERSION_MINOR 16
 #define PRISM_VERSION_PATCH 0
-#define PRISM_VERSION "0.15.0"
+#define PRISM_VERSION "0.16.0"

data/include/prism.h

@@ -2,16 +2,17 @@
 #define PRISM_H
 
 #include "prism/defines.h"
+#include "prism/util/pm_buffer.h"
+#include "prism/util/pm_char.h"
+#include "prism/util/pm_memchr.h"
+#include "prism/util/pm_strpbrk.h"
 #include "prism/ast.h"
 #include "prism/diagnostic.h"
 #include "prism/node.h"
 #include "prism/pack.h"
 #include "prism/parser.h"
+#include "prism/prettyprint.h"
 #include "prism/regexp.h"
-#include "prism/util/pm_buffer.h"
-#include "prism/util/pm_char.h"
-#include "prism/util/pm_memchr.h"
-#include "prism/util/pm_strpbrk.h"
 #include "prism/version.h"
 
 #include <assert.h>
@@ -29,12 +30,11 @@
 
 void pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer);
 
-void pm_print_node(pm_parser_t *parser, pm_node_t *node);
+void pm_serialize_encoding(pm_encoding_t *encoding, pm_buffer_t *buffer);
 
-void pm_parser_metadata(pm_parser_t *parser, const char *metadata);
+void pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer);
 
-// Generate a scope node from the given node.
-void pm_scope_node_init(const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_t *previous, pm_parser_t *parser);
+void pm_parser_metadata(pm_parser_t *parser, const char *metadata);
 
 // The prism version and the serialization format.
 PRISM_EXPORTED_FUNCTION const char * pm_version(void);
@@ -59,15 +59,15 @@ PRISM_EXPORTED_FUNCTION void pm_parser_free(pm_parser_t *parser);
 // Parse the Ruby source associated with the given parser and return the tree.
 PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse(pm_parser_t *parser);
 
-// Pretty-prints the AST represented by the given node to the given buffer.
-PRISM_EXPORTED_FUNCTION void pm_prettyprint(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer);
-
 // Serialize the AST represented by the given node to the given buffer.
 PRISM_EXPORTED_FUNCTION void pm_serialize(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer);
 
 // Parse the given source to the AST and serialize the AST to the given buffer.
 PRISM_EXPORTED_FUNCTION void pm_parse_serialize(const uint8_t *source, size_t size, pm_buffer_t *buffer, const char *metadata);
 
+// Parse and serialize the comments in the given source to the given buffer.
+PRISM_EXPORTED_FUNCTION void pm_parse_serialize_comments(const uint8_t *source, size_t size, pm_buffer_t *buffer, const char *metadata);
+
 // Lex the given source and serialize to the given buffer.
 PRISM_EXPORTED_FUNCTION void pm_lex_serialize(const uint8_t *source, size_t size, const char *filepath, pm_buffer_t *buffer);
 

data/lib/prism/compiler.rb

@@ -393,9 +393,6 @@ module Prism
     # Compile a RegularExpressionNode node
     alias visit_regular_expression_node visit_child_nodes
 
-    # Compile a RequiredDestructuredParameterNode node
-    alias visit_required_destructured_parameter_node visit_child_nodes
-
     # Compile a RequiredParameterNode node
     alias visit_required_parameter_node visit_child_nodes
 

data/lib/prism/debug.rb

@@ -52,9 +52,21 @@ module Prism
         stack = [ISeq.new(RubyVM::InstructionSequence.compile(source).to_a)]
 
         while (iseq = stack.pop)
-          # For some reason, CRuby occasionally pushes this special local
-          # variable when there are splat arguments. We get rid of that here.
-          locals << (iseq.local_table - [:"#arg_rest"])
+          names = [*iseq.local_table]
+          names.map!.with_index do |name, index|
+            # When an anonymous local variable is present in the iseq's local
+            # table, it is represented as the stack offset from the top.
+            # However, when these are dumped to binary and read back in, they
+            # are replaced with the symbol :#arg_rest. To consistently handle
+            # this, we replace them here with their index.
+            if name == :"#arg_rest"
+              names.length - index + 1
+            else
+              name
+            end
+          end
+
+          locals << names
           iseq.each_child { |child| stack << child }
         end
 
@@ -110,11 +122,13 @@ module Prism
 
             # Recurse down the parameter tree to find any destructured
             # parameters and add them after the other parameters.
-            param_stack = params.requireds.concat(params.posts).grep(RequiredDestructuredParameterNode).reverse
+            param_stack = params.requireds.concat(params.posts).grep(MultiTargetNode).reverse
             while (param = param_stack.pop)
               case param
-              when RequiredDestructuredParameterNode
-                param_stack.concat(param.parameters.reverse)
+              when MultiTargetNode
+                param_stack.concat(param.rights.reverse)
+                param_stack << param.rest
+                param_stack.concat(param.lefts.reverse)
               when RequiredParameterNode
                 sorted << param.name
               when SplatNode

data/lib/prism/desugar_compiler.rb

@@ -161,7 +161,7 @@ module Prism
           nil,
           node.operator_loc.copy(length: node.operator_loc.length - 1),
           nil,
-          ArgumentsNode.new([node.value], node.value.location),
+          ArgumentsNode.new([node.value], 0, node.value.location),
           nil,
           nil,
           0,

data/lib/prism/dispatcher.rb

@@ -1008,14 +1008,6 @@ module Prism
       listeners[:on_regular_expression_node_leave]&.each { |listener| listener.on_regular_expression_node_leave(node) }
     end
 
-    # Dispatch enter and leave events for RequiredDestructuredParameterNode nodes and continue
-    # walking the tree.
-    def visit_required_destructured_parameter_node(node)
-      listeners[:on_required_destructured_parameter_node_enter]&.each { |listener| listener.on_required_destructured_parameter_node_enter(node) }
-      super
-      listeners[:on_required_destructured_parameter_node_leave]&.each { |listener| listener.on_required_destructured_parameter_node_leave(node) }
-    end
-
     # Dispatch enter and leave events for RequiredParameterNode nodes and continue
     # walking the tree.
     def visit_required_parameter_node(node)
@@ -1931,12 +1923,6 @@ module Prism
         listeners[:on_regular_expression_node_leave]&.each { |listener| listener.on_regular_expression_node_leave(node) }
       end
 
-      # Dispatch enter and leave events for RequiredDestructuredParameterNode nodes.
-      def visit_required_destructured_parameter_node(node)
-        listeners[:on_required_destructured_parameter_node_enter]&.each { |listener| listener.on_required_destructured_parameter_node_enter(node) }
-        listeners[:on_required_destructured_parameter_node_leave]&.each { |listener| listener.on_required_destructured_parameter_node_leave(node) }
-      end
-
       # Dispatch enter and leave events for RequiredParameterNode nodes.
       def visit_required_parameter_node(node)
         listeners[:on_required_parameter_node_enter]&.each { |listener| listener.on_required_parameter_node_enter(node) }

data/lib/prism/dsl.rb

@@ -63,8 +63,8 @@ module Prism
     end
 
     # Create a new ArgumentsNode node
-    def ArgumentsNode(arguments, location = Location())
-      ArgumentsNode.new(arguments, location)
+    def ArgumentsNode(arguments, flags, location = Location())
+      ArgumentsNode.new(arguments, flags, location)
     end
 
     # Create a new ArrayNode node
@@ -358,8 +358,8 @@ module Prism
     end
 
     # Create a new HashPatternNode node
-    def HashPatternNode(constant, assocs, kwrest, opening_loc, closing_loc, location = Location())
-      HashPatternNode.new(constant, assocs, kwrest, opening_loc, closing_loc, location)
+    def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location = Location())
+      HashPatternNode.new(constant, elements, rest, opening_loc, closing_loc, location)
     end
 
     # Create a new IfNode node
@@ -538,13 +538,13 @@ module Prism
     end
 
     # Create a new MultiTargetNode node
-    def MultiTargetNode(targets, lparen_loc, rparen_loc, location = Location())
-      MultiTargetNode.new(targets, lparen_loc, rparen_loc, location)
+    def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location = Location())
+      MultiTargetNode.new(lefts, rest, rights, lparen_loc, rparen_loc, location)
     end
 
     # Create a new MultiWriteNode node
-    def MultiWriteNode(targets, lparen_loc, rparen_loc, operator_loc, value, location = Location())
-      MultiWriteNode.new(targets, lparen_loc, rparen_loc, operator_loc, value, location)
+    def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location = Location())
+      MultiWriteNode.new(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location)
     end
 
     # Create a new NextNode node
@@ -632,11 +632,6 @@ module Prism
       RegularExpressionNode.new(opening_loc, content_loc, closing_loc, unescaped, flags, location)
     end
 
-    # Create a new RequiredDestructuredParameterNode node
-    def RequiredDestructuredParameterNode(parameters, opening_loc, closing_loc, location = Location())
-      RequiredDestructuredParameterNode.new(parameters, opening_loc, closing_loc, location)
-    end
-
     # Create a new RequiredParameterNode node
     def RequiredParameterNode(name, location = Location())
       RequiredParameterNode.new(name, location)

data/lib/prism/ffi.rb

@@ -70,6 +70,7 @@ module Prism
       "prism.h",
       "pm_version",
       "pm_parse_serialize",
+      "pm_parse_serialize_comments",
       "pm_lex_serialize",
       "pm_parse_lex_serialize"
     )
@@ -224,6 +225,30 @@ module Prism
     end
   end
 
+  # Mirror the Prism.parse_comments API by using the serialization API.
+  def self.parse_comments(code, filepath = nil)
+    LibRubyParser::PrismBuffer.with do |buffer|
+      metadata = [filepath.bytesize, filepath.b, 0].pack("LA*L") if filepath
+      LibRubyParser.pm_parse_serialize_comments(code, code.bytesize, buffer.pointer, metadata)
+
+      source = Source.new(code)
+      loader = Serialize::Loader.new(source, buffer.read)
+
+      loader.load_header
+      loader.load_force_encoding
+      loader.load_comments
+    end
+  end
+
+  # Mirror the Prism.parse_file_comments API by using the serialization
+  # API. This uses native strings instead of Ruby strings because it allows us
+  # to use mmap when it is available.
+  def self.parse_file_comments(filepath)
+    LibRubyParser::PrismString.with(filepath) do |string|
+      parse_comments(string.read, filepath)
+    end
+  end
+
   # Mirror the Prism.parse_lex API by using the serialization API.
   def self.parse_lex(code, filepath = nil)
     LibRubyParser::PrismBuffer.with do |buffer|

data/lib/prism/lex_compat.rb

@@ -529,7 +529,7 @@ module Prism
                     line.each_char.with_index do |char, i|
                       case char
                       when "\r"
-                        if line.chars[i + 1] == "\n"
+                        if line[i + 1] == "\n"
                           break
                         end
                       when "\n"