prism 0.13.0 → 0.14.0

data/lib/prism/node_ext.rb

@@ -52,4 +52,48 @@ module Prism
       o
     end
   end
+
+  class ConstantReadNode < Node
+    # Returns the list of parts for the full name of this constant. For example: [:Foo]
+    def full_name_parts
+      [name]
+    end
+
+    # Returns the full name of this constant. For example: "Foo"
+    def full_name
+      name.name
+    end
+  end
+
+  class ConstantPathNode < Node
+    # Returns the list of parts for the full name of this constant path. For example: [:Foo, :Bar]
+    def full_name_parts
+      parts = [child.name]
+      current = parent
+
+      while current.is_a?(ConstantPathNode)
+        parts.unshift(current.child.name)
+        current = current.parent
+      end
+
+      parts.unshift(current&.name || :"")
+    end
+
+    # Returns the full name of this constant path. For example: "Foo::Bar"
+    def full_name
+      full_name_parts.join("::")
+    end
+  end
+
+  class ConstantPathTargetNode < Node
+    # Returns the list of parts for the full name of this constant path. For example: [:Foo, :Bar]
+    def full_name_parts
+      (parent&.full_name_parts || [:""]).push(child.name)
+    end
+
+    # Returns the full name of this constant path. For example: "Foo::Bar"
+    def full_name
+      full_name_parts.join("::")
+    end
+  end
 end

data/lib/prism/parse_result.rb

@@ -117,7 +117,7 @@ module Prism
     end
 
     def pretty_print(q)
-      q.text("(#{start_line},#{start_column})-(#{end_line},#{end_column}))")
+      q.text("(#{start_line},#{start_column})-(#{end_line},#{end_column})")
     end
 
     def ==(other)
@@ -137,7 +137,7 @@ module Prism
     end
 
     def self.null
-      new(0, 0)
+      new(nil, 0, 0)
     end
   end
 
@@ -166,6 +166,32 @@ module Prism
     end
   end
 
+  # This represents a magic comment that was encountered during parsing.
+  class MagicComment
+    attr_reader :key_loc, :value_loc
+
+    def initialize(key_loc, value_loc)
+      @key_loc = key_loc
+      @value_loc = value_loc
+    end
+
+    def key
+      key_loc.slice
+    end
+
+    def value
+      value_loc.slice
+    end
+
+    def deconstruct_keys(keys)
+      { key_loc: key_loc, value_loc: value_loc }
+    end
+
+    def inspect
+      "#<Prism::MagicComment @key=#{key.inspect} @value=#{value.inspect}>"
+    end
+  end
+
   # This represents an error that was encountered during parsing.
   class ParseError
     attr_reader :message, :location
@@ -206,18 +232,19 @@ module Prism
   # the AST, any comments that were encounters, and any errors that were
   # encountered.
   class ParseResult
-    attr_reader :value, :comments, :errors, :warnings, :source
+    attr_reader :value, :comments, :magic_comments, :errors, :warnings, :source
 
-    def initialize(value, comments, errors, warnings, source)
+    def initialize(value, comments, magic_comments, errors, warnings, source)
       @value = value
       @comments = comments
+      @magic_comments = magic_comments
       @errors = errors
       @warnings = warnings
       @source = source
     end
 
     def deconstruct_keys(keys)
-      { value: value, comments: comments, errors: errors, warnings: warnings }
+      { value: value, comments: comments, magic_comments: magic_comments, errors: errors, warnings: warnings }
     end
 
     def success?

data/lib/prism/pattern.rb

@@ -10,7 +10,7 @@ module Prism
   #     in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
   #     end
   #
-  # the pattern is the `ConstantPathNode[...]` expression.
+  # the pattern is the <tt>ConstantPathNode[...]</tt> expression.
   #
   # The pattern gets compiled into an object that responds to #call by running
   # the #compile method. This method itself will run back through Prism to

data/lib/prism/serialize.rb

@@ -21,7 +21,7 @@ end
 module Prism
   module Serialize
     MAJOR_VERSION = 0
