prism 0.14.0 → 0.15.1

data/src/serialize.c

@@ -179,6 +179,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             break;
         }
         case PM_BACK_REFERENCE_READ_NODE: {
+            pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_back_reference_read_node_t *)node)->name));
             break;
         }
         case PM_BEGIN_NODE: {
@@ -312,23 +313,6 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
                 pm_buffer_append_u8(buffer, 1);
                 pm_serialize_location(parser, &((pm_call_and_write_node_t *)node)->message_loc, buffer);
             }
-            if (((pm_call_and_write_node_t *)node)->opening_loc.start == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_buffer_append_u8(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_and_write_node_t *)node)->opening_loc, buffer);
-            }
-            if (((pm_call_and_write_node_t *)node)->arguments == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_serialize_node(parser, (pm_node_t *)((pm_call_and_write_node_t *)node)->arguments, buffer);
-            }
-            if (((pm_call_and_write_node_t *)node)->closing_loc.start == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_buffer_append_u8(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_and_write_node_t *)node)->closing_loc, buffer);
-            }
             pm_buffer_append_u32(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_call_and_write_node_t *)node)->read_name));
             pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_call_and_write_node_t *)node)->write_name));
@@ -398,23 +382,6 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
                 pm_buffer_append_u8(buffer, 1);
                 pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->message_loc, buffer);
             }
-            if (((pm_call_operator_write_node_t *)node)->opening_loc.start == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_buffer_append_u8(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->opening_loc, buffer);
-            }
-            if (((pm_call_operator_write_node_t *)node)->arguments == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_serialize_node(parser, (pm_node_t *)((pm_call_operator_write_node_t *)node)->arguments, buffer);
-            }
-            if (((pm_call_operator_write_node_t *)node)->closing_loc.start == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_buffer_append_u8(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_operator_write_node_t *)node)->closing_loc, buffer);
-            }
             pm_buffer_append_u32(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->read_name));
             pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->write_name));
@@ -441,23 +408,6 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
                 pm_buffer_append_u8(buffer, 1);
                 pm_serialize_location(parser, &((pm_call_or_write_node_t *)node)->message_loc, buffer);
             }
-            if (((pm_call_or_write_node_t *)node)->opening_loc.start == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_buffer_append_u8(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_or_write_node_t *)node)->opening_loc, buffer);
-            }
-            if (((pm_call_or_write_node_t *)node)->arguments == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_serialize_node(parser, (pm_node_t *)((pm_call_or_write_node_t *)node)->arguments, buffer);
-            }
-            if (((pm_call_or_write_node_t *)node)->closing_loc.start == NULL) {
-                pm_buffer_append_u8(buffer, 0);
-            } else {
-                pm_buffer_append_u8(buffer, 1);
-                pm_serialize_location(parser, &((pm_call_or_write_node_t *)node)->closing_loc, buffer);
-            }
             pm_buffer_append_u32(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
             pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_call_or_write_node_t *)node)->read_name));
             pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_call_or_write_node_t *)node)->write_name));
@@ -971,6 +921,94 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
             }
             break;
         }
+        case PM_INDEX_AND_WRITE_NODE: {
+            if (((pm_index_and_write_node_t *)node)->receiver == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->receiver, buffer);
+            }
+            if (((pm_index_and_write_node_t *)node)->call_operator_loc.start == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_buffer_append_u8(buffer, 1);
+                pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->call_operator_loc, buffer);
+            }
+            pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->opening_loc, buffer);
+            if (((pm_index_and_write_node_t *)node)->arguments == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->arguments, buffer);
+            }
+            pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->closing_loc, buffer);
+            if (((pm_index_and_write_node_t *)node)->block == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->block, buffer);
+            }
+            pm_buffer_append_u32(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
+            pm_serialize_location(parser, &((pm_index_and_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->value, buffer);
+            break;
+        }
+        case PM_INDEX_OPERATOR_WRITE_NODE: {
+            if (((pm_index_operator_write_node_t *)node)->receiver == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->receiver, buffer);
+            }
+            if (((pm_index_operator_write_node_t *)node)->call_operator_loc.start == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_buffer_append_u8(buffer, 1);
+                pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->call_operator_loc, buffer);
+            }
+            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->opening_loc, buffer);
+            if (((pm_index_operator_write_node_t *)node)->arguments == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->arguments, buffer);
+            }
+            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->closing_loc, buffer);
+            if (((pm_index_operator_write_node_t *)node)->block == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->block, buffer);
+            }
+            pm_buffer_append_u32(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
+            pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_index_operator_write_node_t *)node)->operator));
+            pm_serialize_location(parser, &((pm_index_operator_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->value, buffer);
+            break;
+        }
+        case PM_INDEX_OR_WRITE_NODE: {
+            if (((pm_index_or_write_node_t *)node)->receiver == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->receiver, buffer);
+            }
+            if (((pm_index_or_write_node_t *)node)->call_operator_loc.start == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_buffer_append_u8(buffer, 1);
+                pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->call_operator_loc, buffer);
+            }
+            pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->opening_loc, buffer);
+            if (((pm_index_or_write_node_t *)node)->arguments == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->arguments, buffer);
+            }
+            pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->closing_loc, buffer);
+            if (((pm_index_or_write_node_t *)node)->block == NULL) {
+                pm_buffer_append_u8(buffer, 0);
+            } else {
+                pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->block, buffer);
+            }
+            pm_buffer_append_u32(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
+            pm_serialize_location(parser, &((pm_index_or_write_node_t *)node)->operator_loc, buffer);
+            pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->value, buffer);
+            break;
+        }
         case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
             pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_instance_variable_and_write_node_t *)node)->name));
             pm_serialize_location(parser, &((pm_instance_variable_and_write_node_t *)node)->name_loc, buffer);
