yarp 0.11.0 → 0.12.0

data/src/serialize.c

@@ -67,10 +67,16 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
         // it is not part of the AST
         case YP_SCOPE_NODE:
             return;
-        case YP_ALIAS_NODE: {
-            yp_serialize_node(parser, (yp_node_t *)((yp_alias_node_t *)node)->new_name, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_alias_node_t *)node)->old_name, buffer);
-            yp_serialize_location(parser, &((yp_alias_node_t *)node)->keyword_loc, buffer);
+        case YP_ALIAS_GLOBAL_VARIABLE_NODE: {
+            yp_serialize_node(parser, (yp_node_t *)((yp_alias_global_variable_node_t *)node)->new_name, buffer);
+            yp_serialize_node(parser, (yp_node_t *)((yp_alias_global_variable_node_t *)node)->old_name, buffer);
+            yp_serialize_location(parser, &((yp_alias_global_variable_node_t *)node)->keyword_loc, buffer);
+            break;
+        }
+        case YP_ALIAS_METHOD_NODE: {
+            yp_serialize_node(parser, (yp_node_t *)((yp_alias_method_node_t *)node)->new_name, buffer);
+            yp_serialize_node(parser, (yp_node_t *)((yp_alias_method_node_t *)node)->old_name, buffer);
+            yp_serialize_location(parser, &((yp_alias_method_node_t *)node)->keyword_loc, buffer);
             break;
         }
         case YP_ALTERNATION_PATTERN_NODE: {
@@ -323,7 +329,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
                 yp_buffer_append_u8(buffer, 1);
                 yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->closing_loc, buffer);
             }
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             yp_serialize_string(parser, &((yp_call_and_write_node_t *)node)->read_name, buffer);
             yp_serialize_string(parser, &((yp_call_and_write_node_t *)node)->write_name, buffer);
             yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->operator_loc, buffer);
@@ -370,7 +376,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_call_node_t *)node)->block, buffer);
             }
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             yp_serialize_string(parser, &((yp_call_node_t *)node)->name, buffer);
             break;
         }
@@ -409,7 +415,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
                 yp_buffer_append_u8(buffer, 1);
                 yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->closing_loc, buffer);
             }
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             yp_serialize_string(parser, &((yp_call_operator_write_node_t *)node)->read_name, buffer);
             yp_serialize_string(parser, &((yp_call_operator_write_node_t *)node)->write_name, buffer);
             yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_call_operator_write_node_t *)node)->operator));
@@ -452,7 +458,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
                 yp_buffer_append_u8(buffer, 1);
                 yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->closing_loc, buffer);
             }
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             yp_serialize_string(parser, &((yp_call_or_write_node_t *)node)->read_name, buffer);
             yp_serialize_string(parser, &((yp_call_or_write_node_t *)node)->write_name, buffer);
             yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->operator_loc, buffer);
@@ -799,7 +805,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
                 yp_serialize_node(parser, (yp_node_t *)((yp_flip_flop_node_t *)node)->right, buffer);
             }
             yp_serialize_location(parser, &((yp_flip_flop_node_t *)node)->operator_loc, buffer);
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             break;
         }
         case YP_FLOAT_NODE: {
@@ -945,6 +951,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             yp_serialize_node(parser, (yp_node_t *)((yp_imaginary_node_t *)node)->numeric, buffer);
             break;
         }
+        case YP_IMPLICIT_NODE: {
+            yp_serialize_node(parser, (yp_node_t *)((yp_implicit_node_t *)node)->value, buffer);
+            break;
+        }
         case YP_IN_NODE: {
             yp_serialize_node(parser, (yp_node_t *)((yp_in_node_t *)node)->pattern, buffer);
             if (((yp_in_node_t *)node)->statements == NULL) {
@@ -999,6 +1009,18 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             break;
         }
         case YP_INTEGER_NODE: {
+            yp_buffer_append_u32(buffer, node->flags >> 2);
+            break;
+        }
+        case YP_INTERPOLATED_MATCH_LAST_LINE_NODE: {
+            yp_serialize_location(parser, &((yp_interpolated_match_last_line_node_t *)node)->opening_loc, buffer);
+            uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_match_last_line_node_t *)node)->parts.size);
+            yp_buffer_append_u32(buffer, parts_size);
+            for (uint32_t index = 0; index < parts_size; index++) {
+                yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_match_last_line_node_t *)node)->parts.nodes[index], buffer);
+            }
+            yp_serialize_location(parser, &((yp_interpolated_match_last_line_node_t *)node)->closing_loc, buffer);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             break;
         }
         case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
@@ -1009,7 +1031,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
                 yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_regular_expression_node_t *)node)->parts.nodes[index], buffer);
             }
             yp_serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             break;
         }
         case YP_INTERPOLATED_STRING_NODE: {
@@ -1155,6 +1177,14 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             yp_serialize_location(parser, &((yp_local_variable_write_node_t *)node)->operator_loc, buffer);
             break;
         }
+        case YP_MATCH_LAST_LINE_NODE: {
+            yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->opening_loc, buffer);
+            yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->content_loc, buffer);
+            yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->closing_loc, buffer);
+            yp_serialize_string(parser, &((yp_match_last_line_node_t *)node)->unescaped, buffer);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
+            break;
+        }
         case YP_MATCH_PREDICATE_NODE: {
             yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->value, buffer);
             yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->pattern, buffer);
@@ -1167,6 +1197,15 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             yp_serialize_location(parser, &((yp_match_required_node_t *)node)->operator_loc, buffer);
             break;
         }
+        case YP_MATCH_WRITE_NODE: {
+            yp_serialize_node(parser, (yp_node_t *)((yp_match_write_node_t *)node)->call, buffer);
+            uint32_t locals_size = yp_sizet_to_u32(((yp_match_write_node_t *)node)->locals.size);
+            yp_buffer_append_u32(buffer, locals_size);
+            for (uint32_t index = 0; index < locals_size; index++) {
+                yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_match_write_node_t *)node)->locals.ids[index]));
+            }
+            break;
+        }
         case YP_MISSING_NODE: {
             break;
         }
@@ -1274,16 +1313,16 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             for (uint32_t index = 0; index < optionals_size; index++) {
                 yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->optionals.nodes[index], buffer);
             }
-            uint32_t posts_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->posts.size);
-            yp_buffer_append_u32(buffer, posts_size);
-            for (uint32_t index = 0; index < posts_size; index++) {
-                yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->posts.nodes[index], buffer);
-            }
             if (((yp_parameters_node_t *)node)->rest == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_parameters_node_t *)node)->rest, buffer);
             }
+            uint32_t posts_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->posts.size);
+            yp_buffer_append_u32(buffer, posts_size);
+            for (uint32_t index = 0; index < posts_size; index++) {
+                yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->posts.nodes[index], buffer);
+            }
             uint32_t keywords_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->keywords.size);
             yp_buffer_append_u32(buffer, keywords_size);
             for (uint32_t index = 0; index < keywords_size; index++) {
@@ -1366,7 +1405,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
                 yp_serialize_node(parser, (yp_node_t *)((yp_range_node_t *)node)->right, buffer);
             }
             yp_serialize_location(parser, &((yp_range_node_t *)node)->operator_loc, buffer);
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             break;
         }
         case YP_RATIONAL_NODE: {
@@ -1381,7 +1420,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->content_loc, buffer);
             yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->closing_loc, buffer);
             yp_serialize_string(parser, &((yp_regular_expression_node_t *)node)->unescaped, buffer);
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             break;
         }
         case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
@@ -1510,6 +1549,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             break;
         }
         case YP_STRING_NODE: {
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             if (((yp_string_node_t *)node)->opening_loc.start == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
@@ -1621,7 +1661,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_until_node_t *)node)->statements, buffer);
             }
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             break;
         }
         case YP_WHEN_NODE: {
@@ -1652,7 +1692,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_while_node_t *)node)->statements, buffer);
             }
-            yp_buffer_append_u32(buffer, node->flags >> 1);
+            yp_buffer_append_u32(buffer, node->flags >> 2);
             break;
         }
         case YP_X_STRING_NODE: {

data/src/util/yp_char.c

@@ -123,6 +123,9 @@ yp_char_is_inline_whitespace(const uint8_t b) {
     return yp_char_is_char_kind(b, YP_CHAR_BIT_INLINE_WHITESPACE);
 }
 
+// Scan through the string and return the number of characters at the start of
+// the string that match the given kind. Disallows searching past the given
+// maximum number of characters.
 static inline size_t
 yp_strspn_number_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
     if (length <= 0) return 0;
@@ -134,20 +137,57 @@ yp_strspn_number_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
     return size;
 }
 
+// Scan through the string and return the number of characters at the start of
+// the string that match the given kind. Disallows searching past the given
+// maximum number of characters.
+//
+// Additionally, report the location of the last invalid underscore character
+// found in the string through the out invalid parameter.
+static inline size_t
+yp_strspn_number_kind_underscores(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid, uint8_t kind) {
+    if (length <= 0) return 0;
+
+    size_t size = 0;
+    size_t maximum = (size_t) length;
+
+    bool underscore = false;
+    while (size < maximum && (yp_number_table[string[size]] & kind)) {
+        if (string[size] == '_') {
+            if (underscore) *invalid = string + size;
+            underscore = true;
+        } else {
+            underscore = false;
+        }
+
+        size++;
+    }
+
+    if (string[size - 1] == '_') *invalid = string + size - 1;
+    return size;
+}
+
 // Returns the number of characters at the start of the string that are binary
 // digits or underscores. Disallows searching past the given maximum number of
 // characters.
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
 size_t
-yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_BINARY_NUMBER);
+yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_BINARY_NUMBER);
 }
 
 // Returns the number of characters at the start of the string that are octal
-// digits or underscores.  Disallows searching past the given maximum number of
+// digits or underscores. Disallows searching past the given maximum number of
 // characters.
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
 size_t
-yp_strspn_octal_number(const uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_OCTAL_NUMBER);
+yp_strspn_octal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_OCTAL_NUMBER);
 }
 
 // Returns the number of characters at the start of the string that are decimal
@@ -160,9 +200,13 @@ yp_strspn_decimal_digit(const uint8_t *string, ptrdiff_t length) {
 // Returns the number of characters at the start of the string that are decimal
 // digits or underscores. Disallows searching past the given maximum number of
 // characters.
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
 size_t
-yp_strspn_decimal_number(const uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_DECIMAL_NUMBER);
+yp_strspn_decimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_DECIMAL_NUMBER);
 }
 
 // Returns the number of characters at the start of the string that are
@@ -176,9 +220,13 @@ yp_strspn_hexadecimal_digit(const uint8_t *string, ptrdiff_t length) {
 // Returns the number of characters at the start of the string that are
 // hexadecimal digits or underscores. Disallows searching past the given maximum
 // number of characters.
+//
+// If multiple underscores are found in a row or if an underscore is
+// found at the end of the number, then the invalid pointer is set to the index
+// of the first invalid underscore.
 size_t
-yp_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_HEXADECIMAL_NUMBER);
+yp_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_HEXADECIMAL_NUMBER);
 }
 
 static inline bool

data/src/util/yp_constant_pool.c

@@ -59,10 +59,42 @@ yp_constant_pool_hash(const uint8_t *start, size_t length) {
     return value;
 }
 