-    MINOR_VERSION = 13
+    MINOR_VERSION = 14
     PATCH_VERSION = 0
 
     def self.load(input, serialized)
@@ -62,9 +62,10 @@ module Prism
 
       def load_metadata
         comments = load_varint.times.map { Comment.new(Comment::TYPES.fetch(load_varint), load_location) }
+        magic_comments = load_varint.times.map { MagicComment.new(load_location, load_location) }
         errors = load_varint.times.map { ParseError.new(load_embedded_string, load_location) }
         warnings = load_varint.times.map { ParseWarning.new(load_embedded_string, load_location) }
-        [comments, errors, warnings]
+        [comments, magic_comments, errors, warnings]
       end
 
       def load_tokens
@@ -83,14 +84,14 @@ module Prism
       def load_tokens_result
         tokens = load_tokens
         encoding = load_encoding
-        comments, errors, warnings = load_metadata
+        comments, magic_comments, errors, warnings = load_metadata
 
         if encoding != @encoding
           tokens.each { |token,| token.value.force_encoding(encoding) }
         end
 
         raise "Expected to consume all bytes while deserializing" unless @io.eof?
-        Prism::ParseResult.new(tokens, comments, errors, warnings, @source)
+        Prism::ParseResult.new(tokens, comments, magic_comments, errors, warnings, @source)
       end
 
       def load_nodes
@@ -104,17 +105,17 @@ module Prism
         @encoding = load_encoding
         @input = input.force_encoding(@encoding).freeze
 
-        comments, errors, warnings = load_metadata
+        comments, magic_comments, errors, warnings = load_metadata
 
         @constant_pool_offset = io.read(4).unpack1("L")
         @constant_pool = Array.new(load_varint, nil)
 
-        [load_node, comments, errors, warnings]
+        [load_node, comments, magic_comments, errors, warnings]
       end
 
       def load_result
-        node, comments, errors, warnings = load_nodes
-        Prism::ParseResult.new(node, comments, errors, warnings, @source)
+        node, comments, magic_comments, errors, warnings = load_nodes
+        Prism::ParseResult.new(node, comments, magic_comments, errors, warnings, @source)
       end
 
       private
@@ -151,13 +152,14 @@ module Prism
       end
 
       def load_string
-        case io.getbyte
+        type = io.getbyte
+        case type
         when 1
           input.byteslice(load_varint, load_varint).force_encoding(encoding)
         when 2
           load_embedded_string
         else
-          raise
+          raise "Unknown serialized string type: #{type}"
         end
       end
 
@@ -239,13 +241,13 @@ module Prism
         when 17 then
           BreakNode.new(load_optional_node, load_location, location)
         when 18 then
-          CallAndWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_string, load_string, load_location, load_node, location)
+          CallAndWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_required_constant, load_required_constant, load_location, load_node, location)
         when 19 then
-          CallNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_optional_node, load_varint, load_string, location)
+          CallNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_optional_node, load_varint, load_required_constant, location)
         when 20 then
-          CallOperatorWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_string, load_string, load_required_constant, load_location, load_node, location)
+          CallOperatorWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_required_constant, load_required_constant, load_required_constant, load_location, load_node, location)
         when 21 then
-          CallOrWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_string, load_string, load_location, load_node, location)
+          CallOrWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_required_constant, load_required_constant, load_location, load_node, location)
         when 22 then
           CapturePatternNode.new(load_node, load_node, load_location, location)
         when 23 then

data/prism.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "prism"
-  spec.version = "0.13.0"
+  spec.version = "0.14.0"
   spec.authors = ["Shopify"]
   spec.email = ["ruby@shopify.com"]
 
@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
     "docs/fuzzing.md",
     "docs/heredocs.md",
     "docs/mapping.md",
+    "docs/prism.png",
     "docs/ripper.md",
     "docs/ruby_api.md",
     "docs/serialization.md",