@@ -1834,12 +1872,12 @@ pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer)
             pm_constant_t *constant = &parser->constant_pool.constants[bucket->id - 1];
             size_t buffer_offset = offset + ((((size_t)bucket->id) - 1) * 8);
 
-            if (bucket->owned) {
-                // Since this is an owned constant, we are going to write its
-                // contents into the buffer after the constant pool. So
-                // effectively in place of the source offset, we have a buffer
-                // offset. We will add a leading 1 to indicate that this is a
-                // buffer offset.
+            if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED || bucket->type == PM_CONSTANT_POOL_BUCKET_CONSTANT) {
+                // Since this is an owned or constant constant, we are going to
+                // write its contents into the buffer after the constant pool.
+                // So effectively in place of the source offset, we have a
+                // buffer offset. We will add a leading 1 to indicate that this
+                // is a buffer offset.
                 uint32_t content_offset = pm_sizet_to_u32(buffer->length);
                 uint32_t owned_mask = (uint32_t) (1 << 31);
 

data/src/util/pm_constant_pool.c

@@ -154,9 +154,16 @@ pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity) {
     return true;
 }
 
+// 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) {
+    assert(constant_id > 0 && constant_id <= pool->size);
+    return &pool->constants[constant_id - 1];
+}
+
 // Insert a constant into a constant pool and return its index in the pool.
 static inline pm_constant_id_t
-pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t length, bool owned) {
+pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t length, pm_constant_pool_bucket_type_t type) {
     if (pool->size >= (pool->capacity / 4 * 3)) {
         if (!pm_constant_pool_resize(pool)) return 0;
     }
@@ -178,19 +185,19 @@ pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t l
             // Since we have found a match, we need to check if this is
             // attempting to insert a shared or an owned constant. We want to
             // prefer shared constants since they don't require allocations.
-            if (owned) {
+            if (type == PM_CONSTANT_POOL_BUCKET_OWNED) {
                 // If we're attempting to insert an owned constant and we have
                 // an existing constant, then either way we don't want the given
                 // memory. Either it's duplicated with the existing constant or
                 // it's not necessary because we have a shared version.
                 free((void *) start);
-            } else if (bucket->owned) {
+            } else if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED) {
                 // If we're attempting to insert a shared constant and the
                 // existing constant is owned, then we can free the owned
                 // constant and replace it with the shared constant.
                 free((void *) constant->start);
                 constant->start = start;
-                bucket->owned = false;
+                bucket->type = (unsigned int) (PM_CONSTANT_POOL_BUCKET_DEFAULT & 0x3);
             }
 
             return bucket->id;
@@ -202,15 +209,15 @@ pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t l
     // IDs are allocated starting at 1, since the value 0 denotes a non-existant
     // constant.
     uint32_t id = ++pool->size;
-    assert(pool->size < ((uint32_t) (1 << 31)));
+    assert(pool->size < ((uint32_t) (1 << 30)));
 
     *bucket = (pm_constant_pool_bucket_t) {
-        .id = (unsigned int) (id & 0x7FFFFFFF),
-        .owned = owned,
+        .id = (unsigned int) (id & 0x3fffffff),
+        .type = (unsigned int) (type & 0x3),
         .hash = hash
     };
 
-    pool->constants[id - 1]  = (pm_constant_t) {
+    pool->constants[id - 1] = (pm_constant_t) {
         .start = start,
         .length = length,
     };
@@ -222,7 +229,7 @@ pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t l
 // if any potential calls to resize fail.
 pm_constant_id_t
 pm_constant_pool_insert_shared(pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    return pm_constant_pool_insert(pool, start, length, false);
+    return pm_constant_pool_insert(pool, start, length, PM_CONSTANT_POOL_BUCKET_DEFAULT);
 }
 
 // Insert a constant into a constant pool from memory that is now owned by the
@@ -230,7 +237,14 @@ pm_constant_pool_insert_shared(pm_constant_pool_t *pool, const uint8_t *start, s
 // resize fail.
 pm_constant_id_t
 pm_constant_pool_insert_owned(pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    return pm_constant_pool_insert(pool, start, length, true);
+    return pm_constant_pool_insert(pool, start, length, PM_CONSTANT_POOL_BUCKET_OWNED);
+}
+
+// Insert a constant into a constant pool from memory that is constant. Returns
+// the id of the constant, or 0 if any potential calls to resize fail.
+pm_constant_id_t
+pm_constant_pool_insert_constant(pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
+    return pm_constant_pool_insert(pool, start, length, PM_CONSTANT_POOL_BUCKET_CONSTANT);
 }
 
 // Free the memory associated with a constant pool.
@@ -242,7 +256,7 @@ pm_constant_pool_free(pm_constant_pool_t *pool) {
         pm_constant_pool_bucket_t *bucket = &pool->buckets[index];
 
         // If an id is set on this constant, then we know we have content here.
-        if (bucket->id != 0 && bucket->owned) {
+        if (bucket->id != 0 && bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED) {
             pm_constant_t *constant = &pool->constants[bucket->id - 1];
             free((void *) constant->start);
         }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prism
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-13 00:00:00.000000000 Z
+date: 2023-10-18 00:00:00.000000000 Z
 dependencies: []
 description:
 email: