Support parsing numbered parameters

Author: kddnewton

include/yarp/diagnostic.h

@@ -150,6 +150,7 @@ typedef enum {
     YP_ERR_MULTI_ASSIGN_MULTI_SPLATS,
     YP_ERR_NOT_EXPRESSION,
     YP_ERR_NUMBER_LITERAL_UNDERSCORE,
+    YP_ERR_NUMBERED_PARAMETER_NOT_ALLOWED,
     YP_ERR_OPERATOR_MULTI_ASSIGN,
     YP_ERR_OPERATOR_WRITE_BLOCK,
     YP_ERR_PARAMETER_ASSOC_SPLAT_MULTI,

lib/yarp.rb

@@ -440,10 +440,6 @@ def self.cruby_locals(source)
             # arguments. We get rid of that here.
             names = names.grep_v(Integer)
 
-            # TODO: We don't support numbered local variables yet, so we get rid
-            # of those here.
-            names = names.grep_v(/^_\d$/)
-
             # For some reason, CRuby occasionally pushes this special local
             # variable when there are splat arguments. We get rid of that here.
             names = names.grep_v(:"#arg_rest")

src/diagnostic.c

@@ -184,8 +184,9 @@ static const char* const diagnostic_messages[YP_DIAGNOSTIC_ID_LEN] = {
     [YP_ERR_MULTI_ASSIGN_MULTI_SPLATS]          = "Multiple splats in multiple assignment",
     [YP_ERR_NOT_EXPRESSION]                     = "Expected an expression after `not`",
     [YP_ERR_NUMBER_LITERAL_UNDERSCORE]          = "Number literal ending with a `_`",
-    [YP_ERR_OPERATOR_WRITE_BLOCK]               = "Unexpected operator after a call with a block",
+    [YP_ERR_NUMBERED_PARAMETER_NOT_ALLOWED]     = "Numbered parameters are not allowed alongside explicit parameters",
     [YP_ERR_OPERATOR_MULTI_ASSIGN]              = "Unexpected operator for a multiple assignment",
+    [YP_ERR_OPERATOR_WRITE_BLOCK]               = "Unexpected operator after a call with a block",
     [YP_ERR_PARAMETER_ASSOC_SPLAT_MULTI]        = "Unexpected multiple `**` splat parameters",
     [YP_ERR_PARAMETER_BLOCK_MULTI]              = "Multiple block parameters; only one block is allowed",
     [YP_ERR_PARAMETER_NAME_REPEAT]              = "Repeated parameter name",

src/util/yp_constant_pool.c

@@ -107,10 +107,10 @@ 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;
     }
 
     size_t hash = yp_constant_pool_hash(start, length);
@@ -122,7 +122,24 @@ 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;
+            }
+
+            return constant->id;
         }
 
         index = (index + 1) % pool->capacity;
@@ -131,35 +148,30 @@ yp_constant_pool_insert(yp_constant_pool_t *pool, const uint8_t *start, size_t l
     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 & 0x1,
         .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
 // 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_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.

src/yarp.c

@@ -10111,6 +10111,30 @@ parse_variable_call(yp_parser_t *parser) {
             return (yp_node_t *) yp_local_variable_read_node_create(parser, &parser->previous, (uint32_t) depth);
         }
 
+        if (!parser->current_scope->closed && token_is_numbered_parameter(parser->previous.start, parser->previous.end)) {
+            // Now that we know we have a numbered parameter, we need to check
+            // if it's allowed in this context. If it is, then we will create a
+            // local variable read. If it's not, then we'll create a normal call
+            // node but add an error.
+            if (parser->current_scope->explicit_params) {
+                yp_diagnostic_list_append(&parser->error_list, parser->previous.start, parser->previous.end, YP_ERR_NUMBERED_PARAMETER_NOT_ALLOWED);
+            } else {
+                uint8_t number = parser->previous.start[1];
+                uint8_t current = '1';
+                uint8_t *value;
+
+                while (current < number) {
+                    value = malloc(2);
+                    value[0] = '_';
+                    value[1] = current++;
+                    yp_parser_local_add_owned(parser, value, 2);
+                }
+
+                yp_parser_local_add_token(parser, &parser->previous);
+                return (yp_node_t *) yp_local_variable_read_node_create(parser, &parser->previous, 0);
+            }
+        }
+
         flags |= YP_CALL_NODE_FLAGS_VARIABLE_CALL;
     }