@@ -46,7 +47,6 @@ Gem::Specification.new do |spec|
     "include/prism/pack.h",
     "include/prism/parser.h",
     "include/prism/regexp.h",
-    "include/prism/unescape.h",
     "include/prism/util/pm_buffer.h",
     "include/prism/util/pm_char.h",
     "include/prism/util/pm_constant_pool.h",
@@ -92,7 +92,6 @@ Gem::Specification.new do |spec|
     "src/regexp.c",
     "src/serialize.c",
     "src/token_type.c",
-    "src/unescape.c",
     "src/util/pm_buffer.c",
     "src/util/pm_char.c",
     "src/util/pm_constant_pool.c",

data/src/diagnostic.c

@@ -265,7 +265,7 @@ pm_diagnostic_message(pm_diagnostic_id_t diag_id) {
 // Append an error to the given list of diagnostic.
 bool
 pm_diagnostic_list_append(pm_list_t *list, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id) {
-    pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) malloc(sizeof(pm_diagnostic_t));
+    pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) calloc(sizeof(pm_diagnostic_t), 1);
     if (diagnostic == NULL) return false;
 
     *diagnostic = (pm_diagnostic_t) { .start = start, .end = end, .message = pm_diagnostic_message(diag_id) };

data/src/node.c

@@ -204,8 +204,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
             if (cast->arguments != NULL) {
                 pm_node_destroy(parser, (pm_node_t *)cast->arguments);
             }
-            pm_string_free(&cast->read_name);
-            pm_string_free(&cast->write_name);
             pm_node_destroy(parser, (pm_node_t *)cast->value);
             break;
         }
@@ -221,7 +219,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
             if (cast->block != NULL) {
                 pm_node_destroy(parser, (pm_node_t *)cast->block);
             }
-            pm_string_free(&cast->name);
             break;
         }
 #line 57 "node.c.erb"
@@ -233,8 +230,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
             if (cast->arguments != NULL) {
                 pm_node_destroy(parser, (pm_node_t *)cast->arguments);
             }
-            pm_string_free(&cast->read_name);
-            pm_string_free(&cast->write_name);
             pm_node_destroy(parser, (pm_node_t *)cast->value);
             break;
         }
@@ -247,8 +242,6 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
             if (cast->arguments != NULL) {
                 pm_node_destroy(parser, (pm_node_t *)cast->arguments);
             }
-            pm_string_free(&cast->read_name);
-            pm_string_free(&cast->write_name);
             pm_node_destroy(parser, (pm_node_t *)cast->value);
             break;
         }
@@ -1263,8 +1256,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
             if (cast->arguments != NULL) {
                 pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
             }
-            memsize->memsize += pm_string_memsize(&cast->read_name);
-            memsize->memsize += pm_string_memsize(&cast->write_name);
             pm_node_memsize_node((pm_node_t *)cast->value, memsize);
             break;
         }
@@ -1281,7 +1272,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
             if (cast->block != NULL) {
                 pm_node_memsize_node((pm_node_t *)cast->block, memsize);
             }
-            memsize->memsize += pm_string_memsize(&cast->name);
             break;
         }
 #line 102 "node.c.erb"
@@ -1294,8 +1284,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
             if (cast->arguments != NULL) {
                 pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
             }
-            memsize->memsize += pm_string_memsize(&cast->read_name);
-            memsize->memsize += pm_string_memsize(&cast->write_name);
             pm_node_memsize_node((pm_node_t *)cast->value, memsize);
             break;
         }
@@ -1309,8 +1297,6 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
             if (cast->arguments != NULL) {
                 pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
             }
-            memsize->memsize += pm_string_memsize(&cast->read_name);
-            memsize->memsize += pm_string_memsize(&cast->write_name);
             pm_node_memsize_node((pm_node_t *)cast->value, memsize);
             break;
         }

data/src/prettyprint.c