+// https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+static size_t
+next_power_of_two(size_t v) {
+    // Avoid underflow in subtraction on next line.
+    if (v == 0) {
+        // 1 is the nearest power of 2 to 0 (2^0)
+        return 1;
+    }
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+#if defined(__LP64__) || defined(_WIN64)
+    v |= v >> 32;
+#endif
+    v++;
+    return v;
+}
+
+#ifndef NDEBUG
+static bool
+is_power_of_two(size_t size) {
+    return (size & (size - 1)) == 0;
+}
+#endif
+
 // Resize a constant pool to a given capacity.
 static inline bool
 yp_constant_pool_resize(yp_constant_pool_t *pool) {
+    assert(is_power_of_two(pool->capacity));
     size_t next_capacity = pool->capacity * 2;
+    if (next_capacity < pool->capacity) return false;
+
+    const size_t mask = next_capacity - 1;
     yp_constant_t *next_constants = calloc(next_capacity, sizeof(yp_constant_t));
     if (next_constants == NULL) return false;
 
@@ -74,13 +106,13 @@ yp_constant_pool_resize(yp_constant_pool_t *pool) {
         // If an id is set on this constant, then we know we have content here.
         // In this case we need to insert it into the next constant pool.
         if (constant->id != 0) {
-            size_t next_index = constant->hash % next_capacity;
+            size_t next_index = constant->hash & mask;
 
             // This implements linear scanning to find the next available slot
             // in case this index is already taken. We don't need to bother
             // comparing the values since we know that the hash is unique.
             while (next_constants[next_index].id != 0) {
-                next_index = (next_index + 1) % next_capacity;
+                next_index = (next_index + 1) & mask;
             }
 
             // Here we copy over the entire constant, which includes the id so
@@ -98,6 +130,10 @@ yp_constant_pool_resize(yp_constant_pool_t *pool) {
 // Initialize a new constant pool with a given capacity.
 bool
 yp_constant_pool_init(yp_constant_pool_t *pool, size_t capacity) {
+    const size_t size_t_max = (~((size_t) 0));
+    if (capacity >= ((size_t_max / 2) + 1)) return false;
+
+    capacity = next_power_of_two(capacity);
     pool->constants = calloc(capacity, sizeof(yp_constant_t));
     if (pool->constants == NULL) return false;
 
@@ -107,14 +143,16 @@ yp_constant_pool_init(yp_constant_pool_t *pool, size_t capacity) {
 }
 
 // Insert a constant into a constant pool and return its index in the pool.
-static size_t
-yp_constant_pool_insert(yp_constant_pool_t *pool, const uint8_t *start, size_t length) {
+static inline yp_constant_id_t
+yp_constant_pool_insert(yp_constant_pool_t *pool, const uint8_t *start, size_t length, bool owned) {
     if (pool->size >= (pool->capacity / 4 * 3)) {
-        if (!yp_constant_pool_resize(pool)) return pool->capacity;
+        if (!yp_constant_pool_resize(pool)) return 0;
     }
 
+    assert(is_power_of_two(pool->capacity));
+    const size_t mask = pool->capacity - 1;
     size_t hash = yp_constant_pool_hash(start, length);
-    size_t index = hash % pool->capacity;
+    size_t index = hash & mask;
     yp_constant_t *constant;
 
     while (constant = &pool->constants[index], constant->id != 0) {
@@ -122,31 +160,49 @@ yp_constant_pool_insert(yp_constant_pool_t *pool, const uint8_t *start, size_t l
         // same as the content we are trying to insert. If it is, then we can
         // return the id of the existing constant.
         if ((constant->length == length) && memcmp(constant->start, start, length) == 0) {
-            return index;
+            // 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 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 (constant->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;
+                constant->owned = false;
+            }
+
+            return constant->id;
         }
 
-        index = (index + 1) % pool->capacity;
+        index = (index + 1) & mask;
     }
 
     pool->size++;
     assert(pool->size < ((size_t) (1 << 31)));
 
-    pool->constants[index] = (yp_constant_t) {
+    *constant = (yp_constant_t) {
         .id = (unsigned int) (pool->size & 0x7FFFFFFF),
+        .owned = owned,
         .start = start,
         .length = length,
         .hash = hash
     };
 
-    return index;
+    return constant->id;
 }
 
 // Insert a constant into a constant pool. Returns the id of the constant, or 0
 // if any potential calls to resize fail.
 yp_constant_id_t
 yp_constant_pool_insert_shared(yp_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    size_t index = yp_constant_pool_insert(pool, start, length);
-    return index == pool->capacity ? 0 : ((yp_constant_id_t) pool->constants[index].id);
+    return yp_constant_pool_insert(pool, start, length, false);
 }
 
 // Insert a constant into a constant pool from memory that is now owned by the
@@ -154,12 +210,7 @@ yp_constant_pool_insert_shared(yp_constant_pool_t *pool, const uint8_t *start, s
 // resize fail.
 yp_constant_id_t
 yp_constant_pool_insert_owned(yp_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    size_t index = yp_constant_pool_insert(pool, start, length);
-    if (index == pool->capacity) return 0;
-
-    yp_constant_t *constant = &pool->constants[index];
-    constant->owned = true;
-    return ((yp_constant_id_t) constant->id);
+    return yp_constant_pool_insert(pool, start, length, true);
 }
 
 // Free the memory associated with a constant pool.