@@ -327,14 +327,14 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
                 prettyprint_location(buffer, parser, &((pm_call_and_write_node_t *)node)->closing_loc);
             }
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
-            pm_buffer_append_str(buffer, ", ", 2);            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_bytes(buffer, pm_string_source(&((pm_call_and_write_node_t *)node)->read_name), pm_string_length(&((pm_call_and_write_node_t *)node)->read_name));
-            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_str(buffer, ", ", 2);            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_bytes(buffer, pm_string_source(&((pm_call_and_write_node_t *)node)->write_name), pm_string_length(&((pm_call_and_write_node_t *)node)->write_name));
-            pm_buffer_append_str(buffer, "\"", 1);
+            pm_buffer_append_str(buffer, ", ", 2);            char read_name_buffer[12];
+            snprintf(read_name_buffer, sizeof(read_name_buffer), "%u", ((pm_call_and_write_node_t *)node)->read_name);
+            pm_buffer_append_str(buffer, read_name_buffer, strlen(read_name_buffer));
+            pm_buffer_append_str(buffer, ", ", 2);            char write_name_buffer[12];
+            snprintf(write_name_buffer, sizeof(write_name_buffer), "%u", ((pm_call_and_write_node_t *)node)->write_name);
+            pm_buffer_append_str(buffer, write_name_buffer, strlen(write_name_buffer));
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_location(buffer, parser, &((pm_call_and_write_node_t *)node)->operator_loc);
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_node(buffer, parser, (pm_node_t *)((pm_call_and_write_node_t *)node)->value);
             pm_buffer_append_str(buffer, ")", 1);
@@ -378,11 +378,11 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
                 prettyprint_node(buffer, parser, (pm_node_t *)((pm_call_node_t *)node)->block);
             }
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
-            pm_buffer_append_str(buffer, ", ", 2);            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_bytes(buffer, pm_string_source(&((pm_call_node_t *)node)->name), pm_string_length(&((pm_call_node_t *)node)->name));
-            pm_buffer_append_str(buffer, "\"", 1);
+            pm_buffer_append_str(buffer, ", ", 2);            char name_buffer[12];
+            snprintf(name_buffer, sizeof(name_buffer), "%u", ((pm_call_node_t *)node)->name);
+            pm_buffer_append_str(buffer, name_buffer, strlen(name_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
         }
@@ -419,14 +419,14 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
                 prettyprint_location(buffer, parser, &((pm_call_operator_write_node_t *)node)->closing_loc);
             }
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
-            pm_buffer_append_str(buffer, ", ", 2);            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_bytes(buffer, pm_string_source(&((pm_call_operator_write_node_t *)node)->read_name), pm_string_length(&((pm_call_operator_write_node_t *)node)->read_name));
-            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_str(buffer, ", ", 2);            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_bytes(buffer, pm_string_source(&((pm_call_operator_write_node_t *)node)->write_name), pm_string_length(&((pm_call_operator_write_node_t *)node)->write_name));
-            pm_buffer_append_str(buffer, "\"", 1);
+            pm_buffer_append_str(buffer, ", ", 2);            char read_name_buffer[12];
+            snprintf(read_name_buffer, sizeof(read_name_buffer), "%u", ((pm_call_operator_write_node_t *)node)->read_name);
+            pm_buffer_append_str(buffer, read_name_buffer, strlen(read_name_buffer));
+            pm_buffer_append_str(buffer, ", ", 2);            char write_name_buffer[12];
+            snprintf(write_name_buffer, sizeof(write_name_buffer), "%u", ((pm_call_operator_write_node_t *)node)->write_name);
+            pm_buffer_append_str(buffer, write_name_buffer, strlen(write_name_buffer));
             pm_buffer_append_str(buffer, ", ", 2);            char operator_buffer[12];
             snprintf(operator_buffer, sizeof(operator_buffer), "%u", ((pm_call_operator_write_node_t *)node)->operator);
             pm_buffer_append_str(buffer, operator_buffer, strlen(operator_buffer));
@@ -468,14 +468,14 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
                 prettyprint_location(buffer, parser, &((pm_call_or_write_node_t *)node)->closing_loc);
             }
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
-            pm_buffer_append_str(buffer, ", ", 2);            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_bytes(buffer, pm_string_source(&((pm_call_or_write_node_t *)node)->read_name), pm_string_length(&((pm_call_or_write_node_t *)node)->read_name));
-            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_str(buffer, ", ", 2);            pm_buffer_append_str(buffer, "\"", 1);
-            pm_buffer_append_bytes(buffer, pm_string_source(&((pm_call_or_write_node_t *)node)->write_name), pm_string_length(&((pm_call_or_write_node_t *)node)->write_name));
-            pm_buffer_append_str(buffer, "\"", 1);
+            pm_buffer_append_str(buffer, ", ", 2);            char read_name_buffer[12];
+            snprintf(read_name_buffer, sizeof(read_name_buffer), "%u", ((pm_call_or_write_node_t *)node)->read_name);
+            pm_buffer_append_str(buffer, read_name_buffer, strlen(read_name_buffer));
+            pm_buffer_append_str(buffer, ", ", 2);            char write_name_buffer[12];
+            snprintf(write_name_buffer, sizeof(write_name_buffer), "%u", ((pm_call_or_write_node_t *)node)->write_name);
+            pm_buffer_append_str(buffer, write_name_buffer, strlen(write_name_buffer));
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_location(buffer, parser, &((pm_call_or_write_node_t *)node)->operator_loc);
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_node(buffer, parser, (pm_node_t *)((pm_call_or_write_node_t *)node)->value);
             pm_buffer_append_str(buffer, ")", 1);
@@ -904,7 +904,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
             }
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_location(buffer, parser, &((pm_flip_flop_node_t *)node)->operator_loc);
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -1182,7 +1182,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
         case PM_INTEGER_NODE: {
             pm_buffer_append_str(buffer, "IntegerNode(", 12);
                         char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -1198,7 +1198,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
             pm_buffer_append_str(buffer, "]", 1);
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_location(buffer, parser, &((pm_interpolated_match_last_line_node_t *)node)->closing_loc);
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -1214,7 +1214,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
             pm_buffer_append_str(buffer, "]", 1);
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_location(buffer, parser, &((pm_interpolated_regular_expression_node_t *)node)->closing_loc);
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -1433,7 +1433,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
             pm_buffer_append_bytes(buffer, pm_string_source(&((pm_match_last_line_node_t *)node)->unescaped), pm_string_length(&((pm_match_last_line_node_t *)node)->unescaped));
             pm_buffer_append_str(buffer, "\"", 1);
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -1717,7 +1717,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
             }
             pm_buffer_append_str(buffer, ", ", 2);            prettyprint_location(buffer, parser, &((pm_range_node_t *)node)->operator_loc);
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -1742,7 +1742,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
             pm_buffer_append_bytes(buffer, pm_string_source(&((pm_regular_expression_node_t *)node)->unescaped), pm_string_length(&((pm_regular_expression_node_t *)node)->unescaped));
             pm_buffer_append_str(buffer, "\"", 1);
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -1919,7 +1919,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
         case PM_STRING_NODE: {
             pm_buffer_append_str(buffer, "StringNode(", 11);
                         char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ", ", 2);            if (((pm_string_node_t *)node)->opening_loc.start == NULL) {
                 pm_buffer_append_str(buffer, "nil", 3);
@@ -2041,7 +2041,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
                 prettyprint_node(buffer, parser, (pm_node_t *)((pm_until_node_t *)node)->statements);
             }
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;
@@ -2078,7 +2078,7 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
                 prettyprint_node(buffer, parser, (pm_node_t *)((pm_while_node_t *)node)->statements);
             }
             pm_buffer_append_str(buffer, ", ", 2);            char flags_buffer[12];
-            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", node->flags >> 2);
+            snprintf(flags_buffer, sizeof(flags_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_str(buffer, flags_buffer, strlen(flags_buffer));
             pm_buffer_append_str(buffer, ")", 1);
             break;